Release v0.6.0

As several modifiers are now supported on the same `Style` struct, make sure
that this feature is illustrated in some places of the demo.

.gitignore

@@ -3,3 +3,4 @@ Cargo.lock
 *.log
 *.rs.rustfmt
 .gdb_history
+.idea/

CHANGELOG.md

@@ -2,6 +2,82 @@
 
 ## To be released
 
+## v0.6.0 - 2019-05-18
+
+### Changed
+
+* Update crossterm backend
+
+## v0.5.1 - 2019-04-14
+
+### Fixed
+
+* Fix a panic in the Sparkline widget
+
+## v0.5.0 - 2019-03-10
+
+### Added
+
+* Add a new curses backend (with Windows support thanks to `pancurses`).
+* Add `Backend::get_cursor` and `Backend::set_cursor` methods to query and
+set the position of the cursor.
+* Add more constructors to the `Crossterm` backend.
+* Add a demo for all backends using a shared UI and application state.
+* Add `Ratio` as a new variant of layout `Constraint`. It can be used to define
+exact ratios constraints.
+
+### Changed
+
+* Add support for multiple modifiers on the same `Style` by changing `Modifier`
+from an enum to a bitflags struct.
+
+So instead of writing:
+
+```rust
+let style = Style::default().modifier(Modifier::Italic);
+```
+
+one should use:
+
+```rust
+let style = Style::default().modifier(Modifier::ITALIC);
+// or
+let style = Style::default().modifier(Modifier::ITALIC | Modifier::BOLD);
+```
+
+### Fixed
+
+* Ensure correct behavoir of the alternate screens with the `Crossterm` backend.
+* Fix out of bounds panic when two `Buffer` are merged.
+
+## v0.4.0 - 2019-02-03
+
+### Added
+
+* Add a new canvas shape: `Rectangle`.
+* Official support of `Crossterm` backend.
+* Make it possible to choose the divider between `Tabs`.
+* Add word wrapping on Paragraph.
+* The gauge widget accepts a ratio (f64 between 0 and 1) in addition of a
+percentage.
+
+### Changed
+
+* Upgrade to Rust 2018 edition.
+
+### Fixed
+
+* Fix rendering of double-width characters.
+* Fix race condition on the size of the terminal and expose a size that is
+safe to use when drawing through `Frame::size`.
+* Prevent unsigned int overflow on large screens.
+
+## v0.3.0 - 2018-11-04
+
+### Added
+
+* Add experimental test backend
+
 ## v0.3.0-beta.3 - 2018-09-24
 
 ### Changed

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "tui"
-version = "0.3.0-beta.3"
+version = "0.6.0"
 authors = ["Florian Dehau <work@fdehau.com>"]
 description = """
 A library to build rich terminal user interfaces or dashboards
@@ -10,36 +10,52 @@ repository = "https://github.com/fdehau/tui-rs"
 license = "MIT"
 exclude = ["assets/*", ".travis.yml"]
 autoexamples = true
+edition = "2018"
 
 [badges]
 travis-ci = { repository = "fdehau/tui-rs" }
+appveyor = { repository = "fdehau/tui-rs" }
 
 [features]
 default = ["termion"]
+curses = ["easycurses", "pancurses"]
 
 [dependencies]
 bitflags = "1.0"
 cassowary = "0.3"
-itertools = "0.7"
+itertools = "0.8"
 log = "0.4"
 either = "1.5"
 unicode-segmentation = "1.2"
 unicode-width = "0.1"
 termion = { version = "1.5", optional = true }
 rustbox = { version = "0.11", optional = true }
-crossterm = { version = "0.4", optional = true }
+crossterm = { version = "^0.9", optional = true }
+easycurses = { version = "0.12.2", optional = true }
+pancurses = { version = "0.16.1", optional = true, features = ["win32a"] }
 
 [dev-dependencies]
 stderrlog = "0.4"
-rand = "0.4"
+rand = "0.6"
 failure = "0.1"
+structopt = "0.2"
 
 [[example]]
-name = "rustbox"
-path = "examples/rustbox.rs"
+name = "termion_demo"
+path = "examples/termion_demo.rs"
+required-features = ["termion"]
+
+[[example]]
+name = "rustbox_demo"
+path = "examples/rustbox_demo.rs"
 required-features = ["rustbox"]
 
 [[example]]
-name = "crossterm"
-path = "examples/crossterm.rs"
+name = "crossterm_demo"
+path = "examples/crossterm_demo.rs"
 required-features = ["crossterm"]
+
+[[example]]
+name = "curses_demo"
+path = "examples/curses_demo.rs"
+required-features = ["curses"]

Makefile

@@ -1,5 +1,4 @@
-# Makefile for the tui-rs project (https://github.com/fdehau/tui-rs)
-
+SHELL=/bin/bash
 
 # ================================ Cargo ======================================
 
@@ -52,28 +51,27 @@ fmt: ## Check the format of the source code
 	cargo fmt --all -- --check
 
 .PHONY: clippy
-clippy: RUST_CHANNEL = nightly
 clippy: ## Check the style of the source code and catch common errors
-	$(CARGO) clippy --features="termion rustbox"
+	$(CARGO) clippy --all-features
 
 
 # ================================ Test =======================================
 
 .PHONY: test
 test: ## Run the tests
-	$(CARGO) test --features=termion,crossterm
+	$(CARGO) test --all-features
 
 # =============================== Examples ====================================
 
 .PHONY: build-examples
 build-examples: ## Build all examples
-	@$(CARGO) build --examples --features=termion,crossterm
+	@$(CARGO) build --examples --all-features
 
 .PHONY: run-examples
 run-examples: ## Run all examples
 	@for file in examples/*.rs; do \
-	  name=$$(basename $${file//.rs/}); \
-	  $(CARGO) run --features=termion,crossterm --example $$name; \
+	  name=$$(basename $${file/.rs/}); \
+	  $(CARGO) run --all-features --release --example $$name; \
 	  done;
 
 # ================================ Doc ========================================

README.md

@@ -1,6 +1,7 @@
 # tui-rs
 
 [![Build Status](https://travis-ci.org/fdehau/tui-rs.svg?branch=master)](https://travis-ci.org/fdehau/tui-rs)
+[![Build status](https://ci.appveyor.com/api/projects/status/t724mb1q31xpyxy5/branch/master?svg=true)](https://ci.appveyor.com/project/fdehau/tui-rs/branch/master)
 [![Crate Status](https://img.shields.io/crates/v/tui.svg)](https://crates.io/crates/tui)
 [![Docs Status](https://docs.rs/tui/badge.svg)](https://docs.rs/crate/tui/)
 
@@ -11,13 +12,15 @@ user interfaces and dashboards. It is heavily inspired by the `Javascript`
 library [blessed-contrib](https://github.com/yaronn/blessed-contrib) and the
 `Go` library [termui](https://github.com/gizak/termui).
 
-The library itself supports two different backends to draw to the terminal. You
+The library itself supports four different backends to draw to the terminal. You
 can either choose from:
 
   - [termion](https://github.com/ticki/termion)
   - [rustbox](https://github.com/gchp/rustbox)
+  - [crossterm](https://github.com/TimonPost/crossterm)
+  - [pancurses](https://github.com/ihalila/pancurses)
 
-However, some features may only be available in one of the two.
+However, some features may only be available in one of the four.
 
 The library is based on the principle of immediate rendering with intermediate
 buffers. This means that at each new frame you should build all widgets that are
@@ -34,7 +37,16 @@ you may rely on the previously cited libraries to achieve such features.
 
 ### Demo
 
-The [source code](examples/demo.rs) of the demo gif.
+The demo shown in the gif can be run with all available backends
+(`exmples/*_demo.rs` files). For example to see the `termion` version one could
+run:
+
+```
+cargo run --example termion_demo --release -- --tick-rate 200
+```
+
+The UI code is in [examples/demo/ui.rs](examples/demo/ui.rs) while the
+application state is in [examples/demo/app.rs](examples/demo/app.rs).
 
 ### Widgets
 
@@ -44,7 +56,7 @@ The library comes with the following list of widgets:
   * [Gauge](examples/gauge.rs)
   * [Sparkline](examples/sparkline.rs)
   * [Chart](examples/chart.rs)
-  * [BarChart](examples/bar_chart.rs)
+  * [BarChart](examples/barchart.rs)
   * [List](examples/list.rs)
   * [Table](examples/table.rs)
   * [Paragraph](examples/paragraph.rs)
@@ -54,6 +66,8 @@ The library comes with the following list of widgets:
 Click on each item to see the source of the example. Run the examples with with 
 cargo (e.g. to run the demo `cargo run --example demo`), and quit by pressing `q`.
 
+You can run all examples by running `make run-examples`.
+
 ### Third-party widgets
 
 * [tui-logger](https://github.com/gin66/tui-logger)

appveyor.yml

@@ -0,0 +1,19 @@
+environment:
+  matrix:
+    # Stable channel
+    - TARGET: x86_64-pc-windows-gnu
+      CHANNEL: stable
+    - TARGET: x86_64-pc-windows-msvc
+      CHANNEL: stable
+
+install:
+  - curl -sSf -o rustup-init.exe https://win.rustup.rs
+  - rustup-init.exe --default-host %TARGET% --default-toolchain %CHANNEL% -y
+  - set PATH=%PATH%;C:\Users\appveyor\.cargo\bin
+  - rustc -Vv
+  - cargo -V
+
+build: false
+
+test_script:
+  - cargo build --no-default-features --features crossterm

examples/barchart.rs

@@ -1,7 +1,3 @@
-extern crate failure;
-extern crate termion;
-extern crate tui;
-
 #[allow(dead_code)]
 mod util;
 
@@ -12,22 +8,20 @@ use termion::input::MouseTerminal;
 use termion::raw::IntoRawMode;
 use termion::screen::AlternateScreen;
 use tui::backend::TermionBackend;
-use tui::layout::{Constraint, Direction, Layout, Rect};
+use tui::layout::{Constraint, Direction, Layout};
 use tui::style::{Color, Modifier, Style};
 use tui::widgets::{BarChart, Block, Borders, Widget};
 use tui::Terminal;
 
-use util::event::{Event, Events};
+use crate::util::event::{Event, Events};
 
 struct App<'a> {
-    size: Rect,
     data: Vec<(&'a str, u64)>,
 }
 
 impl<'a> App<'a> {
     fn new() -> App<'a> {
         App {
-            size: Rect::default(),
             data: vec![
                 ("B1", 9),
                 ("B2", 12),
@@ -79,17 +73,12 @@ fn main() -> Result<(), failure::Error> {
     let mut app = App::new();
 
     loop {
-        let size = terminal.size()?;
-        if app.size != size {
-            terminal.resize(size)?;
-            app.size = size;
-        }
         terminal.draw(|mut f| {
             let chunks = Layout::default()
                 .direction(Direction::Vertical)
                 .margin(2)
                 .constraints([Constraint::Percentage(50), Constraint::Percentage(50)].as_ref())
-                .split(app.size);
+                .split(f.size());
             BarChart::default()
                 .block(Block::default().title("Data1").borders(Borders::ALL))
                 .data(&app.data)
@@ -108,7 +97,7 @@ fn main() -> Result<(), failure::Error> {
                     .bar_width(5)
                     .bar_gap(3)
                     .style(Style::default().fg(Color::Green))
-                    .value_style(Style::default().bg(Color::Green).modifier(Modifier::Bold))
+                    .value_style(Style::default().bg(Color::Green).modifier(Modifier::BOLD))
                     .render(&mut f, chunks[0]);
                 BarChart::default()
                     .block(Block::default().title("Data3").borders(Borders::ALL))
@@ -117,15 +106,17 @@ fn main() -> Result<(), failure::Error> {
                     .bar_width(7)
                     .bar_gap(0)
                     .value_style(Style::default().bg(Color::Red))
-                    .label_style(Style::default().fg(Color::Cyan).modifier(Modifier::Italic))
+                    .label_style(Style::default().fg(Color::Cyan).modifier(Modifier::ITALIC))
                     .render(&mut f, chunks[1]);
             }
         })?;
 
         match events.next()? {
-            Event::Input(input) => if input == Key::Char('q') {
-                break;
-            },
+            Event::Input(input) => {
+                if input == Key::Char('q') {
+                    break;
+                }
+            }
             Event::Tick => {
                 app.update();
             }

examples/block.rs

@@ -1,7 +1,3 @@
-extern crate failure;
-extern crate termion;
-extern crate tui;
-
 #[allow(dead_code)]
 mod util;
 
@@ -11,24 +7,12 @@ use termion::input::MouseTerminal;
 use termion::raw::IntoRawMode;
 use termion::screen::AlternateScreen;
 use tui::backend::TermionBackend;
-use tui::layout::{Constraint, Direction, Layout, Rect};
+use tui::layout::{Constraint, Direction, Layout};
 use tui::style::{Color, Modifier, Style};
 use tui::widgets::{Block, Borders, Widget};
 use tui::Terminal;
 
-use util::event::{Event, Events};
-
-struct App {
-    size: Rect,
-}
-
-impl Default for App {
-    fn default() -> App {
-        App {
-            size: Rect::default(),
-        }
-    }
-}
+use crate::util::event::{Event, Events};
 
 fn main() -> Result<(), failure::Error> {
     // Terminal initialization
@@ -39,29 +23,21 @@ fn main() -> Result<(), failure::Error> {
     let mut terminal = Terminal::new(backend)?;
     terminal.hide_cursor()?;
 
-    // Create default app state
-    let mut app = App::default();
-
     // Setup event handlers
     let events = Events::new();
 
     loop {
-        let size = terminal.size()?;
-        if app.size != size {
-            terminal.resize(size)?;
-            app.size = size;
-        }
-
         terminal.draw(|mut f| {
             // Wrapping block for a group
             // Just draw the block and the group on the same area and build the group
             // with at least a margin of 1
+            let size = f.size();
             Block::default().borders(Borders::ALL).render(&mut f, size);
             let chunks = Layout::default()
                 .direction(Direction::Vertical)
                 .margin(4)
                 .constraints([Constraint::Percentage(50), Constraint::Percentage(50)].as_ref())
-                .split(app.size);
+                .split(f.size());
             {
                 let chunks = Layout::default()
                     .direction(Direction::Horizontal)
@@ -78,8 +54,9 @@ fn main() -> Result<(), failure::Error> {
                         Style::default()
                             .fg(Color::White)
                             .bg(Color::Red)
-                            .modifier(Modifier::Bold),
-                    ).render(&mut f, chunks[1]);
+                            .modifier(Modifier::BOLD),
+                    )
+                    .render(&mut f, chunks[1]);
             }
             {
                 let chunks = Layout::default()
@@ -99,9 +76,11 @@ fn main() -> Result<(), failure::Error> {
         })?;
 
         match events.next()? {
-            Event::Input(key) => if key == Key::Char('q') {
-                break;
-            },
+            Event::Input(key) => {
+                if key == Key::Char('q') {
+                    break;
+                }
+            }
             _ => {}
         }
     }

examples/canvas.rs

@@ -1,7 +1,3 @@
-extern crate failure;
-extern crate termion;
-extern crate tui;
-
 #[allow(dead_code)]
 mod util;
 
@@ -15,14 +11,13 @@ use termion::screen::AlternateScreen;
 use tui::backend::TermionBackend;
 use tui::layout::{Constraint, Direction, Layout, Rect};
 use tui::style::Color;
-use tui::widgets::canvas::{Canvas, Line, Map, MapResolution};
+use tui::widgets::canvas::{Canvas, Map, MapResolution, Rectangle};
 use tui::widgets::{Block, Borders, Widget};
 use tui::Terminal;
 
-use util::event::{Config, Event, Events};
+use crate::util::event::{Config, Event, Events};
 
 struct App {
-    size: Rect,
     x: f64,
     y: f64,
     ball: Rect,
@@ -36,7 +31,6 @@ struct App {
 impl App {
     fn new() -> App {
         App {
-            size: Default::default(),
             x: 0.0,
             y: 0.0,
             ball: Rect::new(10, 30, 10, 10),
@@ -92,17 +86,11 @@ fn main() -> Result<(), failure::Error> {
     let mut app = App::new();
 
     loop {
-        let size = terminal.size()?;
-        if size != app.size {
-            terminal.resize(size)?;
-            app.size = size;
-        }
-
         terminal.draw(|mut f| {
             let chunks = Layout::default()
                 .direction(Direction::Horizontal)
                 .constraints([Constraint::Percentage(50), Constraint::Percentage(50)].as_ref())
-                .split(app.size);
+                .split(f.size());
             Canvas::default()
                 .block(Block::default().borders(Borders::ALL).title("World"))
                 .paint(|ctx| {
@@ -111,41 +99,19 @@ fn main() -> Result<(), failure::Error> {
                         resolution: MapResolution::High,
                     });
                     ctx.print(app.x, -app.y, "You are here", Color::Yellow);
-                }).x_bounds([-180.0, 180.0])
+                })
+                .x_bounds([-180.0, 180.0])
                 .y_bounds([-90.0, 90.0])
                 .render(&mut f, chunks[0]);
             Canvas::default()
                 .block(Block::default().borders(Borders::ALL).title("Pong"))
                 .paint(|ctx| {
-                    ctx.draw(&Line {
-                        x1: f64::from(app.ball.left()),
-                        y1: f64::from(app.ball.top()),
-                        x2: f64::from(app.ball.right()),
-                        y2: f64::from(app.ball.top()),
+                    ctx.draw(&Rectangle {
+                        rect: app.ball,
                         color: Color::Yellow,
                     });
-                    ctx.draw(&Line {
-                        x1: f64::from(app.ball.right()),
-                        y1: f64::from(app.ball.top()),
-                        x2: f64::from(app.ball.right()),
-                        y2: f64::from(app.ball.bottom()),
-                        color: Color::Yellow,
-                    });
-                    ctx.draw(&Line {
-                        x1: f64::from(app.ball.right()),
-                        y1: f64::from(app.ball.bottom()),
-                        x2: f64::from(app.ball.left()),
-                        y2: f64::from(app.ball.bottom()),
-                        color: Color::Yellow,
-                    });
-                    ctx.draw(&Line {
-                        x1: f64::from(app.ball.left()),
-                        y1: f64::from(app.ball.bottom()),
-                        x2: f64::from(app.ball.left()),
-                        y2: f64::from(app.ball.top()),
-                        color: Color::Yellow,
-                    });
-                }).x_bounds([10.0, 110.0])
+                })
+                .x_bounds([10.0, 110.0])
                 .y_bounds([10.0, 110.0])
                 .render(&mut f, chunks[1]);
         })?;

examples/chart.rs

@@ -1,7 +1,3 @@
-extern crate failure;
-extern crate termion;
-extern crate tui;
-
 #[allow(dead_code)]
 mod util;
 
@@ -12,16 +8,14 @@ use termion::input::MouseTerminal;
 use termion::raw::IntoRawMode;
 use termion::screen::AlternateScreen;
 use tui::backend::TermionBackend;
-use tui::layout::Rect;
 use tui::style::{Color, Modifier, Style};
 use tui::widgets::{Axis, Block, Borders, Chart, Dataset, Marker, Widget};
 use tui::Terminal;
 
-use util::event::{Event, Events};
-use util::SinSignal;
+use crate::util::event::{Event, Events};
+use crate::util::SinSignal;
 
 struct App {
-    size: Rect,
     signal1: SinSignal,
     data1: Vec<(f64, f64)>,
     signal2: SinSignal,
@@ -36,7 +30,6 @@ impl App {
         let data1 = signal1.by_ref().take(200).collect::<Vec<(f64, f64)>>();
         let data2 = signal2.by_ref().take(200).collect::<Vec<(f64, f64)>>();
         App {
-            size: Rect::default(),
             signal1,
             data1,
             signal2,
@@ -74,38 +67,36 @@ fn main() -> Result<(), failure::Error> {
     let mut app = App::new();
 
     loop {
-        let size = terminal.size()?;
-        if app.size != size {
-            terminal.resize(size)?;
-            app.size = size;
-        }
-
         terminal.draw(|mut f| {
+            let size = f.size();
             Chart::default()
                 .block(
                     Block::default()
                         .title("Chart")
-                        .title_style(Style::default().fg(Color::Cyan).modifier(Modifier::Bold))
+                        .title_style(Style::default().fg(Color::Cyan).modifier(Modifier::BOLD))
                         .borders(Borders::ALL),
-                ).x_axis(
+                )
+                .x_axis(
                     Axis::default()
                         .title("X Axis")
                         .style(Style::default().fg(Color::Gray))
-                        .labels_style(Style::default().modifier(Modifier::Italic))
+                        .labels_style(Style::default().modifier(Modifier::ITALIC))
                         .bounds(app.window)
                         .labels(&[
                             &format!("{}", app.window[0]),
                             &format!("{}", (app.window[0] + app.window[1]) / 2.0),
                             &format!("{}", app.window[1]),
                         ]),
-                ).y_axis(
+                )
+                .y_axis(
                     Axis::default()
                         .title("Y Axis")
                         .style(Style::default().fg(Color::Gray))
-                        .labels_style(Style::default().modifier(Modifier::Italic))
+                        .labels_style(Style::default().modifier(Modifier::ITALIC))
                         .bounds([-20.0, 20.0])
                         .labels(&["-20", "0", "20"]),
-                ).datasets(&[
+                )
+                .datasets(&[
                     Dataset::default()
                         .name("data2")
                         .marker(Marker::Dot)
@@ -116,13 +107,16 @@ fn main() -> Result<(), failure::Error> {
                         .marker(Marker::Braille)
                         .style(Style::default().fg(Color::Yellow))
                         .data(&app.data2),
-                ]).render(&mut f, app.size);
+                ])
+                .render(&mut f, size);
         })?;
 
         match events.next()? {
-            Event::Input(input) => if input == Key::Char('q') {
-                break;
-            },
+            Event::Input(input) => {
+                if input == Key::Char('q') {
+                    break;
+                }
+            }
             Event::Tick => {
                 app.update();
             }

examples/crossterm.rs

@@ -1,59 +0,0 @@
-extern crate crossterm;
-extern crate failure;
-extern crate tui;
-
-use tui::backend::CrosstermBackend;
-use tui::layout::Rect;
-use tui::style::{Color, Modifier, Style};
-use tui::widgets::{Block, Borders, Paragraph, Text, Widget};
-use tui::Terminal;
-
-struct App {
-    size: Rect,
-}
-
-impl Default for App {
-    fn default() -> App {
-        App {
-            size: Rect::default(),
-        }
-    }
-}
-
-fn main() -> Result<(), failure::Error> {
-    let mut terminal = Terminal::new(CrosstermBackend::new())?;
-    terminal.clear()?;
-    terminal.hide_cursor()?;
-    let mut app = App::default();
-    loop {
-        let size = terminal.size()?;
-        if app.size != size {
-            terminal.resize(size)?;
-            app.size = size;
-        }
-
-        terminal.draw(|mut f| {
-            let text = [
-                Text::raw("It "),
-                Text::styled("works", Style::default().fg(Color::Yellow)),
-            ];
-            Paragraph::new(text.iter())
-                .block(
-                    Block::default()
-                        .title("Crossterm Backend")
-                        .title_style(Style::default().fg(Color::Yellow).modifier(Modifier::Bold))
-                        .borders(Borders::ALL)
-                        .border_style(Style::default().fg(Color::Magenta)),
-                ).render(&mut f, size);
-        })?;
-
-        let input = crossterm::input(terminal.backend().screen());
-        match input.read_char()? {
-            'q' => {
-                break;
-            }
-            _ => {}
-        };
-    }
-    Ok(())
-}

examples/crossterm_demo.rs

@@ -0,0 +1,91 @@
+#[allow(dead_code)]
+mod demo;
+#[allow(dead_code)]
+mod util;
+
+use std::sync::mpsc;
+use std::thread;
+use std::time::Duration;
+
+use crossterm;
+use structopt::StructOpt;
+use tui::backend::CrosstermBackend;
+use tui::Terminal;
+
+use crate::demo::{ui, App};
+
+enum Event<I> {
+    Input(I),
+    Tick,
+}
+
+#[derive(Debug, StructOpt)]
+struct Cli {
+    #[structopt(long = "tick-rate", default_value = "250")]
+    tick_rate: u64,
+    #[structopt(long = "log")]
+    log: bool,
+}
+
+fn main() -> Result<(), failure::Error> {
+    let cli = Cli::from_args();
+    stderrlog::new().quiet(!cli.log).verbosity(4).init()?;
+
+    let backend = CrosstermBackend::new();
+    let mut terminal = Terminal::new(backend)?;
+    terminal.hide_cursor()?;
+
+    // Setup input handling
+    let (tx, rx) = mpsc::channel();
+    {
+        let tx = tx.clone();
+        thread::spawn(move || {
+            let input = crossterm::input();
+            loop {
+                match input.read_char() {
+                    Ok(key) => {
+                        if let Err(_) = tx.send(Event::Input(key)) {
+                            return;
+                        }
+                        if key == 'q' {
+                            return;
+                        }
+                    }
+                    Err(_) => {}
+                }
+            }
+        });
+    }
+    {
+        let tx = tx.clone();
+        thread::spawn(move || {
+            let tx = tx.clone();
+            loop {
+                tx.send(Event::Tick).unwrap();
+                thread::sleep(Duration::from_millis(cli.tick_rate));
+            }
+        });
+    }
+
+    let mut app = App::new("Crossterm Demo");
+
+    terminal.clear()?;
+
+    loop {
+        ui::draw(&mut terminal, &app)?;
+        match rx.recv()? {
+            Event::Input(key) => {
+                // TODO: handle key events once they are supported by crossterm
+                app.on_key(key);
+            }
+            Event::Tick => {
+                app.on_tick();
+            }
+        }
+        if app.should_quit {
+            break;
+        }
+    }
+
+    Ok(())
+}

examples/curses_demo.rs

@@ -0,0 +1,75 @@
+mod demo;
+#[allow(dead_code)]
+mod util;
+
+use std::io;
+use std::time::{Duration, Instant};
+
+use easycurses;
+use structopt::StructOpt;
+use tui::backend::CursesBackend;
+use tui::Terminal;
+
+use crate::demo::{ui, App};
+
+#[derive(Debug, StructOpt)]
+struct Cli {
+    #[structopt(long = "tick-rate", default_value = "250")]
+    tick_rate: u64,
+    #[structopt(long = "log")]
+    log: bool,
+}
+
+fn main() -> Result<(), failure::Error> {
+    let cli = Cli::from_args();
+    stderrlog::new().quiet(!cli.log).verbosity(4).init()?;
+
+    let mut backend = CursesBackend::new().ok_or(io::Error::new(io::ErrorKind::Other, ""))?;
+    let curses = backend.get_curses_mut();
+    curses.set_echo(false);
+    curses.set_input_timeout(easycurses::TimeoutMode::WaitUpTo(50));
+    curses.set_input_mode(easycurses::InputMode::RawCharacter);
+    curses.set_keypad_enabled(true);
+    let mut terminal = Terminal::new(backend)?;
+    terminal.hide_cursor()?;
+
+    let mut app = App::new("Curses demo");
+
+    let mut last_tick = Instant::now();
+    let tick_rate = Duration::from_millis(cli.tick_rate);
+    loop {
+        ui::draw(&mut terminal, &app)?;
+        match terminal.backend_mut().get_curses_mut().get_input() {
+            Some(input) => {
+                match input {
+                    easycurses::Input::Character(c) => {
+                        app.on_key(c);
+                    }
+                    easycurses::Input::KeyUp => {
+                        app.on_up();
+                    }
+                    easycurses::Input::KeyDown => {
+                        app.on_down();
+                    }
+                    easycurses::Input::KeyLeft => {
+                        app.on_left();
+                    }
+                    easycurses::Input::KeyRight => {
+                        app.on_right();
+                    }
+                    _ => {}
+                };
+            }
+            _ => {}
+        };
+        terminal.backend_mut().get_curses_mut().flush_input();
+        if last_tick.elapsed() > tick_rate {
+            app.on_tick();
+            last_tick = Instant::now();
+        }
+        if app.should_quit {
+            break;
+        }
+    }
+    Ok(())
+}

examples/custom_widget.rs

@@ -1,7 +1,3 @@
-extern crate failure;
-extern crate termion;
-extern crate tui;
-
 #[allow(dead_code)]
 mod util;
 
@@ -18,19 +14,7 @@ use tui::style::Style;
 use tui::widgets::Widget;
 use tui::Terminal;
 
-use util::event::{Event, Events};
-
-struct App {
-    size: Rect,
-}
-
-impl Default for App {
-    fn default() -> App {
-        App {
-            size: Rect::default(),
-        }
-    }
-}
+use crate::util::event::{Event, Events};
 
 struct Label<'a> {
     text: &'a str,
@@ -65,23 +49,18 @@ fn main() -> Result<(), failure::Error> {
 
     let events = Events::new();
 
-    let mut app = App::default();
-
     loop {
-        let size = terminal.size()?;
-        if app.size != size {
-            terminal.resize(size)?;
-            app.size = size;
-        }
-
         terminal.draw(|mut f| {
-            Label::default().text("Test").render(&mut f, app.size);
+            let size = f.size();
+            Label::default().text("Test").render(&mut f, size);
         })?;
 
         match events.next()? {
-            Event::Input(key) => if key == Key::Char('q') {
-                break;
-            },
+            Event::Input(key) => {
+                if key == Key::Char('q') {
+                    break;
+                }
+            }
             _ => {}
         }
     }

examples/demo.rs

@@ -1,475 +0,0 @@
-extern crate failure;
-extern crate log;
-extern crate stderrlog;
-extern crate termion;
-extern crate tui;
-
-#[allow(dead_code)]
-mod util;
-
-use std::io;
-
-use termion::event::Key;
-use termion::input::MouseTerminal;
-use termion::raw::{IntoRawMode, RawTerminal};
-use termion::screen::AlternateScreen;
-use tui::backend::TermionBackend;
-use tui::layout::{Constraint, Direction, Layout, Rect};
-use tui::style::{Color, Modifier, Style};
-use tui::widgets::canvas::{Canvas, Line, Map, MapResolution};
-use tui::widgets::{
-    Axis, BarChart, Block, Borders, Chart, Dataset, Gauge, List, Marker, Paragraph, Row,
-    SelectableList, Sparkline, Table, Tabs, Text, Widget,
-};
-use tui::{Frame, Terminal};
-
-use util::event::{Event, Events};
-use util::{RandomSignal, SinSignal, TabsState};
-
-type Backend = TermionBackend<AlternateScreen<MouseTerminal<RawTerminal<io::Stdout>>>>;
-
-struct Server<'a> {
-    name: &'a str,
-    location: &'a str,
-    coords: (f64, f64),
-    status: &'a str,
-}
-
-struct App<'a> {
-    size: Rect,
-    items: Vec<&'a str>,
-    events: Vec<(&'a str, &'a str)>,
-    selected: usize,
-    tabs: TabsState<'a>,
-    show_chart: bool,
-    progress: u16,
-    data: Vec<u64>,
-    data2: Vec<(f64, f64)>,
-    data3: Vec<(f64, f64)>,
-    data4: Vec<(&'a str, u64)>,
-    window: [f64; 2],
-    colors: [Color; 2],
-    color_index: usize,
-    servers: Vec<Server<'a>>,
-}
-
-fn main() -> Result<(), failure::Error> {
-    stderrlog::new()
-        .module(module_path!())
-        .verbosity(4)
-        .init()?;
-
-    let stdout = io::stdout().into_raw_mode()?;
-    let stdout = MouseTerminal::from(stdout);
-    let stdout = AlternateScreen::from(stdout);
-    let backend = TermionBackend::new(stdout);
-    let mut terminal = Terminal::new(backend)?;
-    terminal.hide_cursor()?;
-
-    let events = Events::new();
-
-    let mut rand_signal = RandomSignal::new(0, 100);
-    let mut sin_signal = SinSignal::new(0.2, 3.0, 18.0);
-    let mut sin_signal2 = SinSignal::new(0.1, 2.0, 10.0);
-
-    let mut app = App {
-        size: Rect::default(),
-        items: vec![
-            "Item1", "Item2", "Item3", "Item4", "Item5", "Item6", "Item7", "Item8", "Item9",
-            "Item10", "Item11", "Item12", "Item13", "Item14", "Item15", "Item16", "Item17",
-            "Item18", "Item19", "Item20", "Item21", "Item22", "Item23", "Item24",
-        ],
-        events: vec![
-            ("Event1", "INFO"),
-            ("Event2", "INFO"),
-            ("Event3", "CRITICAL"),
-            ("Event4", "ERROR"),
-            ("Event5", "INFO"),
-            ("Event6", "INFO"),
-            ("Event7", "WARNING"),
-            ("Event8", "INFO"),
-            ("Event9", "INFO"),
-            ("Event10", "INFO"),
-            ("Event11", "CRITICAL"),
-            ("Event12", "INFO"),
-            ("Event13", "INFO"),
-            ("Event14", "INFO"),
-            ("Event15", "INFO"),
-            ("Event16", "INFO"),
-            ("Event17", "ERROR"),
-            ("Event18", "ERROR"),
-            ("Event19", "INFO"),
-            ("Event20", "INFO"),
-            ("Event21", "WARNING"),
-            ("Event22", "INFO"),
-            ("Event23", "INFO"),
-            ("Event24", "WARNING"),
-            ("Event25", "INFO"),
-            ("Event26", "INFO"),
-        ],
-        selected: 0,
-        tabs: TabsState::new(vec!["Tab0", "Tab1"]),
-        show_chart: true,
-        progress: 0,
-        data: rand_signal.by_ref().take(300).collect(),
-        data2: sin_signal.by_ref().take(100).collect(),
-        data3: sin_signal2.by_ref().take(200).collect(),
-        data4: vec![
-            ("B1", 9),
-            ("B2", 12),
-            ("B3", 5),
-            ("B4", 8),
-            ("B5", 2),
-            ("B6", 4),
-            ("B7", 5),
-            ("B8", 9),
-            ("B9", 14),
-            ("B10", 15),
-            ("B11", 1),
-            ("B12", 0),
-            ("B13", 4),
-            ("B14", 6),
-            ("B15", 4),
-            ("B16", 6),
-            ("B17", 4),
-            ("B18", 7),
-            ("B19", 13),
-            ("B20", 8),
-            ("B21", 11),
-            ("B22", 9),
-            ("B23", 3),
-            ("B24", 5),
-        ],
-        window: [0.0, 20.0],
-        colors: [Color::Magenta, Color::Red],
-        color_index: 0,
-        servers: vec![
-            Server {
-                name: "NorthAmerica-1",
-                location: "New York City",
-                coords: (40.71, -74.00),
-                status: "Up",
-            },
-            Server {
-                name: "Europe-1",
-                location: "Paris",
-                coords: (48.85, 2.35),
-                status: "Failure",
-            },
-            Server {
-                name: "SouthAmerica-1",
-                location: "São Paulo",
-                coords: (-23.54, -46.62),
-                status: "Up",
-            },
-            Server {
-                name: "Asia-1",
-                location: "Singapore",
-                coords: (1.35, 103.86),
-                status: "Up",
-            },
-        ],
-    };
-
-    loop {
-        let size = terminal.size()?;
-        if size != app.size {
-            terminal.resize(size)?;
-            app.size = size;
-        }
-
-        // Draw UI
-        terminal.draw(|mut f| {
-            let chunks = Layout::default()
-                .constraints([Constraint::Length(3), Constraint::Min(0)].as_ref())
-                .split(app.size);
-            Tabs::default()
-                .block(Block::default().borders(Borders::ALL).title("Tabs"))
-                .titles(&app.tabs.titles)
-                .style(Style::default().fg(Color::Green))
-                .highlight_style(Style::default().fg(Color::Yellow))
-                .select(app.tabs.index)
-                .render(&mut f, chunks[0]);
-            match app.tabs.index {
-                0 => draw_first_tab(&mut f, &app, chunks[1]),
-                1 => draw_second_tab(&mut f, &app, chunks[1]),
-                _ => {}
-            };
-        })?;
-
-        match events.next()? {
-            Event::Input(input) => match input {
-                Key::Char('q') => {
-                    break;
-                }
-                Key::Up => {
-                    if app.selected > 0 {
-                        app.selected -= 1
-                    };
-                }
-                Key::Down => if app.selected < app.items.len() - 1 {
-                    app.selected += 1;
-                },
-                Key::Left => {
-                    app.tabs.previous();
-                }
-                Key::Right => {
-                    app.tabs.next();
-                }
-                Key::Char('t') => {
-                    app.show_chart = !app.show_chart;
-                }
-                _ => {}
-            },
-            Event::Tick => {
-                app.progress += 5;
-                if app.progress > 100 {
-                    app.progress = 0;
-                }
-                app.data.insert(0, rand_signal.next().unwrap());
-                app.data.pop();
-                for _ in 0..5 {
-                    app.data2.remove(0);
-                    app.data2.push(sin_signal.next().unwrap());
-                }
-                for _ in 0..10 {
-                    app.data3.remove(0);
-                    app.data3.push(sin_signal2.next().unwrap());
-                }
-                let i = app.data4.pop().unwrap();
-                app.data4.insert(0, i);
-                app.window[0] += 1.0;
-                app.window[1] += 1.0;
-                let i = app.events.pop().unwrap();
-                app.events.insert(0, i);
-                app.color_index += 1;
-                if app.color_index >= app.colors.len() {
-                    app.color_index = 0;
-                }
-            }
-        }
-    }
-    Ok(())
-}
-
-fn draw_first_tab(f: &mut Frame<Backend>, app: &App, area: Rect) {
-    let chunks = Layout::default()
-        .constraints(
-            [
-                Constraint::Length(7),
-                Constraint::Min(7),
-                Constraint::Length(7),
-            ]
-                .as_ref(),
-        ).split(area);
-    draw_gauges(f, app, chunks[0]);
-    draw_charts(f, app, chunks[1]);
-    draw_text(f, chunks[2]);
-}
-
-fn draw_gauges(f: &mut Frame<Backend>, app: &App, area: Rect) {
-    let chunks = Layout::default()
-        .constraints([Constraint::Length(2), Constraint::Length(3)].as_ref())
-        .margin(1)
-        .split(area);
-    Block::default()
-        .borders(Borders::ALL)
-        .title("Graphs")
-        .render(f, area);
-    Gauge::default()
-        .block(Block::default().title("Gauge:"))
-        .style(
-            Style::default()
-                .fg(Color::Magenta)
-                .bg(Color::Black)
-                .modifier(Modifier::Italic),
-        ).label(&format!("{} / 100", app.progress))
-        .percent(app.progress)
-        .render(f, chunks[0]);
-    Sparkline::default()
-        .block(Block::default().title("Sparkline:"))
-        .style(Style::default().fg(Color::Green))
-        .data(&app.data)
-        .render(f, chunks[1]);
-}
-
-fn draw_charts(f: &mut Frame<Backend>, app: &App, area: Rect) {
-    let constraints = if app.show_chart {
-        vec![Constraint::Percentage(50), Constraint::Percentage(50)]
-    } else {
-        vec![Constraint::Percentage(100)]
-    };
-    let chunks = Layout::default()
-        .constraints(constraints)
-        .direction(Direction::Horizontal)
-        .split(area);
-    {
-        let chunks = Layout::default()
-            .constraints([Constraint::Percentage(50), Constraint::Percentage(50)].as_ref())
-            .split(chunks[0]);
-        {
-            let chunks = Layout::default()
-                .constraints([Constraint::Percentage(50), Constraint::Percentage(50)].as_ref())
-                .direction(Direction::Horizontal)
-                .split(chunks[0]);
-            SelectableList::default()
-                .block(Block::default().borders(Borders::ALL).title("List"))
-                .items(&app.items)
-                .select(Some(app.selected))
-                .highlight_style(Style::default().fg(Color::Yellow).modifier(Modifier::Bold))
-                .highlight_symbol(">")
-                .render(f, chunks[0]);
-            let info_style = Style::default().fg(Color::White);
-            let warning_style = Style::default().fg(Color::Yellow);
-            let error_style = Style::default().fg(Color::Magenta);
-            let critical_style = Style::default().fg(Color::Red);
-            let events = app.events.iter().map(|&(evt, level)| {
-                Text::styled(
-                    format!("{}: {}", level, evt),
-                    match level {
-                        "ERROR" => error_style,
-                        "CRITICAL" => critical_style,
-                        "WARNING" => warning_style,
-                        _ => info_style,
-                    },
-                )
-            });
-            List::new(events)
-                .block(Block::default().borders(Borders::ALL).title("List"))
-                .render(f, chunks[1]);
-        }
-        BarChart::default()
-            .block(Block::default().borders(Borders::ALL).title("Bar chart"))
-            .data(&app.data4)
-            .bar_width(3)
-            .bar_gap(2)
-            .value_style(
-                Style::default()
-                    .fg(Color::Black)
-                    .bg(Color::Green)
-                    .modifier(Modifier::Italic),
-            ).label_style(Style::default().fg(Color::Yellow))
-            .style(Style::default().fg(Color::Green))
-            .render(f, chunks[1]);
-    }
-    if app.show_chart {
-        Chart::default()
-            .block(
-                Block::default()
-                    .title("Chart")
-                    .title_style(Style::default().fg(Color::Cyan).modifier(Modifier::Bold))
-                    .borders(Borders::ALL),
-            ).x_axis(
-                Axis::default()
-                    .title("X Axis")
-                    .style(Style::default().fg(Color::Gray))
-                    .labels_style(Style::default().modifier(Modifier::Italic))
-                    .bounds(app.window)
-                    .labels(&[
-                        &format!("{}", app.window[0]),
-                        &format!("{}", (app.window[0] + app.window[1]) / 2.0),
-                        &format!("{}", app.window[1]),
-                    ]),
-            ).y_axis(
-                Axis::default()
-                    .title("Y Axis")
-                    .style(Style::default().fg(Color::Gray))
-                    .labels_style(Style::default().modifier(Modifier::Italic))
-                    .bounds([-20.0, 20.0])
-                    .labels(&["-20", "0", "20"]),
-            ).datasets(&[
-                Dataset::default()
-                    .name("data2")
-                    .marker(Marker::Dot)
-                    .style(Style::default().fg(Color::Cyan))
-                    .data(&app.data2),
-                Dataset::default()
-                    .name("data3")
-                    .marker(Marker::Braille)
-                    .style(Style::default().fg(Color::Yellow))
-                    .data(&app.data3),
-            ]).render(f, chunks[1]);
-    }
-}
-
-fn draw_text(f: &mut Frame<Backend>, area: Rect) {
-    let text = [
-        Text::raw("This is a paragraph with several lines. You can change style your text the way you want.\n\nFox example: "),
-        Text::styled("under", Style::default().fg(Color::Red)),
-        Text::raw(" "),
-        Text::styled("the", Style::default().fg(Color::Green)),
-        Text::raw(" "),
-        Text::styled("rainbow", Style::default().fg(Color::Blue)),
-        Text::raw(".\nOh and if you didn't "),
-        Text::styled("notice", Style::default().modifier(Modifier::Italic)),
-        Text::raw(" you can "),
-        Text::styled("automatically", Style::default().modifier(Modifier::Bold)),
-        Text::raw(" "),
-        Text::styled("wrap", Style::default().modifier(Modifier::Invert)),
-        Text::raw(" your "),
-        Text::styled("text", Style::default().modifier(Modifier::Underline)),
-        Text::raw(".\nOne more thing is that it should display unicode characters: 10€")
-    ];
-    Paragraph::new(text.iter())
-        .block(
-            Block::default()
-                .borders(Borders::ALL)
-                .title("Footer")
-                .title_style(Style::default().fg(Color::Magenta).modifier(Modifier::Bold)),
-        ).wrap(true)
-        .render(f, area);
-}
-
-fn draw_second_tab(f: &mut Frame<Backend>, app: &App, area: Rect) {
-    let chunks = Layout::default()
-        .constraints([Constraint::Percentage(30), Constraint::Percentage(70)].as_ref())
-        .direction(Direction::Horizontal)
-        .split(area);
-    let up_style = Style::default().fg(Color::Green);
-    let failure_style = Style::default().fg(Color::Red);
-    let header = ["Server", "Location", "Status"];
-    let rows = app.servers.iter().map(|s| {
-        let style = if s.status == "Up" {
-            up_style
-        } else {
-            failure_style
-        };
-        Row::StyledData(vec![s.name, s.location, s.status].into_iter(), style)
-    });
-    Table::new(header.into_iter(), rows)
-        .block(Block::default().title("Servers").borders(Borders::ALL))
-        .header_style(Style::default().fg(Color::Yellow))
-        .widths(&[15, 15, 10])
-        .render(f, chunks[0]);
-
-    Canvas::default()
-        .block(Block::default().title("World").borders(Borders::ALL))
-        .paint(|ctx| {
-            ctx.draw(&Map {
-                color: Color::White,
-                resolution: MapResolution::High,
-            });
-            ctx.layer();
-            for (i, s1) in app.servers.iter().enumerate() {
-                for s2 in &app.servers[i + 1..] {
-                    ctx.draw(&Line {
-                        x1: s1.coords.1,
-                        y1: s1.coords.0,
-                        y2: s2.coords.0,
-                        x2: s2.coords.1,
-                        color: Color::Yellow,
-                    });
-                }
-            }
-            for server in &app.servers {
-                let color = if server.status == "Up" {
-                    Color::Green
-                } else {
-                    Color::Red
-                };
-                ctx.print(server.coords.1, server.coords.0, "X", color);
-            }
-        }).x_bounds([-180.0, 180.0])
-        .y_bounds([-90.0, 90.0])
-        .render(f, chunks[1]);
-}

examples/demo/app.rs

@@ -0,0 +1,249 @@
+use crate::util::{RandomSignal, SinSignal, TabsState};
+
+const TASKS: [&'static str; 24] = [
+    "Item1", "Item2", "Item3", "Item4", "Item5", "Item6", "Item7", "Item8", "Item9", "Item10",
+    "Item11", "Item12", "Item13", "Item14", "Item15", "Item16", "Item17", "Item18", "Item19",
+    "Item20", "Item21", "Item22", "Item23", "Item24",
+];
+
+const LOGS: [(&'static str, &'static str); 26] = [
+    ("Event1", "INFO"),
+    ("Event2", "INFO"),
+    ("Event3", "CRITICAL"),
+    ("Event4", "ERROR"),
+    ("Event5", "INFO"),
+    ("Event6", "INFO"),
+    ("Event7", "WARNING"),
+    ("Event8", "INFO"),
+    ("Event9", "INFO"),
+    ("Event10", "INFO"),
+    ("Event11", "CRITICAL"),
+    ("Event12", "INFO"),
+    ("Event13", "INFO"),
+    ("Event14", "INFO"),
+    ("Event15", "INFO"),
+    ("Event16", "INFO"),
+    ("Event17", "ERROR"),
+    ("Event18", "ERROR"),
+    ("Event19", "INFO"),
+    ("Event20", "INFO"),
+    ("Event21", "WARNING"),
+    ("Event22", "INFO"),
+    ("Event23", "INFO"),
+    ("Event24", "WARNING"),
+    ("Event25", "INFO"),
+    ("Event26", "INFO"),
+];
+
+const EVENTS: [(&'static str, u64); 24] = [
+    ("B1", 9),
+    ("B2", 12),
+    ("B3", 5),
+    ("B4", 8),
+    ("B5", 2),
+    ("B6", 4),
+    ("B7", 5),
+    ("B8", 9),
+    ("B9", 14),
+    ("B10", 15),
+    ("B11", 1),
+    ("B12", 0),
+    ("B13", 4),
+    ("B14", 6),
+    ("B15", 4),
+    ("B16", 6),
+    ("B17", 4),
+    ("B18", 7),
+    ("B19", 13),
+    ("B20", 8),
+    ("B21", 11),
+    ("B22", 9),
+    ("B23", 3),
+    ("B24", 5),
+];
+
+pub struct Signal<S: Iterator> {
+    source: S,
+    pub points: Vec<S::Item>,
+    tick_rate: usize,
+}
+
+impl<S> Signal<S>
+where
+    S: Iterator,
+{
+    fn on_tick(&mut self) {
+        for _ in 0..self.tick_rate {
+            self.points.remove(0);
+        }
+        self.points
+            .extend(self.source.by_ref().take(self.tick_rate));
+    }
+}
+
+pub struct Signals {
+    pub sin1: Signal<SinSignal>,
+    pub sin2: Signal<SinSignal>,
+    pub window: [f64; 2],
+}
+
+impl Signals {
+    fn on_tick(&mut self) {
+        self.sin1.on_tick();
+        self.sin2.on_tick();
+        self.window[0] += 1.0;
+        self.window[1] += 1.0;
+    }
+}
+
+pub struct ListState<I> {
+    pub items: Vec<I>,
+    pub selected: usize,
+}
+
+impl<I> ListState<I> {
+    fn new(items: Vec<I>) -> ListState<I> {
+        ListState { items, selected: 0 }
+    }
+    fn select_previous(&mut self) {
+        if self.selected > 0 {
+            self.selected -= 1;
+        }
+    }
+    fn select_next(&mut self) {
+        if self.selected < self.items.len() - 1 {
+            self.selected += 1
+        }
+    }
+}
+
+pub struct Server<'a> {
+    pub name: &'a str,
+    pub location: &'a str,
+    pub coords: (f64, f64),
+    pub status: &'a str,
+}
+
+pub struct App<'a> {
+    pub title: &'a str,
+    pub should_quit: bool,
+    pub tabs: TabsState<'a>,
+    pub show_chart: bool,
+    pub progress: u16,
+    pub sparkline: Signal<RandomSignal>,
+    pub tasks: ListState<(&'a str)>,
+    pub logs: ListState<(&'a str, &'a str)>,
+    pub signals: Signals,
+    pub barchart: Vec<(&'a str, u64)>,
+    pub servers: Vec<Server<'a>>,
+}
+
+impl<'a> App<'a> {
+    pub fn new(title: &'a str) -> App<'a> {
+        let mut rand_signal = RandomSignal::new(0, 100);
+        let sparkline_points = rand_signal.by_ref().take(300).collect();
+        let mut sin_signal = SinSignal::new(0.2, 3.0, 18.0);
+        let sin1_points = sin_signal.by_ref().take(100).collect();
+        let mut sin_signal2 = SinSignal::new(0.1, 2.0, 10.0);
+        let sin2_points = sin_signal2.by_ref().take(200).collect();
+        App {
+            title,
+            should_quit: false,
+            tabs: TabsState::new(vec!["Tab0", "Tab1"]),
+            show_chart: true,
+            progress: 0,
+            sparkline: Signal {
+                source: rand_signal,
+                points: sparkline_points,
+                tick_rate: 1,
+            },
+            tasks: ListState::new(TASKS.to_vec()),
+            logs: ListState::new(LOGS.to_vec()),
+            signals: Signals {
+                sin1: Signal {
+                    source: sin_signal,
+                    points: sin1_points,
+                    tick_rate: 5,
+                },
+                sin2: Signal {
+                    source: sin_signal2,
+                    points: sin2_points,
+                    tick_rate: 10,
+                },
+                window: [0.0, 20.0],
+            },
+            barchart: EVENTS.to_vec(),
+            servers: vec![
+                Server {
+                    name: "NorthAmerica-1",
+                    location: "New York City",
+                    coords: (40.71, -74.00),
+                    status: "Up",
+                },
+                Server {
+                    name: "Europe-1",
+                    location: "Paris",
+                    coords: (48.85, 2.35),
+                    status: "Failure",
+                },
+                Server {
+                    name: "SouthAmerica-1",
+                    location: "São Paulo",
+                    coords: (-23.54, -46.62),
+                    status: "Up",
+                },
+                Server {
+                    name: "Asia-1",
+                    location: "Singapore",
+                    coords: (1.35, 103.86),
+                    status: "Up",
+                },
+            ],
+        }
+    }
+
+    pub fn on_up(&mut self) {
+        self.tasks.select_previous();
+    }
+
+    pub fn on_down(&mut self) {
+        self.tasks.select_next();
+    }
+
+    pub fn on_right(&mut self) {
+        self.tabs.next();
+    }
+
+    pub fn on_left(&mut self) {
+        self.tabs.previous();
+    }
+
+    pub fn on_key(&mut self, c: char) {
+        match c {
+            'q' => {
+                self.should_quit = true;
+            }
+            't' => {
+                self.show_chart = !self.show_chart;
+            }
+            _ => {}
+        }
+    }
+
+    pub fn on_tick(&mut self) {
+        // Update progress
+        self.progress += 5;
+        if self.progress > 100 {
+            self.progress = 0;
+        }
+
+        self.sparkline.on_tick();
+        self.signals.on_tick();
+
+        let log = self.logs.items.pop().unwrap();
+        self.logs.items.insert(0, log);
+
+        let event = self.barchart.pop().unwrap();
+        self.barchart.insert(0, event);
+    }
+}

examples/demo/mod.rs

@@ -0,0 +1,3 @@
+mod app;
+pub mod ui;
+pub use app::App;

examples/demo/ui.rs

@@ -0,0 +1,290 @@
+use std::io;
+
+use tui::backend::Backend;
+use tui::layout::{Constraint, Direction, Layout, Rect};
+use tui::style::{Color, Modifier, Style};
+use tui::widgets::canvas::{Canvas, Line, Map, MapResolution, Rectangle};
+use tui::widgets::{
+    Axis, BarChart, Block, Borders, Chart, Dataset, Gauge, List, Marker, Paragraph, Row,
+    SelectableList, Sparkline, Table, Tabs, Text, Widget,
+};
+use tui::{Frame, Terminal};
+
+use crate::demo::App;
+
+pub fn draw<B: Backend>(terminal: &mut Terminal<B>, app: &App) -> Result<(), io::Error> {
+    terminal.draw(|mut f| {
+        let chunks = Layout::default()
+            .constraints([Constraint::Length(3), Constraint::Min(0)].as_ref())
+            .split(f.size());
+        Tabs::default()
+            .block(Block::default().borders(Borders::ALL).title(app.title))
+            .titles(&app.tabs.titles)
+            .style(Style::default().fg(Color::Green))
+            .highlight_style(Style::default().fg(Color::Yellow))
+            .select(app.tabs.index)
+            .render(&mut f, chunks[0]);
+        match app.tabs.index {
+            0 => draw_first_tab(&mut f, &app, chunks[1]),
+            1 => draw_second_tab(&mut f, &app, chunks[1]),
+            _ => {}
+        };
+    })
+}
+
+fn draw_first_tab<B>(f: &mut Frame<B>, app: &App, area: Rect)
+where
+    B: Backend,
+{
+    let chunks = Layout::default()
+        .constraints(
+            [
+                Constraint::Length(7),
+                Constraint::Min(7),
+                Constraint::Length(7),
+            ]
+            .as_ref(),
+        )
+        .split(area);
+    draw_gauges(f, app, chunks[0]);
+    draw_charts(f, app, chunks[1]);
+    draw_text(f, chunks[2]);
+}
+
+fn draw_gauges<B>(f: &mut Frame<B>, app: &App, area: Rect)
+where
+    B: Backend,
+{
+    let chunks = Layout::default()
+        .constraints([Constraint::Length(2), Constraint::Length(3)].as_ref())
+        .margin(1)
+        .split(area);
+    Block::default()
+        .borders(Borders::ALL)
+        .title("Graphs")
+        .render(f, area);
+    Gauge::default()
+        .block(Block::default().title("Gauge:"))
+        .style(
+            Style::default()
+                .fg(Color::Magenta)
+                .bg(Color::Black)
+                .modifier(Modifier::ITALIC | Modifier::BOLD),
+        )
+        .label(&format!("{} / 100", app.progress))
+        .percent(app.progress)
+        .render(f, chunks[0]);
+    Sparkline::default()
+        .block(Block::default().title("Sparkline:"))
+        .style(Style::default().fg(Color::Green))
+        .data(&app.sparkline.points)
+        .render(f, chunks[1]);
+}
+
+fn draw_charts<B>(f: &mut Frame<B>, app: &App, area: Rect)
+where
+    B: Backend,
+{
+    let constraints = if app.show_chart {
+        vec![Constraint::Percentage(50), Constraint::Percentage(50)]
+    } else {
+        vec![Constraint::Percentage(100)]
+    };
+    let chunks = Layout::default()
+        .constraints(constraints)
+        .direction(Direction::Horizontal)
+        .split(area);
+    {
+        let chunks = Layout::default()
+            .constraints([Constraint::Percentage(50), Constraint::Percentage(50)].as_ref())
+            .split(chunks[0]);
+        {
+            let chunks = Layout::default()
+                .constraints([Constraint::Percentage(50), Constraint::Percentage(50)].as_ref())
+                .direction(Direction::Horizontal)
+                .split(chunks[0]);
+            SelectableList::default()
+                .block(Block::default().borders(Borders::ALL).title("List"))
+                .items(&app.tasks.items)
+                .select(Some(app.tasks.selected))
+                .highlight_style(Style::default().fg(Color::Yellow).modifier(Modifier::BOLD))
+                .highlight_symbol(">")
+                .render(f, chunks[0]);
+            let info_style = Style::default().fg(Color::White);
+            let warning_style = Style::default().fg(Color::Yellow);
+            let error_style = Style::default().fg(Color::Magenta);
+            let critical_style = Style::default().fg(Color::Red);
+            let events = app.logs.items.iter().map(|&(evt, level)| {
+                Text::styled(
+                    format!("{}: {}", level, evt),
+                    match level {
+                        "ERROR" => error_style,
+                        "CRITICAL" => critical_style,
+                        "WARNING" => warning_style,
+                        _ => info_style,
+                    },
+                )
+            });
+            List::new(events)
+                .block(Block::default().borders(Borders::ALL).title("List"))
+                .render(f, chunks[1]);
+        }
+        BarChart::default()
+            .block(Block::default().borders(Borders::ALL).title("Bar chart"))
+            .data(&app.barchart)
+            .bar_width(3)
+            .bar_gap(2)
+            .value_style(
+                Style::default()
+                    .fg(Color::Black)
+                    .bg(Color::Green)
+                    .modifier(Modifier::ITALIC),
+            )
+            .label_style(Style::default().fg(Color::Yellow))
+            .style(Style::default().fg(Color::Green))
+            .render(f, chunks[1]);
+    }
+    if app.show_chart {
+        Chart::default()
+            .block(
+                Block::default()
+                    .title("Chart")
+                    .title_style(Style::default().fg(Color::Cyan).modifier(Modifier::BOLD))
+                    .borders(Borders::ALL),
+            )
+            .x_axis(
+                Axis::default()
+                    .title("X Axis")
+                    .style(Style::default().fg(Color::Gray))
+                    .labels_style(Style::default().modifier(Modifier::ITALIC))
+                    .bounds(app.signals.window)
+                    .labels(&[
+                        &format!("{}", app.signals.window[0]),
+                        &format!("{}", (app.signals.window[0] + app.signals.window[1]) / 2.0),
+                        &format!("{}", app.signals.window[1]),
+                    ]),
+            )
+            .y_axis(
+                Axis::default()
+                    .title("Y Axis")
+                    .style(Style::default().fg(Color::Gray))
+                    .labels_style(Style::default().modifier(Modifier::ITALIC))
+                    .bounds([-20.0, 20.0])
+                    .labels(&["-20", "0", "20"]),
+            )
+            .datasets(&[
+                Dataset::default()
+                    .name("data2")
+                    .marker(Marker::Dot)
+                    .style(Style::default().fg(Color::Cyan))
+                    .data(&app.signals.sin1.points),
+                Dataset::default()
+                    .name("data3")
+                    .marker(Marker::Braille)
+                    .style(Style::default().fg(Color::Yellow))
+                    .data(&app.signals.sin2.points),
+            ])
+            .render(f, chunks[1]);
+    }
+}
+
+fn draw_text<B>(f: &mut Frame<B>, area: Rect)
+where
+    B: Backend,
+{
+    let text = [
+        Text::raw("This is a paragraph with several lines. You can change style your text the way you want.\n\nFox example: "),
+        Text::styled("under", Style::default().fg(Color::Red)),
+        Text::raw(" "),
+        Text::styled("the", Style::default().fg(Color::Green)),
+        Text::raw(" "),
+        Text::styled("rainbow", Style::default().fg(Color::Blue)),
+        Text::raw(".\nOh and if you didn't "),
+        Text::styled("notice", Style::default().modifier(Modifier::ITALIC)),
+        Text::raw(" you can "),
+        Text::styled("automatically", Style::default().modifier(Modifier::BOLD)),
+        Text::raw(" "),
+        Text::styled("wrap", Style::default().modifier(Modifier::REVERSED)),
+        Text::raw(" your "),
+        Text::styled("text", Style::default().modifier(Modifier::UNDERLINED)),
+        Text::raw(".\nOne more thing is that it should display unicode characters: 10€")
+    ];
+    Paragraph::new(text.iter())
+        .block(
+            Block::default()
+                .borders(Borders::ALL)
+                .title("Footer")
+                .title_style(Style::default().fg(Color::Magenta).modifier(Modifier::BOLD)),
+        )
+        .wrap(true)
+        .render(f, area);
+}
+
+fn draw_second_tab<B>(f: &mut Frame<B>, app: &App, area: Rect)
+where
+    B: Backend,
+{
+    let chunks = Layout::default()
+        .constraints([Constraint::Percentage(30), Constraint::Percentage(70)].as_ref())
+        .direction(Direction::Horizontal)
+        .split(area);
+    let up_style = Style::default().fg(Color::Green);
+    let failure_style = Style::default()
+        .fg(Color::Red)
+        .modifier(Modifier::RAPID_BLINK | Modifier::CROSSED_OUT);
+    let header = ["Server", "Location", "Status"];
+    let rows = app.servers.iter().map(|s| {
+        let style = if s.status == "Up" {
+            up_style
+        } else {
+            failure_style
+        };
+        Row::StyledData(vec![s.name, s.location, s.status].into_iter(), style)
+    });
+    Table::new(header.into_iter(), rows)
+        .block(Block::default().title("Servers").borders(Borders::ALL))
+        .header_style(Style::default().fg(Color::Yellow))
+        .widths(&[15, 15, 10])
+        .render(f, chunks[0]);
+
+    Canvas::default()
+        .block(Block::default().title("World").borders(Borders::ALL))
+        .paint(|ctx| {
+            ctx.draw(&Map {
+                color: Color::White,
+                resolution: MapResolution::High,
+            });
+            ctx.layer();
+            ctx.draw(&Rectangle {
+                rect: Rect {
+                    x: 0,
+                    y: 30,
+                    width: 10,
+                    height: 10,
+                },
+                color: Color::Yellow,
+            });
+            for (i, s1) in app.servers.iter().enumerate() {
+                for s2 in &app.servers[i + 1..] {
+                    ctx.draw(&Line {
+                        x1: s1.coords.1,
+                        y1: s1.coords.0,
+                        y2: s2.coords.0,
+                        x2: s2.coords.1,
+                        color: Color::Yellow,
+                    });
+                }
+            }
+            for server in &app.servers {
+                let color = if server.status == "Up" {
+                    Color::Green
+                } else {
+                    Color::Red
+                };
+                ctx.print(server.coords.1, server.coords.0, "X", color);
+            }
+        })
+        .x_bounds([-180.0, 180.0])
+        .y_bounds([-90.0, 90.0])
+        .render(f, chunks[1]);
+}

examples/gauge.rs

@@ -1,7 +1,3 @@
-extern crate failure;
-extern crate termion;
-extern crate tui;
-
 #[allow(dead_code)]
 mod util;
 
@@ -12,28 +8,26 @@ use termion::input::MouseTerminal;
 use termion::raw::IntoRawMode;
 use termion::screen::AlternateScreen;
 use tui::backend::TermionBackend;
-use tui::layout::{Constraint, Direction, Layout, Rect};
+use tui::layout::{Constraint, Direction, Layout};
 use tui::style::{Color, Modifier, Style};
 use tui::widgets::{Block, Borders, Gauge, Widget};
 use tui::Terminal;
 
-use util::event::{Event, Events};
+use crate::util::event::{Event, Events};
 
 struct App {
-    size: Rect,
     progress1: u16,
     progress2: u16,
-    progress3: u16,
+    progress3: f64,
     progress4: u16,
 }
 
 impl App {
     fn new() -> App {
         App {
-            size: Rect::default(),
             progress1: 0,
             progress2: 0,
-            progress3: 0,
+            progress3: 0.0,
             progress4: 0,
         }
     }
@@ -47,9 +41,9 @@ impl App {
         if self.progress2 > 100 {
             self.progress2 = 0;
         }
-        self.progress3 += 1;
-        if self.progress3 > 100 {
-            self.progress3 = 0;
+        self.progress3 += 0.001;
+        if self.progress3 > 1.0 {
+            self.progress3 = 0.0;
         }
         self.progress4 += 3;
         if self.progress4 > 100 {
@@ -72,12 +66,6 @@ fn main() -> Result<(), failure::Error> {
     let mut app = App::new();
 
     loop {
-        let size = terminal.size()?;
-        if size != app.size {
-            terminal.resize(size)?;
-            app.size = size;
-        }
-
         terminal.draw(|mut f| {
             let chunks = Layout::default()
                 .direction(Direction::Vertical)
@@ -89,8 +77,10 @@ fn main() -> Result<(), failure::Error> {
                         Constraint::Percentage(25),
                         Constraint::Percentage(25),
                     ]
-                        .as_ref(),
-                ).split(app.size);
+                    .as_ref(),
+                )
+                .split(f.size());
+
             Gauge::default()
                 .block(Block::default().title("Gauge1").borders(Borders::ALL))
                 .style(Style::default().fg(Color::Yellow))
@@ -103,22 +93,24 @@ fn main() -> Result<(), failure::Error> {
                 .label(&format!("{}/100", app.progress2))
                 .render(&mut f, chunks[1]);
             Gauge::default()
-                .block(Block::default().title("Gauge2").borders(Borders::ALL))
+                .block(Block::default().title("Gauge3").borders(Borders::ALL))
                 .style(Style::default().fg(Color::Yellow))
-                .percent(app.progress3)
+                .ratio(app.progress3)
                 .render(&mut f, chunks[2]);
             Gauge::default()
-                .block(Block::default().title("Gauge3").borders(Borders::ALL))
-                .style(Style::default().fg(Color::Cyan).modifier(Modifier::Italic))
+                .block(Block::default().title("Gauge4").borders(Borders::ALL))
+                .style(Style::default().fg(Color::Cyan).modifier(Modifier::ITALIC))
                 .percent(app.progress4)
                 .label(&format!("{}/100", app.progress2))
                 .render(&mut f, chunks[3]);
         })?;
 
         match events.next()? {
-            Event::Input(input) => if input == Key::Char('q') {
-                break;
-            },
+            Event::Input(input) => {
+                if input == Key::Char('q') {
+                    break;
+                }
+            }
             Event::Tick => {
                 app.update();
             }

examples/layout.rs

@@ -1,9 +1,3 @@
-extern crate failure;
-extern crate log;
-extern crate stderrlog;
-extern crate termion;
-extern crate tui;
-
 #[allow(dead_code)]
 mod util;
 
@@ -14,27 +8,13 @@ use termion::input::MouseTerminal;
 use termion::raw::IntoRawMode;
 use termion::screen::AlternateScreen;
 use tui::backend::TermionBackend;
-use tui::layout::{Constraint, Direction, Layout, Rect};
+use tui::layout::{Constraint, Direction, Layout};
 use tui::widgets::{Block, Borders, Widget};
 use tui::Terminal;
 
-use util::event::{Event, Events};
-
-struct App {
-    size: Rect,
-}
-
-impl App {
-    fn new() -> App {
-        App {
-            size: Rect::default(),
-        }
-    }
-}
+use crate::util::event::{Event, Events};
 
 fn main() -> Result<(), failure::Error> {
-    stderrlog::new().verbosity(4).init()?;
-
     // Terminal initialization
     let stdout = io::stdout().into_raw_mode()?;
     let stdout = MouseTerminal::from(stdout);
@@ -45,16 +25,7 @@ fn main() -> Result<(), failure::Error> {
 
     let events = Events::new();
 
-    // App
-    let mut app = App::new();
-
     loop {
-        let size = terminal.size()?;
-        if size != app.size {
-            terminal.resize(size)?;
-            app.size = size;
-        }
-
         terminal.draw(|mut f| {
             let chunks = Layout::default()
                 .direction(Direction::Vertical)
@@ -64,8 +35,9 @@ fn main() -> Result<(), failure::Error> {
                         Constraint::Percentage(80),
                         Constraint::Percentage(10),
                     ]
-                        .as_ref(),
-                ).split(app.size);
+                    .as_ref(),
+                )
+                .split(f.size());
 
             Block::default()
                 .title("Block")
@@ -78,9 +50,11 @@ fn main() -> Result<(), failure::Error> {
         })?;
 
         match events.next()? {
-            Event::Input(input) => if let Key::Char('q') = input {
-                break;
-            },
+            Event::Input(input) => {
+                if let Key::Char('q') = input {
+                    break;
+                }
+            }
             _ => {}
         }
     }

examples/list.rs

@@ -1,7 +1,3 @@
-extern crate failure;
-extern crate termion;
-extern crate tui;
-
 #[allow(dead_code)]
 mod util;
 
@@ -12,15 +8,14 @@ use termion::input::MouseTerminal;
 use termion::raw::IntoRawMode;
 use termion::screen::AlternateScreen;
 use tui::backend::TermionBackend;
-use tui::layout::{Constraint, Corner, Direction, Layout, Rect};
+use tui::layout::{Constraint, Corner, Direction, Layout};
 use tui::style::{Color, Modifier, Style};
 use tui::widgets::{Block, Borders, List, SelectableList, Text, Widget};
 use tui::Terminal;
 
-use util::event::{Event, Events};
+use crate::util::event::{Event, Events};
 
 struct App<'a> {
-    size: Rect,
     items: Vec<&'a str>,
     selected: Option<usize>,
     events: Vec<(&'a str, &'a str)>,
@@ -33,7 +28,6 @@ struct App<'a> {
 impl<'a> App<'a> {
     fn new() -> App<'a> {
         App {
-            size: Rect::default(),
             items: vec![
                 "Item1", "Item2", "Item3", "Item4", "Item5", "Item6", "Item7", "Item8", "Item9",
                 "Item10", "Item11", "Item12", "Item13", "Item14", "Item15", "Item16", "Item17",
@@ -96,17 +90,11 @@ fn main() -> Result<(), failure::Error> {
     let mut app = App::new();
 
     loop {
-        let size = terminal.size()?;
-        if size != app.size {
-            terminal.resize(size)?;
-            app.size = size;
-        }
-
         terminal.draw(|mut f| {
             let chunks = Layout::default()
                 .direction(Direction::Horizontal)
                 .constraints([Constraint::Percentage(50), Constraint::Percentage(50)].as_ref())
-                .split(app.size);
+                .split(f.size());
 
             let style = Style::default().fg(Color::Black).bg(Color::White);
             SelectableList::default()
@@ -114,7 +102,7 @@ fn main() -> Result<(), failure::Error> {
                 .items(&app.items)
                 .select(app.selected)
                 .style(style)
-                .highlight_style(style.fg(Color::LightGreen).modifier(Modifier::Bold))
+                .highlight_style(style.fg(Color::LightGreen).modifier(Modifier::BOLD))
                 .highlight_symbol(">")
                 .render(&mut f, chunks[0]);
             {

examples/paragraph.rs

@@ -1,7 +1,3 @@
-extern crate failure;
-extern crate termion;
-extern crate tui;
-
 #[allow(dead_code)]
 mod util;
 
@@ -12,24 +8,12 @@ use termion::input::MouseTerminal;
 use termion::raw::IntoRawMode;
 use termion::screen::AlternateScreen;
 use tui::backend::TermionBackend;
-use tui::layout::{Alignment, Constraint, Direction, Layout, Rect};
+use tui::layout::{Alignment, Constraint, Direction, Layout};
 use tui::style::{Color, Modifier, Style};
-use tui::widgets::{Block, Paragraph, Text, Widget};
+use tui::widgets::{Block, Borders, Paragraph, Text, Widget};
 use tui::Terminal;
 
-use util::event::{Event, Events};
-
-struct App {
-    size: Rect,
-}
-
-impl Default for App {
-    fn default() -> App {
-        App {
-            size: Rect::default(),
-        }
-    }
-}
+use crate::util::event::{Event, Events};
 
 fn main() -> Result<(), failure::Error> {
     // Terminal initialization
@@ -42,16 +26,16 @@ fn main() -> Result<(), failure::Error> {
 
     let events = Events::new();
 
-    let mut app = App::default();
-
+    let mut scroll: u16 = 0;
     loop {
-        let size = terminal.size()?;
-        if size != app.size {
-            terminal.resize(size)?;
-            app.size = size;
-        }
-
         terminal.draw(|mut f| {
+            let size = f.size();
+
+            // Words made "loooong" to demonstrate line breaking.
+            let s = "Veeeeeeeeeeeeeeeery    loooooooooooooooooong   striiiiiiiiiiiiiiiiiiiiiiiiiing.   ";
+            let mut long_line = s.repeat(usize::from(size.width) / s.len() + 4);
+            long_line.push('\n');
+
             Block::default()
                 .style(Style::default().bg(Color::White))
                 .render(&mut f, size);
@@ -61,44 +45,64 @@ fn main() -> Result<(), failure::Error> {
                 .margin(5)
                 .constraints(
                     [
-                        Constraint::Percentage(30),
-                        Constraint::Percentage(30),
-                        Constraint::Percentage(30),
+                        Constraint::Percentage(25),
+                        Constraint::Percentage(25),
+                        Constraint::Percentage(25),
+                        Constraint::Percentage(25),
                     ]
-                        .as_ref(),
-                ).split(size);
+                    .as_ref(),
+                )
+                .split(size);
 
             let text = [
-                Text::raw("This a line\n"),
-                Text::styled("This a line\n", Style::default().fg(Color::Red)),
-                Text::styled("This a line\n", Style::default().bg(Color::Blue)),
+                Text::raw("This is a line \n"),
+                Text::styled("This is a line   \n", Style::default().fg(Color::Red)),
+                Text::styled("This is a line\n", Style::default().bg(Color::Blue)),
                 Text::styled(
-                    "This a longer line\n",
-                    Style::default().modifier(Modifier::CrossedOut),
+                    "This is a longer line\n",
+                    Style::default().modifier(Modifier::CROSSED_OUT),
                 ),
+                Text::styled(&long_line, Style::default().bg(Color::Green)),
                 Text::styled(
-                    "This a line\n",
-                    Style::default().fg(Color::Green).modifier(Modifier::Italic),
+                    "This is a line\n",
+                    Style::default().fg(Color::Green).modifier(Modifier::ITALIC),
                 ),
             ];
 
+            let block = Block::default()
+                .borders(Borders::ALL)
+                .title_style(Style::default().modifier(Modifier::BOLD));
             Paragraph::new(text.iter())
+                .block(block.clone().title("Left, no wrap"))
                 .alignment(Alignment::Left)
                 .render(&mut f, chunks[0]);
             Paragraph::new(text.iter())
-                .alignment(Alignment::Center)
+                .block(block.clone().title("Left, wrap"))
+                .alignment(Alignment::Left)
                 .wrap(true)
                 .render(&mut f, chunks[1]);
             Paragraph::new(text.iter())
+                .block(block.clone().title("Center, wrap"))
+                .alignment(Alignment::Center)
+                .wrap(true)
+                .scroll(scroll)
+                .render(&mut f, chunks[2]);
+            Paragraph::new(text.iter())
+                .block(block.clone().title("Right, wrap"))
                 .alignment(Alignment::Right)
                 .wrap(true)
-                .render(&mut f, chunks[2]);
+                .render(&mut f, chunks[3]);
         })?;
 
+        scroll += 1;
+        scroll %= 10;
+
         match events.next()? {
-            Event::Input(key) => if key == Key::Char('q') {
-                break;
-            },
+            Event::Input(key) => {
+                if key == Key::Char('q') {
+                    break;
+                }
+            }
             _ => {}
         }
     }

examples/rustbox.rs

@@ -1,47 +0,0 @@
-extern crate rustbox;
-extern crate tui;
-
-use rustbox::Key;
-use std::error::Error;
-
-use tui::backend::RustboxBackend;
-use tui::layout::{Constraint, Direction, Layout};
-use tui::style::{Color, Modifier, Style};
-use tui::widgets::{Block, Borders, Paragraph, Widget};
-use tui::Terminal;
-
-fn main() {
-    let mut terminal = Terminal::new(RustboxBackend::new().unwrap()).unwrap();
-    terminal.clear().unwrap();
-    terminal.hide_cursor().unwrap();
-    draw(&mut terminal);
-    loop {
-        match terminal.backend().rustbox().poll_event(false) {
-            Ok(rustbox::Event::KeyEvent(key)) => if key == Key::Char('q') {
-                break;
-            },
-            Err(e) => panic!("{}", e.description()),
-            _ => {}
-        };
-        draw(&mut terminal);
-    }
-    terminal.show_cursor().unwrap();
-}
-
-fn draw(t: &mut Terminal<RustboxBackend>) {
-    let size = t.size().unwrap();
-    {
-        let mut f = t.get_frame();
-        Paragraph::default()
-            .block(
-                Block::default()
-                    .title("Rustbox backend")
-                    .title_style(Style::default().fg(Color::Yellow).modifier(Modifier::Bold))
-                    .borders(Borders::ALL)
-                    .border_style(Style::default().fg(Color::Magenta)),
-            ).text("It {yellow works}!")
-            .render(&mut f, &size);
-    }
-
-    t.draw().unwrap();
-}

examples/rustbox_demo.rs

@@ -0,0 +1,66 @@
+mod demo;
+#[allow(dead_code)]
+mod util;
+
+use std::time::{Duration, Instant};
+
+use rustbox::keyboard::Key;
+use structopt::StructOpt;
+use tui::backend::RustboxBackend;
+use tui::Terminal;
+
+use crate::demo::{ui, App};
+
+#[derive(Debug, StructOpt)]
+struct Cli {
+    #[structopt(long = "tick-rate", default_value = "250")]
+    tick_rate: u64,
+    #[structopt(long = "log")]
+    log: bool,
+}
+
+fn main() -> Result<(), failure::Error> {
+    let cli = Cli::from_args();
+    stderrlog::new().quiet(!cli.log).verbosity(4).init()?;
+
+    let backend = RustboxBackend::new()?;
+    let mut terminal = Terminal::new(backend)?;
+    terminal.hide_cursor()?;
+
+    let mut app = App::new("Rustbox demo");
+
+    let mut last_tick = Instant::now();
+    let tick_rate = Duration::from_millis(cli.tick_rate);
+    loop {
+        ui::draw(&mut terminal, &app)?;
+        match terminal.backend().rustbox().peek_event(tick_rate, false) {
+            Ok(rustbox::Event::KeyEvent(key)) => match key {
+                Key::Char(c) => {
+                    app.on_key(c);
+                }
+                Key::Up => {
+                    app.on_up();
+                }
+                Key::Down => {
+                    app.on_down();
+                }
+                Key::Left => {
+                    app.on_left();
+                }
+                Key::Right => {
+                    app.on_right();
+                }
+                _ => {}
+            },
+            _ => {}
+        }
+        if last_tick.elapsed() > tick_rate {
+            app.on_tick();
+            last_tick = Instant::now();
+        }
+        if app.should_quit {
+            break;
+        }
+    }
+    Ok(())
+}

examples/sparkline.rs

@@ -1,7 +1,3 @@
-extern crate failure;
-extern crate termion;
-extern crate tui;
-
 #[allow(dead_code)]
 mod util;
 
@@ -12,16 +8,15 @@ use termion::input::MouseTerminal;
 use termion::raw::IntoRawMode;
 use termion::screen::AlternateScreen;
 use tui::backend::TermionBackend;
-use tui::layout::{Constraint, Direction, Layout, Rect};
+use tui::layout::{Constraint, Direction, Layout};
 use tui::style::{Color, Style};
 use tui::widgets::{Block, Borders, Sparkline, Widget};
 use tui::Terminal;
 
-use util::event::{Event, Events};
-use util::RandomSignal;
+use crate::util::event::{Event, Events};
+use crate::util::RandomSignal;
 
 struct App {
-    size: Rect,
     signal: RandomSignal,
     data1: Vec<u64>,
     data2: Vec<u64>,
@@ -35,7 +30,6 @@ impl App {
         let data2 = signal.by_ref().take(200).collect::<Vec<u64>>();
         let data3 = signal.by_ref().take(200).collect::<Vec<u64>>();
         App {
-            size: Rect::default(),
             signal,
             data1,
             data2,
@@ -72,12 +66,6 @@ fn main() -> Result<(), failure::Error> {
     let mut app = App::new();
 
     loop {
-        let size = terminal.size()?;
-        if size != app.size {
-            terminal.resize(size)?;
-            app.size = size;
-        }
-
         terminal.draw(|mut f| {
             let chunks = Layout::default()
                 .direction(Direction::Vertical)
@@ -89,14 +77,16 @@ fn main() -> Result<(), failure::Error> {
                         Constraint::Length(7),
                         Constraint::Min(0),
                     ]
-                        .as_ref(),
-                ).split(app.size);
+                    .as_ref(),
+                )
+                .split(f.size());
             Sparkline::default()
                 .block(
                     Block::default()
                         .title("Data1")
                         .borders(Borders::LEFT | Borders::RIGHT),
-                ).data(&app.data1)
+                )
+                .data(&app.data1)
                 .style(Style::default().fg(Color::Yellow))
                 .render(&mut f, chunks[0]);
             Sparkline::default()
@@ -104,7 +94,8 @@ fn main() -> Result<(), failure::Error> {
                     Block::default()
                         .title("Data2")
                         .borders(Borders::LEFT | Borders::RIGHT),
-                ).data(&app.data2)
+                )
+                .data(&app.data2)
                 .style(Style::default().bg(Color::Green))
                 .render(&mut f, chunks[1]);
             // Multiline
@@ -113,15 +104,18 @@ fn main() -> Result<(), failure::Error> {
                     Block::default()
                         .title("Data3")
                         .borders(Borders::LEFT | Borders::RIGHT),
-                ).data(&app.data3)
+                )
+                .data(&app.data3)
                 .style(Style::default().fg(Color::Red))
                 .render(&mut f, chunks[2]);
         })?;
 
         match events.next()? {
-            Event::Input(input) => if input == Key::Char('q') {
-                break;
-            },
+            Event::Input(input) => {
+                if input == Key::Char('q') {
+                    break;
+                }
+            }
             Event::Tick => {
                 app.update();
             }

examples/table.rs

@@ -1,7 +1,3 @@
-extern crate failure;
-extern crate termion;
-extern crate tui;
-
 #[allow(dead_code)]
 mod util;
 
@@ -12,15 +8,14 @@ use termion::input::MouseTerminal;
 use termion::raw::IntoRawMode;
 use termion::screen::AlternateScreen;
 use tui::backend::TermionBackend;
-use tui::layout::{Constraint, Layout, Rect};
+use tui::layout::{Constraint, Layout};
 use tui::style::{Color, Modifier, Style};
 use tui::widgets::{Block, Borders, Row, Table, Widget};
 use tui::Terminal;
 
-use util::event::{Event, Events};
+use crate::util::event::{Event, Events};
 
 struct App<'a> {
-    size: Rect,
     items: Vec<Vec<&'a str>>,
     selected: usize,
 }
@@ -28,7 +23,6 @@ struct App<'a> {
 impl<'a> App<'a> {
     fn new() -> App<'a> {
         App {
-            size: Rect::default(),
             items: vec![
                 vec!["Row12", "Row12", "Row13"],
                 vec!["Row21", "Row22", "Row23"],
@@ -58,14 +52,8 @@ fn main() -> Result<(), failure::Error> {
 
     // Input
     loop {
-        let size = terminal.size()?;
-        if size != app.size {
-            terminal.resize(size)?;
-            app.size = size;
-        }
-
         terminal.draw(|mut f| {
-            let selected_style = Style::default().fg(Color::Yellow).modifier(Modifier::Bold);
+            let selected_style = Style::default().fg(Color::Yellow).modifier(Modifier::BOLD);
             let normal_style = Style::default().fg(Color::White);
             let header = ["Header1", "Header2", "Header3"];
             let rows = app.items.iter().enumerate().map(|(i, item)| {
@@ -79,7 +67,7 @@ fn main() -> Result<(), failure::Error> {
             let rects = Layout::default()
                 .constraints([Constraint::Percentage(100)].as_ref())
                 .margin(5)
-                .split(app.size);
+                .split(f.size());
             Table::new(header.into_iter(), rows)
                 .block(Block::default().borders(Borders::ALL).title("Table"))
                 .widths(&[10, 10, 10])
@@ -97,11 +85,13 @@ fn main() -> Result<(), failure::Error> {
                         app.selected = 0;
                     }
                 }
-                Key::Up => if app.selected > 0 {
-                    app.selected -= 1;
-                } else {
-                    app.selected = app.items.len() - 1;
-                },
+                Key::Up => {
+                    if app.selected > 0 {
+                        app.selected -= 1;
+                    } else {
+                        app.selected = app.items.len() - 1;
+                    }
+                }
                 _ => {}
             },
             _ => {}

examples/tabs.rs

@@ -1,7 +1,3 @@
-extern crate failure;
-extern crate termion;
-extern crate tui;
-
 #[allow(dead_code)]
 mod util;
 
@@ -12,16 +8,15 @@ use termion::input::MouseTerminal;
 use termion::raw::IntoRawMode;
 use termion::screen::AlternateScreen;
 use tui::backend::TermionBackend;
-use tui::layout::{Constraint, Direction, Layout, Rect};
+use tui::layout::{Constraint, Direction, Layout};
 use tui::style::{Color, Style};
 use tui::widgets::{Block, Borders, Tabs, Widget};
 use tui::Terminal;
 
-use util::event::{Event, Events};
-use util::TabsState;
+use crate::util::event::{Event, Events};
+use crate::util::TabsState;
 
 struct App<'a> {
-    size: Rect,
     tabs: TabsState<'a>,
 }
 
@@ -38,28 +33,22 @@ fn main() -> Result<(), failure::Error> {
 
     // App
     let mut app = App {
-        size: Rect::default(),
         tabs: TabsState::new(vec!["Tab0", "Tab1", "Tab2", "Tab3"]),
     };
 
     // Main loop
     loop {
-        let size = terminal.size()?;
-        if size != app.size {
-            terminal.resize(size)?;
-            app.size = size;
-        }
-
         terminal.draw(|mut f| {
+            let size = f.size();
             let chunks = Layout::default()
                 .direction(Direction::Vertical)
                 .margin(5)
                 .constraints([Constraint::Length(3), Constraint::Min(0)].as_ref())
-                .split(app.size);
+                .split(size);
 
             Block::default()
                 .style(Style::default().bg(Color::White))
-                .render(&mut f, app.size);
+                .render(&mut f, size);
             Tabs::default()
                 .block(Block::default().borders(Borders::ALL).title("Tabs"))
                 .titles(&app.tabs.titles)

examples/termion_demo.rs

@@ -0,0 +1,75 @@
+mod demo;
+#[allow(dead_code)]
+mod util;
+
+use std::io;
+use std::time::Duration;
+
+use structopt::StructOpt;
+use termion::event::Key;
+use termion::input::MouseTerminal;
+use termion::raw::IntoRawMode;
+use termion::screen::AlternateScreen;
+use tui::backend::TermionBackend;
+use tui::Terminal;
+
+use crate::demo::{ui, App};
+use crate::util::event::{Config, Event, Events};
+
+#[derive(Debug, StructOpt)]
+struct Cli {
+    #[structopt(long = "tick-rate", default_value = "250")]
+    tick_rate: u64,
+    #[structopt(long = "log")]
+    log: bool,
+}
+
+fn main() -> Result<(), failure::Error> {
+    let cli = Cli::from_args();
+    stderrlog::new().quiet(!cli.log).verbosity(4).init()?;
+
+    let events = Events::with_config(Config {
+        tick_rate: Duration::from_millis(cli.tick_rate),
+        ..Config::default()
+    });
+
+    let stdout = io::stdout().into_raw_mode()?;
+    let stdout = MouseTerminal::from(stdout);
+    let stdout = AlternateScreen::from(stdout);
+    let backend = TermionBackend::new(stdout);
+    let mut terminal = Terminal::new(backend)?;
+    terminal.hide_cursor()?;
+
+    let mut app = App::new("Termion demo");
+    loop {
+        ui::draw(&mut terminal, &app)?;
+        match events.next()? {
+            Event::Input(key) => match key {
+                Key::Char(c) => {
+                    app.on_key(c);
+                }
+                Key::Up => {
+                    app.on_up();
+                }
+                Key::Down => {
+                    app.on_down();
+                }
+                Key::Left => {
+                    app.on_left();
+                }
+                Key::Right => {
+                    app.on_right();
+                }
+                _ => {}
+            },
+            Event::Tick => {
+                app.on_tick();
+            }
+        }
+        if app.should_quit {
+            break;
+        }
+    }
+
+    Ok(())
+}

examples/user_input.rs

@@ -1,4 +1,3 @@
-extern crate failure;
 /// A simple example demonstrating how to handle user input. This is
 /// a bit out of the scope of the library as it does not provide any
 /// input handling out of the box. However, it may helps some to get
@@ -10,30 +9,28 @@ extern crate failure;
 ///   * Pressing Backspace erases a character
 ///   * Pressing Enter pushes the current input in the history of previous
 ///   messages
-extern crate termion;
-extern crate tui;
 
 #[allow(dead_code)]
 mod util;
 
-use std::io;
+use std::io::{self, Write};
 
+use termion::cursor::Goto;
 use termion::event::Key;
 use termion::input::MouseTerminal;
 use termion::raw::IntoRawMode;
 use termion::screen::AlternateScreen;
 use tui::backend::TermionBackend;
-use tui::layout::{Constraint, Direction, Layout, Rect};
+use tui::layout::{Constraint, Direction, Layout};
 use tui::style::{Color, Style};
 use tui::widgets::{Block, Borders, List, Paragraph, Text, Widget};
 use tui::Terminal;
+use unicode_width::UnicodeWidthStr;
 
-use util::event::{Event, Events};
+use crate::util::event::{Event, Events};
 
 /// App holds the state of the application
 struct App {
-    /// Current size of the terminal
-    size: Rect,
     /// Current value of the input box
     input: String,
     /// History of recorded messages
@@ -43,7 +40,6 @@ struct App {
 impl Default for App {
     fn default() -> App {
         App {
-            size: Rect::default(),
             input: String::new(),
             messages: Vec::new(),
         }
@@ -57,7 +53,6 @@ fn main() -> Result<(), failure::Error> {
     let stdout = AlternateScreen::from(stdout);
     let backend = TermionBackend::new(stdout);
     let mut terminal = Terminal::new(backend)?;
-    terminal.hide_cursor()?;
 
     // Setup event handlers
     let events = Events::new();
@@ -66,20 +61,13 @@ fn main() -> Result<(), failure::Error> {
     let mut app = App::default();
 
     loop {
-        // Handle resize
-        let size = terminal.size()?;
-        if app.size != size {
-            terminal.resize(size)?;
-            app.size = size;
-        }
-
         // Draw UI
         terminal.draw(|mut f| {
             let chunks = Layout::default()
                 .direction(Direction::Vertical)
                 .margin(2)
                 .constraints([Constraint::Length(3), Constraint::Min(1)].as_ref())
-                .split(app.size);
+                .split(f.size());
             Paragraph::new([Text::raw(&app.input)].iter())
                 .style(Style::default().fg(Color::Yellow))
                 .block(Block::default().borders(Borders::ALL).title("Input"))
@@ -94,6 +82,13 @@ fn main() -> Result<(), failure::Error> {
                 .render(&mut f, chunks[1]);
         })?;
 
+        // Put the cursor back inside the input box
+        write!(
+            terminal.backend_mut(),
+            "{}",
+            Goto(4 + app.input.width() as u16, 4)
+        )?;
+
         // Handle input
         match events.next()? {
             Event::Input(input) => match input {

examples/util/event.rs

@@ -11,7 +11,7 @@ pub enum Event<I> {
     Tick,
 }
 
-/// An small event handler that wrap termion input and tick events. Each event
+/// A small event handler that wrap termion input and tick events. Each event
 /// type is handled in its own thread and returned to a common `Receiver`
 pub struct Events {
     rx: mpsc::Receiver<Event<Key>>,

examples/util/mod.rs

@@ -1,19 +1,19 @@
-extern crate rand;
-
+#[cfg(feature = "termion")]
 pub mod event;
 
-use self::rand::distributions::{IndependentSample, Range};
+use rand::distributions::{Distribution, Uniform};
+use rand::rngs::ThreadRng;
 
 #[derive(Clone)]
 pub struct RandomSignal {
-    range: Range<u64>,
-    rng: rand::ThreadRng,
+    distribution: Uniform<u64>,
+    rng: ThreadRng,
 }
 
 impl RandomSignal {
     pub fn new(lower: u64, upper: u64) -> RandomSignal {
         RandomSignal {
-            range: Range::new(lower, upper),
+            distribution: Uniform::new(lower, upper),
             rng: rand::thread_rng(),
         }
     }
@@ -22,7 +22,7 @@ impl RandomSignal {
 impl Iterator for RandomSignal {
     type Item = u64;
     fn next(&mut self) -> Option<u64> {
-        Some(self.range.ind_sample(&mut self.rng))
+        Some(self.distribution.sample(&mut self.rng))
     }
 }
 

src/backend/crossterm.rs

@@ -1,56 +1,100 @@
-extern crate crossterm;
-
 use std::io;
 
-use backend::Backend;
-use buffer::Cell;
-use layout::Rect;
-use style::{Color, Modifier};
+use crate::backend::Backend;
+use crate::style::{Color, Modifier};
+use crate::{buffer::Cell, layout::Rect};
+use crossterm::{Crossterm, ErrorKind};
+use std::io::{stdout, Write};
 
 pub struct CrosstermBackend {
-    screen: crossterm::Screen,
+    alternate_screen: Option<crossterm::AlternateScreen>,
+    crossterm: Crossterm,
+}
+
+impl Default for CrosstermBackend {
+    fn default() -> CrosstermBackend {
+        CrosstermBackend {
+            crossterm: Crossterm::new(),
+            alternate_screen: None,
+        }
+    }
 }
 
 impl CrosstermBackend {
     pub fn new() -> CrosstermBackend {
-        CrosstermBackend {
-            screen: crossterm::Screen::default(),
+        CrosstermBackend::default()
+    }
+
+    pub fn with_alternate_screen(
+        alternate_screen: crossterm::AlternateScreen,
+    ) -> Result<CrosstermBackend, io::Error> {
+        Ok(CrosstermBackend {
+            crossterm: Crossterm::new(),
+            alternate_screen: Some(alternate_screen),
+        })
+    }
+
+    pub fn alternate_screen(&self) -> Option<&crossterm::AlternateScreen> {
+        match &self.alternate_screen {
+            Some(alt_screen) => Some(&alt_screen),
+            None => None,
         }
     }
 
-    pub fn screen(&self) -> &crossterm::Screen {
-        &self.screen
+    pub fn crossterm(&self) -> &crossterm::Crossterm {
+        &self.crossterm
+    }
+}
+
+// TODO: consider associated Error type on Backend to allow custom error types
+// per backend
+fn convert_error(error: ErrorKind) -> io::Error {
+    match error {
+        ErrorKind::IoError(err) => err,
+        ErrorKind::FmtError(err) => {
+            io::Error::new(io::ErrorKind::Other, format!("Invalid formatting: {}", err))
+        }
+        ErrorKind::ResizingTerminalFailure(err) => io::Error::new(
+            io::ErrorKind::Other,
+            format!("Failed to resize terminal: {}", err),
+        ),
+        _ => io::Error::new(io::ErrorKind::Other, "Unknown crossterm error"),
     }
 }
 
 impl Backend for CrosstermBackend {
     fn clear(&mut self) -> io::Result<()> {
-        let terminal = crossterm::terminal::terminal(&self.screen);
-        terminal.clear(crossterm::terminal::ClearType::All);
+        let terminal = self.crossterm.terminal();
+        terminal.clear(crossterm::ClearType::All)?;
         Ok(())
     }
 
     fn hide_cursor(&mut self) -> io::Result<()> {
-        let cursor = crossterm::cursor(&self.screen);
-        cursor.hide();
+        let cursor = self.crossterm.cursor();
+        cursor.hide().map_err(convert_error)?;
         Ok(())
     }
 
     fn show_cursor(&mut self) -> io::Result<()> {
-        let cursor = crossterm::cursor(&self.screen);
-        cursor.show();
+        let cursor = self.crossterm.cursor();
+        cursor.show().map_err(convert_error)?;
         Ok(())
     }
 
+    fn get_cursor(&mut self) -> io::Result<(u16, u16)> {
+        let cursor = crossterm::cursor();
+        Ok(cursor.pos())
+    }
+
+    fn set_cursor(&mut self, x: u16, y: u16) -> io::Result<()> {
+        let cursor = crossterm::cursor();
+        cursor.goto(x, y).map_err(convert_error)
+    }
+
     fn size(&self) -> io::Result<Rect> {
-        let terminal = crossterm::terminal::terminal(&self.screen);
+        let terminal = self.crossterm.terminal();
         let (width, height) = terminal.terminal_size();
-        Ok(Rect {
-            x: 0,
-            y: 0,
-            width,
-            height,
-        })
+        Ok(Rect::new(0, 0, width, height))
     }
 
     fn flush(&mut self) -> io::Result<()> {
@@ -61,27 +105,31 @@ impl Backend for CrosstermBackend {
     where
         I: Iterator<Item = (u16, u16, &'a Cell)>,
     {
-        let cursor = crossterm::cursor(&self.screen);
+        let cursor = self.crossterm.cursor();
         let mut last_y = 0;
         let mut last_x = 0;
+        let mut first = true;
+
+        let stdout = stdout();
+        let mut handle = stdout.lock();
+
         for (x, y, cell) in content {
-            if y != last_y || x != last_x + 1 {
-                cursor.goto(x, y);
+            if y != last_y || x != last_x + 1 || first {
+                cursor.goto(x, y).map_err(convert_error)?;
+                first = false;
             }
             last_x = x;
             last_y = y;
-
-            let mut s = crossterm::style(&cell.symbol);
+            let mut s = self.crossterm.style(&cell.symbol);
             if let Some(color) = cell.style.fg.into() {
                 s = s.with(color)
             }
             if let Some(color) = cell.style.bg.into() {
                 s = s.on(color)
             }
-            if let Some(attr) = cell.style.modifier.into() {
-                s = s.attr(attr)
-            }
-            s.paint(&self.screen);
+            s.object_style.attrs = cell.style.modifier.into();
+
+            write!(handle, "{}", s)?;
         }
         Ok(())
     }
@@ -107,22 +155,59 @@ impl From<Color> for Option<crossterm::Color> {
             Color::LightMagenta => Some(crossterm::Color::Magenta),
             Color::LightCyan => Some(crossterm::Color::Cyan),
             Color::White => Some(crossterm::Color::White),
+            Color::Indexed(i) => Some(crossterm::Color::AnsiValue(i)),
             Color::Rgb(r, g, b) => Some(crossterm::Color::Rgb { r, g, b }),
         }
     }
 }
 
-impl From<Modifier> for Option<crossterm::Attribute> {
-    fn from(modifier: Modifier) -> Option<crossterm::Attribute> {
-        match modifier {
-            Modifier::Blink => Some(crossterm::Attribute::SlowBlink),
-            Modifier::Bold => Some(crossterm::Attribute::Bold),
-            Modifier::CrossedOut => Some(crossterm::Attribute::CrossedOut),
-            Modifier::Faint => Some(crossterm::Attribute::Dim),
-            Modifier::Invert => Some(crossterm::Attribute::Reverse),
-            Modifier::Italic => Some(crossterm::Attribute::Italic),
-            Modifier::Underline => Some(crossterm::Attribute::Underlined),
-            _ => None,
+impl From<Modifier> for Vec<crossterm::Attribute> {
+    #[cfg(unix)]
+    fn from(modifier: Modifier) -> Vec<crossterm::Attribute> {
+        let mut result = Vec::new();
+
+        if modifier.contains(Modifier::BOLD) {
+            result.push(crossterm::Attribute::Bold)
         }
+        if modifier.contains(Modifier::DIM) {
+            result.push(crossterm::Attribute::Dim)
+        }
+        if modifier.contains(Modifier::ITALIC) {
+            result.push(crossterm::Attribute::Italic)
+        }
+        if modifier.contains(Modifier::UNDERLINED) {
+            result.push(crossterm::Attribute::Underlined)
+        }
+        if modifier.contains(Modifier::SLOW_BLINK) {
+            result.push(crossterm::Attribute::SlowBlink)
+        }
+        if modifier.contains(Modifier::RAPID_BLINK) {
+            result.push(crossterm::Attribute::RapidBlink)
+        }
+        if modifier.contains(Modifier::REVERSED) {
+            result.push(crossterm::Attribute::Reverse)
+        }
+        if modifier.contains(Modifier::HIDDEN) {
+            result.push(crossterm::Attribute::Hidden)
+        }
+        if modifier.contains(Modifier::CROSSED_OUT) {
+            result.push(crossterm::Attribute::CrossedOut)
+        }
+
+        result
+    }
+
+    #[cfg(windows)]
+    fn from(modifier: Modifier) -> Vec<crossterm::Attribute> {
+        let mut result = Vec::new();
+
+        if modifier.contains(Modifier::BOLD) {
+            result.push(crossterm::Attribute::Bold)
+        }
+        if modifier.contains(Modifier::UNDERLINED) {
+            result.push(crossterm::Attribute::Underlined)
+        }
+
+        result
     }
 }

src/backend/curses.rs

@@ -0,0 +1,283 @@
+use std::io;
+
+use crate::backend::Backend;
+use crate::buffer::Cell;
+use crate::layout::Rect;
+use crate::style::{Color, Modifier, Style};
+use crate::symbols::{bar, block};
+#[cfg(unix)]
+use crate::symbols::{line, DOT};
+#[cfg(unix)]
+use pancurses::{chtype, ToChtype};
+use unicode_segmentation::UnicodeSegmentation;
+
+pub struct CursesBackend {
+    curses: easycurses::EasyCurses,
+}
+
+impl CursesBackend {
+    pub fn new() -> Option<CursesBackend> {
+        let curses = easycurses::EasyCurses::initialize_system()?;
+        Some(CursesBackend { curses })
+    }
+
+    pub fn with_curses(curses: easycurses::EasyCurses) -> CursesBackend {
+        CursesBackend { curses }
+    }
+
+    pub fn get_curses(&self) -> &easycurses::EasyCurses {
+        &self.curses
+    }
+
+    pub fn get_curses_mut(&mut self) -> &mut easycurses::EasyCurses {
+        &mut self.curses
+    }
+}
+
+impl Backend for CursesBackend {
+    fn draw<'a, I>(&mut self, content: I) -> io::Result<()>
+    where
+        I: Iterator<Item = (u16, u16, &'a Cell)>,
+    {
+        let mut last_col = 0;
+        let mut last_row = 0;
+        let mut style = Style {
+            fg: Color::Reset,
+            bg: Color::Reset,
+            modifier: Modifier::empty(),
+        };
+        let mut curses_style = CursesStyle {
+            fg: easycurses::Color::White,
+            bg: easycurses::Color::Black,
+        };
+        let mut update_color = false;
+        for (col, row, cell) in content {
+            // eprintln!("{:?}", cell);
+            if row != last_row || col != last_col + 1 {
+                self.curses.move_rc(i32::from(row), i32::from(col));
+            }
+            last_col = col;
+            last_row = row;
+            if cell.style.modifier != style.modifier {
+                apply_modifier_diff(&mut self.curses.win, style.modifier, cell.style.modifier);
+                style.modifier = cell.style.modifier;
+            };
+            if cell.style.fg != style.fg {
+                update_color = true;
+                if let Some(ccolor) = cell.style.fg.into() {
+                    style.fg = cell.style.fg;
+                    curses_style.fg = ccolor;
+                } else {
+                    style.fg = Color::White;
+                    curses_style.fg = easycurses::Color::White;
+                }
+            };
+            if cell.style.bg != style.bg {
+                update_color = true;
+                if let Some(ccolor) = cell.style.bg.into() {
+                    style.bg = cell.style.bg;
+                    curses_style.bg = ccolor;
+                } else {
+                    style.bg = Color::Black;
+                    curses_style.bg = easycurses::Color::Black;
+                }
+            };
+            if update_color {
+                self.curses
+                    .set_color_pair(easycurses::ColorPair::new(curses_style.fg, curses_style.bg));
+            };
+            update_color = false;
+            draw(&mut self.curses, cell.symbol.as_str());
+        }
+        self.curses.win.attrset(pancurses::Attribute::Normal);
+        self.curses.set_color_pair(easycurses::ColorPair::new(
+            easycurses::Color::White,
+            easycurses::Color::Black,
+        ));
+        Ok(())
+    }
+    fn hide_cursor(&mut self) -> io::Result<()> {
+        self.curses
+            .set_cursor_visibility(easycurses::CursorVisibility::Invisible);
+        Ok(())
+    }
+    fn show_cursor(&mut self) -> io::Result<()> {
+        self.curses
+            .set_cursor_visibility(easycurses::CursorVisibility::Visible);
+        Ok(())
+    }
+    fn get_cursor(&mut self) -> io::Result<(u16, u16)> {
+        let (x, y) = self.curses.get_cursor_rc();
+        Ok((x as u16, y as u16))
+    }
+    fn set_cursor(&mut self, x: u16, y: u16) -> io::Result<()> {
+        self.curses.move_rc(i32::from(x), i32::from(y));
+        Ok(())
+    }
+    fn clear(&mut self) -> io::Result<()> {
+        self.curses.clear();
+        // self.curses.refresh();
+        Ok(())
+    }
+    fn size(&self) -> Result<Rect, io::Error> {
+        let (nrows, ncols) = self.curses.get_row_col_count();
+        Ok(Rect::new(0, 0, ncols as u16, nrows as u16))
+    }
+    fn flush(&mut self) -> io::Result<()> {
+        self.curses.refresh();
+        Ok(())
+    }
+}
+
+struct CursesStyle {
+    fg: easycurses::Color,
+    bg: easycurses::Color,
+}
+
+#[cfg(unix)]
+/// Deals with lack of unicode support for ncurses on unix
+fn draw(curses: &mut easycurses::EasyCurses, symbol: &str) {
+    for grapheme in symbol.graphemes(true) {
+        let ch = match grapheme {
+            line::TOP_RIGHT => pancurses::ACS_URCORNER(),
+            line::VERTICAL => pancurses::ACS_VLINE(),
+            line::HORIZONTAL => pancurses::ACS_HLINE(),
+            line::TOP_LEFT => pancurses::ACS_ULCORNER(),
+            line::BOTTOM_RIGHT => pancurses::ACS_LRCORNER(),
+            line::BOTTOM_LEFT => pancurses::ACS_LLCORNER(),
+            line::VERTICAL_LEFT => pancurses::ACS_RTEE(),
+            line::VERTICAL_RIGHT => pancurses::ACS_LTEE(),
+            line::HORIZONTAL_DOWN => pancurses::ACS_TTEE(),
+            line::HORIZONTAL_UP => pancurses::ACS_BTEE(),
+            block::FULL => pancurses::ACS_BLOCK(),
+            block::SEVEN_EIGHTHS => pancurses::ACS_BLOCK(),
+            block::THREE_QUATERS => pancurses::ACS_BLOCK(),
+            block::FIVE_EIGHTHS => pancurses::ACS_BLOCK(),
+            block::HALF => pancurses::ACS_BLOCK(),
+            block::THREE_EIGHTHS => ' ' as chtype,
+            block::ONE_QUATER => ' ' as chtype,
+            block::ONE_EIGHTH => ' ' as chtype,
+            bar::SEVEN_EIGHTHS => pancurses::ACS_BLOCK(),
+            bar::THREE_QUATERS => pancurses::ACS_BLOCK(),
+            bar::FIVE_EIGHTHS => pancurses::ACS_BLOCK(),
+            bar::HALF => pancurses::ACS_BLOCK(),
+            bar::THREE_EIGHTHS => pancurses::ACS_S9(),
+            bar::ONE_QUATER => pancurses::ACS_S9(),
+            bar::ONE_EIGHTH => pancurses::ACS_S9(),
+            DOT => pancurses::ACS_BULLET(),
+            unicode_char => {
+                if unicode_char.is_ascii() {
+                    let mut chars = unicode_char.chars();
+                    if let Some(ch) = chars.next() {
+                        ch.to_chtype()
+                    } else {
+                        pancurses::ACS_BLOCK()
+                    }
+                } else {
+                    pancurses::ACS_BLOCK()
+                }
+            }
+        };
+        curses.win.addch(ch);
+    }
+}
+
+#[cfg(windows)]
+fn draw(curses: &mut easycurses::EasyCurses, symbol: &str) {
+    for grapheme in symbol.graphemes(true) {
+        let ch = match grapheme {
+            block::SEVEN_EIGHTHS => block::FULL,
+            block::THREE_QUATERS => block::FULL,
+            block::FIVE_EIGHTHS => block::HALF,
+            block::THREE_EIGHTHS => block::HALF,
+            block::ONE_QUATER => block::HALF,
+            block::ONE_EIGHTH => " ",
+            bar::SEVEN_EIGHTHS => bar::FULL,
+            bar::THREE_QUATERS => bar::FULL,
+            bar::FIVE_EIGHTHS => bar::HALF,
+            bar::THREE_EIGHTHS => bar::HALF,
+            bar::ONE_QUATER => bar::HALF,
+            bar::ONE_EIGHTH => " ",
+            ch => ch,
+        };
+        // curses.win.addch(ch);
+        curses.print(ch);
+    }
+}
+
+impl From<Color> for Option<easycurses::Color> {
+    fn from(color: Color) -> Option<easycurses::Color> {
+        match color {
+            Color::Reset => None,
+            Color::Black => Some(easycurses::Color::Black),
+            Color::Red | Color::LightRed => Some(easycurses::Color::Red),
+            Color::Green | Color::LightGreen => Some(easycurses::Color::Green),
+            Color::Yellow | Color::LightYellow => Some(easycurses::Color::Yellow),
+            Color::Magenta | Color::LightMagenta => Some(easycurses::Color::Magenta),
+            Color::Cyan | Color::LightCyan => Some(easycurses::Color::Cyan),
+            Color::White | Color::Gray | Color::DarkGray => Some(easycurses::Color::White),
+            Color::Blue | Color::LightBlue => Some(easycurses::Color::Blue),
+            Color::Indexed(_) => None,
+            Color::Rgb(_, _, _) => None,
+        }
+    }
+}
+
+fn apply_modifier_diff(win: &mut pancurses::Window, from: Modifier, to: Modifier) {
+    remove_modifier(win, from - to);
+    add_modifier(win, to - from);
+}
+
+fn remove_modifier(win: &mut pancurses::Window, remove: Modifier) {
+    if remove.contains(Modifier::BOLD) {
+        win.attroff(pancurses::Attribute::Bold);
+    }
+    if remove.contains(Modifier::DIM) {
+        win.attroff(pancurses::Attribute::Dim);
+    }
+    if remove.contains(Modifier::ITALIC) {
+        win.attroff(pancurses::Attribute::Italic);
+    }
+    if remove.contains(Modifier::UNDERLINED) {
+        win.attroff(pancurses::Attribute::Underline);
+    }
+    if remove.contains(Modifier::SLOW_BLINK) || remove.contains(Modifier::RAPID_BLINK) {
+        win.attroff(pancurses::Attribute::Blink);
+    }
+    if remove.contains(Modifier::REVERSED) {
+        win.attroff(pancurses::Attribute::Reverse);
+    }
+    if remove.contains(Modifier::HIDDEN) {
+        win.attroff(pancurses::Attribute::Invisible);
+    }
+    if remove.contains(Modifier::CROSSED_OUT) {
+        win.attroff(pancurses::Attribute::Strikeout);
+    }
+}
+
+fn add_modifier(win: &mut pancurses::Window, add: Modifier) {
+    if add.contains(Modifier::BOLD) {
+        win.attron(pancurses::Attribute::Bold);
+    }
+    if add.contains(Modifier::DIM) {
+        win.attron(pancurses::Attribute::Dim);
+    }
+    if add.contains(Modifier::ITALIC) {
+        win.attron(pancurses::Attribute::Italic);
+    }
+    if add.contains(Modifier::UNDERLINED) {
+        win.attron(pancurses::Attribute::Underline);
+    }
+    if add.contains(Modifier::SLOW_BLINK) || add.contains(Modifier::RAPID_BLINK) {
+        win.attron(pancurses::Attribute::Blink);
+    }
+    if add.contains(Modifier::REVERSED) {
+        win.attron(pancurses::Attribute::Reverse);
+    }
+    if add.contains(Modifier::HIDDEN) {
+        win.attron(pancurses::Attribute::Invisible);
+    }
+    if add.contains(Modifier::CROSSED_OUT) {
+        win.attron(pancurses::Attribute::Strikeout);
+    }
+}

src/backend/mod.rs

@@ -1,7 +1,7 @@
 use std::io;
 
-use buffer::Cell;
-use layout::Rect;
+use crate::buffer::Cell;
+use crate::layout::Rect;
 
 #[cfg(feature = "rustbox")]
 mod rustbox;
@@ -18,12 +18,22 @@ mod crossterm;
 #[cfg(feature = "crossterm")]
 pub use self::crossterm::CrosstermBackend;
 
+#[cfg(feature = "curses")]
+mod curses;
+#[cfg(feature = "curses")]
+pub use self::curses::CursesBackend;
+
+mod test;
+pub use self::test::TestBackend;
+
 pub trait Backend {
     fn draw<'a, I>(&mut self, content: I) -> Result<(), io::Error>
     where
         I: Iterator<Item = (u16, u16, &'a Cell)>;
     fn hide_cursor(&mut self) -> Result<(), io::Error>;
     fn show_cursor(&mut self) -> Result<(), io::Error>;
+    fn get_cursor(&mut self) -> Result<(u16, u16), io::Error>;
+    fn set_cursor(&mut self, x: u16, y: u16) -> Result<(), io::Error>;
     fn clear(&mut self) -> Result<(), io::Error>;
     fn size(&self) -> Result<Rect, io::Error>;
     fn flush(&mut self) -> Result<(), io::Error>;

src/backend/rustbox.rs

@@ -1,11 +1,10 @@
-extern crate rustbox;
-
+use log::debug;
 use std::io;
 
 use super::Backend;
-use buffer::Cell;
-use layout::Rect;
-use style::{Color, Modifier};
+use crate::buffer::Cell;
+use crate::layout::Rect;
+use crate::style::{Color, Modifier};
 
 pub struct RustboxBackend {
     rustbox: rustbox::RustBox,
@@ -13,8 +12,8 @@ pub struct RustboxBackend {
 
 impl RustboxBackend {
     pub fn new() -> Result<RustboxBackend, rustbox::InitError> {
-        let rustbox = try!(rustbox::RustBox::init(Default::default()));
-        Ok(RustboxBackend { rustbox: rustbox })
+        let rustbox = r#try!(rustbox::RustBox::init(Default::default()));
+        Ok(RustboxBackend { rustbox })
     }
 
     pub fn with_rustbox(instance: rustbox::RustBox) -> RustboxBackend {
@@ -52,17 +51,35 @@ impl Backend for RustboxBackend {
     fn show_cursor(&mut self) -> Result<(), io::Error> {
         Ok(())
     }
+    fn get_cursor(&mut self) -> io::Result<(u16, u16)> {
+        Err(io::Error::from(io::ErrorKind::Other))
+    }
+    fn set_cursor(&mut self, x: u16, y: u16) -> io::Result<()> {
+        self.rustbox.set_cursor(x as isize, y as isize);
+        Ok(())
+    }
     fn clear(&mut self) -> Result<(), io::Error> {
         self.rustbox.clear();
         Ok(())
     }
     fn size(&self) -> Result<Rect, io::Error> {
-        Ok(Rect {
-            x: 0,
-            y: 0,
-            width: self.rustbox.width() as u16,
-            height: self.rustbox.height() as u16,
-        })
+        let term_width = self.rustbox.width();
+        let term_height = self.rustbox.height();
+        let max = u16::max_value();
+        Ok(Rect::new(
+            0,
+            0,
+            if term_width > usize::from(max) {
+                max
+            } else {
+                term_width as u16
+            },
+            if term_height > usize::from(max) {
+                max
+            } else {
+                term_height as u16
+            },
+        ))
     }
     fn flush(&mut self) -> Result<(), io::Error> {
         self.rustbox.present();
@@ -86,6 +103,7 @@ impl Into<rustbox::Color> for Color {
             Color::Cyan | Color::LightCyan => rustbox::Color::Cyan,
             Color::White => rustbox::Color::White,
             Color::Blue | Color::LightBlue => rustbox::Color::Blue,
+            Color::Indexed(i) => rustbox::Color::Byte(u16::from(i)),
             Color::Rgb(r, g, b) => rustbox::Color::Byte(rgb_to_byte(r, g, b)),
         }
     }
@@ -93,11 +111,16 @@ impl Into<rustbox::Color> for Color {
 
 impl Into<rustbox::Style> for Modifier {
     fn into(self) -> rustbox::Style {
-        match self {
-            Modifier::Bold => rustbox::RB_BOLD,
-            Modifier::Underline => rustbox::RB_UNDERLINE,
-            Modifier::Invert => rustbox::RB_REVERSE,
-            _ => rustbox::RB_NORMAL,
+        let mut result = rustbox::Style::empty();
+        if self.contains(Modifier::BOLD) {
+            result.insert(rustbox::RB_BOLD);
         }
+        if self.contains(Modifier::UNDERLINED) {
+            result.insert(rustbox::RB_UNDERLINE);
+        }
+        if self.contains(Modifier::REVERSED) {
+            result.insert(rustbox::RB_REVERSE);
+        }
+        result
     }
 }

src/backend/termion.rs

@@ -1,12 +1,12 @@
-extern crate termion;
-
+use log::debug;
+use std::fmt;
 use std::io;
 use std::io::Write;
 
 use super::Backend;
-use buffer::Cell;
-use layout::Rect;
-use style::{Color, Modifier, Style};
+use crate::buffer::Cell;
+use crate::layout::Rect;
+use crate::style;
 
 pub struct TermionBackend<W>
 where
@@ -60,38 +60,55 @@ where
         self.stdout.flush()
     }
 
+    /// Gets cursor position (0-based index)
+    fn get_cursor(&mut self) -> io::Result<(u16, u16)> {
+        termion::cursor::DetectCursorPos::cursor_pos(&mut self.stdout).map(|(x, y)| (x - 1, y - 1))
+    }
+
+    /// Sets cursor position (0-based index)
+    fn set_cursor(&mut self, x: u16, y: u16) -> io::Result<()> {
+        write!(self.stdout, "{}", termion::cursor::Goto(x + 1, y + 1))?;
+        self.stdout.flush()
+    }
+
     fn draw<'a, I>(&mut self, content: I) -> io::Result<()>
     where
         I: Iterator<Item = (u16, u16, &'a Cell)>,
     {
+        use std::fmt::Write;
+
         let mut string = String::with_capacity(content.size_hint().0 * 3);
-        let mut style = Style::default();
+        let mut style = style::Style::default();
         let mut last_y = 0;
         let mut last_x = 0;
         let mut inst = 0;
         for (x, y, cell) in content {
-            if y != last_y || x != last_x + 1 {
-                string.push_str(&format!("{}", termion::cursor::Goto(x + 1, y + 1)));
+            if y != last_y || x != last_x + 1 || inst == 0 {
+                write!(string, "{}", termion::cursor::Goto(x + 1, y + 1)).unwrap();
                 inst += 1;
             }
             last_x = x;
             last_y = y;
             if cell.style.modifier != style.modifier {
-                string.push_str(&cell.style.modifier.termion_modifier());
+                write!(
+                    string,
+                    "{}",
+                    ModifierDiff {
+                        from: style.modifier,
+                        to: cell.style.modifier
+                    }
+                )
+                .unwrap();
                 style.modifier = cell.style.modifier;
-                if style.modifier == Modifier::Reset {
-                    style.bg = Color::Reset;
-                    style.fg = Color::Reset;
-                }
                 inst += 1;
             }
             if cell.style.fg != style.fg {
-                string.push_str(&cell.style.fg.termion_fg());
+                write!(string, "{}", Fg(cell.style.fg)).unwrap();
                 style.fg = cell.style.fg;
                 inst += 1;
             }
             if cell.style.bg != style.bg {
-                string.push_str(&cell.style.bg.termion_bg());
+                write!(string, "{}", Bg(cell.style.bg)).unwrap();
                 style.bg = cell.style.bg;
                 inst += 1;
             }
@@ -103,21 +120,16 @@ where
             self.stdout,
             "{}{}{}{}",
             string,
-            Color::Reset.termion_fg(),
-            Color::Reset.termion_bg(),
-            Modifier::Reset.termion_modifier()
+            Fg(style::Color::Reset),
+            Bg(style::Color::Reset),
+            termion::style::Reset,
         )
     }
 
     /// Return the size of the terminal
     fn size(&self) -> io::Result<Rect> {
-        let terminal = try!(termion::terminal_size());
-        Ok(Rect {
-            x: 0,
-            y: 0,
-            width: terminal.0,
-            height: terminal.1,
-        })
+        let terminal = r#try!(termion::terminal_size());
+        Ok(Rect::new(0, 0, terminal.0, terminal.1))
     }
 
     fn flush(&mut self) -> io::Result<()> {
@@ -125,102 +137,131 @@ where
     }
 }
 
-macro_rules! termion_fg {
-    ($color:ident) => {
-        format!("{}", termion::color::Fg(termion::color::$color))
-    };
+struct Fg(style::Color);
+
+struct Bg(style::Color);
+
+struct ModifierDiff {
+    from: style::Modifier,
+    to: style::Modifier,
 }
 
-macro_rules! termion_fg_rgb {
-    ($r:expr, $g:expr, $b:expr) => {
-        format!("{}", termion::color::Fg(termion::color::Rgb($r, $g, $b)))
-    };
-}
-
-macro_rules! termion_bg {
-    ($color:ident) => {
-        format!("{}", termion::color::Bg(termion::color::$color))
-    };
-}
-
-macro_rules! termion_bg_rgb {
-    ($r:expr, $g:expr, $b:expr) => {
-        format!("{}", termion::color::Bg(termion::color::Rgb($r, $g, $b)))
-    };
-}
-
-macro_rules! termion_modifier {
-    ($style:ident) => {
-        format!("{}", termion::style::$style)
-    };
-}
-
-impl Color {
-    pub fn termion_fg(self) -> String {
-        match self {
-            Color::Reset => termion_fg!(Reset),
-            Color::Black => termion_fg!(Black),
-            Color::Red => termion_fg!(Red),
-            Color::Green => termion_fg!(Green),
-            Color::Yellow => termion_fg!(Yellow),
-            Color::Blue => termion_fg!(Blue),
-            Color::Magenta => termion_fg!(Magenta),
-            Color::Cyan => termion_fg!(Cyan),
-            Color::Gray => termion_fg!(White),
-            Color::DarkGray => termion_fg!(LightBlack),
-            Color::LightRed => termion_fg!(LightRed),
-            Color::LightGreen => termion_fg!(LightGreen),
-            Color::LightBlue => termion_fg!(LightBlue),
-            Color::LightYellow => termion_fg!(LightYellow),
-            Color::LightMagenta => termion_fg!(LightMagenta),
-            Color::LightCyan => termion_fg!(LightCyan),
-            Color::White => termion_fg!(LightWhite),
-            Color::Rgb(r, g, b) => termion_fg_rgb!(r, g, b),
+impl fmt::Display for Fg {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        use termion::color::Color;
+        match self.0 {
+            style::Color::Reset => termion::color::Reset.write_fg(f),
+            style::Color::Black => termion::color::Black.write_fg(f),
+            style::Color::Red => termion::color::Red.write_fg(f),
+            style::Color::Green => termion::color::Green.write_fg(f),
+            style::Color::Yellow => termion::color::Yellow.write_fg(f),
+            style::Color::Blue => termion::color::Blue.write_fg(f),
+            style::Color::Magenta => termion::color::Magenta.write_fg(f),
+            style::Color::Cyan => termion::color::Cyan.write_fg(f),
+            style::Color::Gray => termion::color::White.write_fg(f),
+            style::Color::DarkGray => termion::color::LightBlack.write_fg(f),
+            style::Color::LightRed => termion::color::LightRed.write_fg(f),
+            style::Color::LightGreen => termion::color::LightGreen.write_fg(f),
+            style::Color::LightBlue => termion::color::LightBlue.write_fg(f),
+            style::Color::LightYellow => termion::color::LightYellow.write_fg(f),
+            style::Color::LightMagenta => termion::color::LightMagenta.write_fg(f),
+            style::Color::LightCyan => termion::color::LightCyan.write_fg(f),
+            style::Color::White => termion::color::LightWhite.write_fg(f),
+            style::Color::Indexed(i) => termion::color::AnsiValue(i).write_fg(f),
+            style::Color::Rgb(r, g, b) => termion::color::Rgb(r, g, b).write_fg(f),
         }
     }
-    pub fn termion_bg(self) -> String {
-        match self {
-            Color::Reset => termion_bg!(Reset),
-            Color::Black => termion_bg!(Black),
-            Color::Red => termion_bg!(Red),
-            Color::Green => termion_bg!(Green),
-            Color::Yellow => termion_bg!(Yellow),
-            Color::Blue => termion_bg!(Blue),
-            Color::Magenta => termion_bg!(Magenta),
-            Color::Cyan => termion_bg!(Cyan),
-            Color::Gray => termion_bg!(White),
-            Color::DarkGray => termion_bg!(LightBlack),
-            Color::LightRed => termion_bg!(LightRed),
-            Color::LightGreen => termion_bg!(LightGreen),
-            Color::LightBlue => termion_bg!(LightBlue),
-            Color::LightYellow => termion_bg!(LightYellow),
-            Color::LightMagenta => termion_bg!(LightMagenta),
-            Color::LightCyan => termion_bg!(LightCyan),
-            Color::White => termion_bg!(LightWhite),
-            Color::Rgb(r, g, b) => termion_bg_rgb!(r, g, b),
+}
+impl fmt::Display for Bg {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        use termion::color::Color;
+        match self.0 {
+            style::Color::Reset => termion::color::Reset.write_bg(f),
+            style::Color::Black => termion::color::Black.write_bg(f),
+            style::Color::Red => termion::color::Red.write_bg(f),
+            style::Color::Green => termion::color::Green.write_bg(f),
+            style::Color::Yellow => termion::color::Yellow.write_bg(f),
+            style::Color::Blue => termion::color::Blue.write_bg(f),
+            style::Color::Magenta => termion::color::Magenta.write_bg(f),
+            style::Color::Cyan => termion::color::Cyan.write_bg(f),
+            style::Color::Gray => termion::color::White.write_bg(f),
+            style::Color::DarkGray => termion::color::LightBlack.write_bg(f),
+            style::Color::LightRed => termion::color::LightRed.write_bg(f),
+            style::Color::LightGreen => termion::color::LightGreen.write_bg(f),
+            style::Color::LightBlue => termion::color::LightBlue.write_bg(f),
+            style::Color::LightYellow => termion::color::LightYellow.write_bg(f),
+            style::Color::LightMagenta => termion::color::LightMagenta.write_bg(f),
+            style::Color::LightCyan => termion::color::LightCyan.write_bg(f),
+            style::Color::White => termion::color::LightWhite.write_bg(f),
+            style::Color::Indexed(i) => termion::color::AnsiValue(i).write_bg(f),
+            style::Color::Rgb(r, g, b) => termion::color::Rgb(r, g, b).write_bg(f),
         }
     }
 }
 
-impl Modifier {
-    pub fn termion_modifier(self) -> String {
-        match self {
-            Modifier::Blink => termion_modifier!(Blink),
-            Modifier::Bold => termion_modifier!(Bold),
-            Modifier::CrossedOut => termion_modifier!(CrossedOut),
-            Modifier::Faint => termion_modifier!(Faint),
-            Modifier::Framed => termion_modifier!(Framed),
-            Modifier::Invert => termion_modifier!(Invert),
-            Modifier::Italic => termion_modifier!(Italic),
-            Modifier::NoBlink => termion_modifier!(NoBlink),
-            Modifier::NoBold => termion_modifier!(NoBold),
-            Modifier::NoCrossedOut => termion_modifier!(NoCrossedOut),
-            Modifier::NoFaint => termion_modifier!(NoFaint),
-            Modifier::NoInvert => termion_modifier!(NoInvert),
-            Modifier::NoItalic => termion_modifier!(NoItalic),
-            Modifier::NoUnderline => termion_modifier!(NoUnderline),
-            Modifier::Reset => termion_modifier!(Reset),
-            Modifier::Underline => termion_modifier!(Underline),
+impl fmt::Display for ModifierDiff {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let remove = self.from - self.to;
+        if remove.contains(style::Modifier::REVERSED) {
+            write!(f, "{}", termion::style::NoInvert)?;
         }
+        if remove.contains(style::Modifier::BOLD) {
+            // XXX: the termion NoBold flag actually enables double-underline on ECMA-48 compliant
+            // terminals, and NoFaint additionally disables bold... so we use this trick to get
+            // the right semantics.
+            write!(f, "{}", termion::style::NoFaint)?;
+
+            if self.to.contains(style::Modifier::DIM) {
+                write!(f, "{}", termion::style::Faint)?;
+            }
+        }
+        if remove.contains(style::Modifier::ITALIC) {
+            write!(f, "{}", termion::style::NoItalic)?;
+        }
+        if remove.contains(style::Modifier::UNDERLINED) {
+            write!(f, "{}", termion::style::NoUnderline)?;
+        }
+        if remove.contains(style::Modifier::DIM) {
+            write!(f, "{}", termion::style::NoFaint)?;
+
+            // XXX: the NoFaint flag additionally disables bold as well, so we need to re-enable it
+            // here if we want it.
+            if self.to.contains(style::Modifier::BOLD) {
+                write!(f, "{}", termion::style::Bold)?;
+            }
+        }
+        if remove.contains(style::Modifier::CROSSED_OUT) {
+            write!(f, "{}", termion::style::NoCrossedOut)?;
+        }
+        if remove.contains(style::Modifier::SLOW_BLINK)
+            || remove.contains(style::Modifier::RAPID_BLINK)
+        {
+            write!(f, "{}", termion::style::NoBlink)?;
+        }
+
+        let add = self.to - self.from;
+        if add.contains(style::Modifier::REVERSED) {
+            write!(f, "{}", termion::style::Invert)?;
+        }
+        if add.contains(style::Modifier::BOLD) {
+            write!(f, "{}", termion::style::Bold)?;
+        }
+        if add.contains(style::Modifier::ITALIC) {
+            write!(f, "{}", termion::style::Italic)?;
+        }
+        if add.contains(style::Modifier::UNDERLINED) {
+            write!(f, "{}", termion::style::Underline)?;
+        }
+        if add.contains(style::Modifier::DIM) {
+            write!(f, "{}", termion::style::Faint)?;
+        }
+        if add.contains(style::Modifier::CROSSED_OUT) {
+            write!(f, "{}", termion::style::CrossedOut)?;
+        }
+        if add.contains(style::Modifier::SLOW_BLINK) || add.contains(style::Modifier::RAPID_BLINK) {
+            write!(f, "{}", termion::style::Blink)?;
+        }
+
+        Ok(())
     }
 }

src/backend/test.rs

@@ -0,0 +1,67 @@
+use crate::backend::Backend;
+use crate::buffer::{Buffer, Cell};
+use crate::layout::Rect;
+use std::io;
+
+#[derive(Debug)]
+pub struct TestBackend {
+    width: u16,
+    buffer: Buffer,
+    height: u16,
+    cursor: bool,
+    pos: (u16, u16),
+}
+
+impl TestBackend {
+    pub fn new(width: u16, height: u16) -> TestBackend {
+        TestBackend {
+            width,
+            height,
+            buffer: Buffer::empty(Rect::new(0, 0, width, height)),
+            cursor: false,
+            pos: (0, 0),
+        }
+    }
+
+    pub fn buffer(&self) -> &Buffer {
+        &self.buffer
+    }
+}
+
+impl Backend for TestBackend {
+    fn draw<'a, I>(&mut self, content: I) -> Result<(), io::Error>
+    where
+        I: Iterator<Item = (u16, u16, &'a Cell)>,
+    {
+        for (x, y, c) in content {
+            let cell = self.buffer.get_mut(x, y);
+            cell.symbol = c.symbol.clone();
+            cell.style = c.style;
+        }
+        Ok(())
+    }
+    fn hide_cursor(&mut self) -> Result<(), io::Error> {
+        self.cursor = false;
+        Ok(())
+    }
+    fn show_cursor(&mut self) -> Result<(), io::Error> {
+        self.cursor = true;
+        Ok(())
+    }
+    fn get_cursor(&mut self) -> Result<(u16, u16), io::Error> {
+        Ok(self.pos)
+    }
+    fn set_cursor(&mut self, x: u16, y: u16) -> Result<(), io::Error> {
+        self.pos = (x, y);
+        Ok(())
+    }
+    fn clear(&mut self) -> Result<(), io::Error> {
+        Ok(())
+    }
+    fn size(&self) -> Result<Rect, io::Error> {
+        Ok(Rect::new(0, 0, self.width, self.height))
+    }
+    fn flush(&mut self) -> Result<(), io::Error> {
+        Ok(())
+    }
+}

src/buffer.rs

@@ -1,10 +1,12 @@
 use std::cmp::min;
+use std::fmt;
 use std::usize;
 
 use unicode_segmentation::UnicodeSegmentation;
+use unicode_width::UnicodeWidthStr;
 
-use layout::Rect;
-use style::{Color, Modifier, Style};
+use crate::layout::Rect;
+use crate::style::{Color, Modifier, Style};
 
 /// A buffer cell
 #[derive(Debug, Clone, PartialEq)]
@@ -72,7 +74,6 @@ impl Default for Cell {
 /// # Examples:
 ///
 /// ```
-/// # extern crate tui;
 /// use tui::buffer::{Buffer, Cell};
 /// use tui::layout::Rect;
 /// use tui::style::{Color, Style, Modifier};
@@ -87,13 +88,13 @@ impl Default for Cell {
 ///     style: Style {
 ///         fg: Color::Red,
 ///         bg: Color::White,
-///         modifier: Modifier::Reset
+///         modifier: Modifier::empty()
 ///     }});
 /// buf.get_mut(5, 0).set_char('x');
 /// assert_eq!(buf.get(5, 0).symbol, "x");
 /// # }
 /// ```
-#[derive(Debug, Clone)]
+#[derive(Clone, PartialEq)]
 pub struct Buffer {
     /// The area represented by this buffer
     pub area: Rect,
@@ -111,6 +112,49 @@ impl Default for Buffer {
     }
 }
 
+impl fmt::Debug for Buffer {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        writeln!(f, "Buffer: {:?}", self.area)?;
+        f.write_str("Content (quoted lines):\n")?;
+        for cells in self.content.chunks(self.area.width as usize) {
+            let mut line = String::new();
+            let mut overwritten = vec![];
+            let mut skip: usize = 0;
+            for (x, c) in cells.iter().enumerate() {
+                if skip == 0 {
+                    line.push_str(&c.symbol);
+                } else {
+                    overwritten.push((x, &c.symbol))
+                }
+                skip = std::cmp::max(skip, c.symbol.width()).saturating_sub(1);
+            }
+            f.write_fmt(format_args!("{:?},", line))?;
+            if !overwritten.is_empty() {
+                f.write_fmt(format_args!(
+                    " Hidden by multi-width symbols: {:?}",
+                    overwritten
+                ))?;
+            }
+            f.write_str("\n")?;
+        }
+        f.write_str("Style:\n")?;
+        for cells in self.content.chunks(self.area.width as usize) {
+            f.write_str("|")?;
+            for cell in cells {
+                write!(
+                    f,
+                    "{} {} {}|",
+                    cell.style.fg.code(),
+                    cell.style.bg.code(),
+                    cell.style.modifier.code()
+                )?;
+            }
+            f.write_str("\n")?;
+        }
+        Ok(())
+    }
+}
+
 impl Buffer {
     /// Returns a Buffer with all cells set to the default one
     pub fn empty(area: Rect) -> Buffer {
@@ -128,6 +172,27 @@ impl Buffer {
         Buffer { area, content }
     }
 
+    /// Returns a Buffer containing the given lines
+    pub fn with_lines<S>(lines: Vec<S>) -> Buffer
+    where
+        S: AsRef<str>,
+    {
+        let height = lines.len() as u16;
+        let width = lines.iter().fold(0, |acc, item| {
+            std::cmp::max(acc, item.as_ref().width() as u16)
+        });
+        let mut buffer = Buffer::empty(Rect {
+            x: 0,
+            y: 0,
+            width,
+            height,
+        });
+        for (y, line) in lines.iter().enumerate() {
+            buffer.set_string(0, y as u16, line, Style::default());
+        }
+        buffer
+    }
+
     /// Returns the content of the buffer as a slice
     pub fn content(&self) -> &[Cell] {
         &self.content
@@ -242,18 +307,30 @@ impl Buffer {
 
     /// Print at most the first n characters of a string if enough space is available
     /// until the end of the line
-    pub fn set_stringn<S>(&mut self, x: u16, y: u16, string: S, limit: usize, style: Style)
+    pub fn set_stringn<S>(&mut self, x: u16, y: u16, string: S, width: usize, style: Style)
     where
         S: AsRef<str>,
     {
         let mut index = self.index_of(x, y);
+        let mut x_offset = x as usize;
         let graphemes = UnicodeSegmentation::graphemes(string.as_ref(), true);
-        let max_index = min((self.area.right() - x) as usize, limit);
-        for s in graphemes.take(max_index) {
-            self.content[index].symbol.clear();
-            self.content[index].symbol.push_str(s);
-            self.content[index].style = style;
-            index += 1;
+        let max_offset = min(self.area.right() as usize, width.saturating_add(x as usize));
+        for s in graphemes {
+            let width = s.width();
+            // `x_offset + width > max_offset` could be integer overflow on 32-bit machines if we
+            // change dimenstions to usize or u32 and someone resizes the terminal to 1x2^32.
+            if width > max_offset.saturating_sub(x_offset) {
+                break;
+            }
+
+            self.content[index].set_symbol(s);
+            self.content[index].set_style(style);
+            // Reset following cells if multi-width (they would be hidden by the grapheme),
+            for i in index + 1..index + width {
+                self.content[i].reset();
+            }
+            index += width;
+            x_offset += width;
         }
     }
 
@@ -283,38 +360,94 @@ impl Buffer {
         self.content.resize(area.area() as usize, cell.clone());
 
         // Move original content to the appropriate space
-        let offset_x = self.area.x - area.x;
-        let offset_y = self.area.y - area.y;
         let size = self.area.area() as usize;
         for i in (0..size).rev() {
             let (x, y) = self.pos_of(i);
             // New index in content
-            let k = ((y + offset_y) * area.width + (x + offset_x)) as usize;
-            self.content[k] = self.content[i].clone();
+            let k = ((y - area.y) * area.width + x - area.x) as usize;
             if i != k {
+                self.content[k] = self.content[i].clone();
                 self.content[i] = cell.clone();
             }
         }
 
         // Push content of the other buffer into this one (may erase previous
         // data)
-        let offset_x = other.area.x - area.x;
-        let offset_y = other.area.y - area.y;
         let size = other.area.area() as usize;
         for i in 0..size {
             let (x, y) = other.pos_of(i);
             // New index in content
-            let k = ((y + offset_y) * area.width + (x + offset_x)) as usize;
+            let k = ((y - area.y) * area.width + x - area.x) as usize;
             self.content[k] = other.content[i].clone();
         }
         self.area = area;
     }
+
+    /// Builds a minimal sequence of coordinates and Cells necessary to update the UI from
+    /// self to other.
+    ///
+    /// We're assuming that buffers are well-formed, that is no double-width cell is followed by
+    /// a non-blank cell.
+    ///
+    /// # Multi-width characters handling:
+    ///
+    /// ```text
+    /// (Index:) `01`
+    /// Prev:    `コ`
+    /// Next:    `aa`
+    /// Updates: `0: a, 1: a'
+    /// ```
+    ///
+    /// ```text
+    /// (Index:) `01`
+    /// Prev:    `a `
+    /// Next:    `コ`
+    /// Updates: `0: コ` (double width symbol at index 0 - skip index 1)
+    /// ```
+    ///
+    /// ```text
+    /// (Index:) `012`
+    /// Prev:    `aaa`
+    /// Next:    `aコ`
+    /// Updates: `0: a, 1: コ` (double width symbol at index 1 - skip index 2)
+    /// ```
+    pub fn diff<'a>(&self, other: &'a Buffer) -> Vec<(u16, u16, &'a Cell)> {
+        let previous_buffer = &self.content;
+        let next_buffer = &other.content;
+        let width = self.area.width;
+
+        let mut updates: Vec<(u16, u16, &Cell)> = vec![];
+        // Cells invalidated by drawing/replacing preceeding multi-width characters:
+        let mut invalidated: usize = 0;
+        // Cells from the current buffer to skip due to preceeding multi-width characters taking their
+        // place (the skipped cells should be blank anyway):
+        let mut to_skip: usize = 0;
+        for (i, (current, previous)) in next_buffer.iter().zip(previous_buffer.iter()).enumerate() {
+            if (current != previous || invalidated > 0) && to_skip == 0 {
+                let x = i as u16 % width;
+                let y = i as u16 / width;
+                updates.push((x, y, &next_buffer[i]));
+            }
+
+            to_skip = current.symbol.width().saturating_sub(1);
+
+            let affected_width = std::cmp::max(current.symbol.width(), previous.symbol.width());
+            invalidated = std::cmp::max(affected_width, invalidated).saturating_sub(1);
+        }
+        updates
+    }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
 
+    fn cell(s: &str) -> Cell {
+        let mut cell = Cell::default();
+        cell.set_symbol(s);
+        cell
+    }
+
     #[test]
     fn it_translates_to_and_from_coordinates() {
         let rect = Rect::new(200, 100, 50, 80);
@@ -348,4 +481,231 @@ mod tests {
         // width is 10; zero-indexed means that 10 would be the 11th cell.
         buf.index_of(10, 0);
     }
+
+    #[test]
+    fn buffer_set_string() {
+        let area = Rect::new(0, 0, 5, 1);
+        let mut buffer = Buffer::empty(area);
+
+        // Zero-width
+        buffer.set_stringn(0, 0, "aaa", 0, Style::default());
+        assert_eq!(buffer, Buffer::with_lines(vec!["     "]));
+
+        buffer.set_string(0, 0, "aaa", Style::default());
+        assert_eq!(buffer, Buffer::with_lines(vec!["aaa  "]));
+
+        // Width limit:
+        buffer.set_stringn(0, 0, "bbbbbbbbbbbbbb", 4, Style::default());
+        assert_eq!(buffer, Buffer::with_lines(vec!["bbbb "]));
+
+        buffer.set_string(0, 0, "12345", Style::default());
+        assert_eq!(buffer, Buffer::with_lines(vec!["12345"]));
+
+        // Width truncation:
+        buffer.set_string(0, 0, "123456", Style::default());
+        assert_eq!(buffer, Buffer::with_lines(vec!["12345"]));
+    }
+
+    #[test]
+    fn buffer_set_string_double_width() {
+        let area = Rect::new(0, 0, 5, 1);
+        let mut buffer = Buffer::empty(area);
+        buffer.set_string(0, 0, "コン", Style::default());
+        assert_eq!(buffer, Buffer::with_lines(vec!["コン "]));
+
+        // Only 1 space left.
+        buffer.set_string(0, 0, "コンピ", Style::default());
+        assert_eq!(buffer, Buffer::with_lines(vec!["コン "]));
+    }
+
+    #[test]
+    fn buffer_with_lines() {
+        let buffer = Buffer::with_lines(vec![
+            "┌────────┐",
+            "│コンピュ│",
+            "│ーa 上で│",
+            "└────────┘",
+        ]);
+        assert_eq!(buffer.area.x, 0);
+        assert_eq!(buffer.area.y, 0);
+        assert_eq!(buffer.area.width, 10);
+        assert_eq!(buffer.area.height, 4);
+    }
+
+    #[test]
+    fn buffer_diffing_empty_empty() {
+        let area = Rect::new(0, 0, 40, 40);
+        let prev = Buffer::empty(area);
+        let next = Buffer::empty(area);
+        let diff = prev.diff(&next);
+        assert_eq!(diff, vec![]);
+    }
+
+    #[test]
+    fn buffer_diffing_empty_filled() {
+        let area = Rect::new(0, 0, 40, 40);
+        let prev = Buffer::empty(area);
+        let next = Buffer::filled(area, Cell::default().set_symbol("a"));
+        let diff = prev.diff(&next);
+        assert_eq!(diff.len(), 40 * 40);
+    }
+
+    #[test]
+    fn buffer_diffing_filled_filled() {
+        let area = Rect::new(0, 0, 40, 40);
+        let prev = Buffer::filled(area, Cell::default().set_symbol("a"));
+        let next = Buffer::filled(area, Cell::default().set_symbol("a"));
+        let diff = prev.diff(&next);
+        assert_eq!(diff, vec![]);
+    }
+
+    #[test]
+    fn buffer_diffing_single_width() {
+        let prev = Buffer::with_lines(vec![
+            "          ",
+            "┌Title─┐  ",
+            "│      │  ",
+            "│      │  ",
+            "└──────┘  ",
+        ]);
+        let next = Buffer::with_lines(vec![
+            "          ",
+            "┌TITLE─┐  ",
+            "│      │  ",
+            "│      │  ",
+            "└──────┘  ",
+        ]);
+        let diff = prev.diff(&next);
+        assert_eq!(
+            diff,
+            vec![
+                (2, 1, &cell("I")),
+                (3, 1, &cell("T")),
+                (4, 1, &cell("L")),
+                (5, 1, &cell("E")),
+            ]
+        );
+    }
+
+    #[test]
+    #[rustfmt::skip]
+    fn buffer_diffing_multi_width() {
+        let prev = Buffer::with_lines(vec![
+            "┌Title─┐  ",
+            "└──────┘  ",
+        ]);
+        let next = Buffer::with_lines(vec![
+            "┌称号──┐  ",
+            "└──────┘  ",
+        ]);
+        let diff = prev.diff(&next);
+        assert_eq!(
+            diff,
+            vec![
+                (1, 0, &cell("称")),
+                // Skipped "i"
+                (3, 0, &cell("号")),
+                // Skipped "l"
+                (5, 0, &cell("─")),
+            ]
+        );
+    }
+
+    #[test]
+    fn buffer_diffing_multi_width_offset() {
+        let prev = Buffer::with_lines(vec!["┌称号──┐"]);
+        let next = Buffer::with_lines(vec!["┌─称号─┐"]);
+
+        let diff = prev.diff(&next);
+        assert_eq!(
+            diff,
+            vec![
+                (1, 0, &cell("─")),
+                (2, 0, &cell("称")),
+                (4, 0, &cell("号")),
+            ]
+        );
+    }
+
+    #[test]
+    fn buffer_merge() {
+        let mut one = Buffer::filled(
+            Rect {
+                x: 0,
+                y: 0,
+                width: 2,
+                height: 2,
+            },
+            Cell::default().set_symbol("1"),
+        );
+        let two = Buffer::filled(
+            Rect {
+                x: 0,
+                y: 2,
+                width: 2,
+                height: 2,
+            },
+            Cell::default().set_symbol("2"),
+        );
+        one.merge(&two);
+        assert_eq!(one, Buffer::with_lines(vec!["11", "11", "22", "22"]));
+    }
+
+    #[test]
+    fn buffer_merge2() {
+        let mut one = Buffer::filled(
+            Rect {
+                x: 2,
+                y: 2,
+                width: 2,
+                height: 2,
+            },
+            Cell::default().set_symbol("1"),
+        );
+        let two = Buffer::filled(
+            Rect {
+                x: 0,
+                y: 0,
+                width: 2,
+                height: 2,
+            },
+            Cell::default().set_symbol("2"),
+        );
+        one.merge(&two);
+        assert_eq!(
+            one,
+            Buffer::with_lines(vec!["22  ", "22  ", "  11", "  11"])
+        );
+    }
+
+    #[test]
+    fn buffer_merge3() {
+        let mut one = Buffer::filled(
+            Rect {
+                x: 3,
+                y: 3,
+                width: 2,
+                height: 2,
+            },
+            Cell::default().set_symbol("1"),
+        );
+        let two = Buffer::filled(
+            Rect {
+                x: 1,
+                y: 1,
+                width: 3,
+                height: 4,
+            },
+            Cell::default().set_symbol("2"),
+        );
+        one.merge(&two);
+        let mut merged = Buffer::with_lines(vec!["222 ", "222 ", "2221", "2221"]);
+        merged.area = Rect {
+            x: 1,
+            y: 1,
+            width: 4,
+            height: 4,
+        };
+        assert_eq!(one, merged);
+    }
 }

src/layout.rs

@@ -24,6 +24,7 @@ pub enum Direction {
 pub enum Constraint {
     // TODO: enforce range 0 - 100
     Percentage(u16),
+    Ratio(u32, u32),
     Length(u16),
     Max(u16),
     Min(u16),
@@ -82,16 +83,62 @@ impl Layout {
     ///
     /// # Examples
     /// ```
-    /// # extern crate tui;
     /// # use tui::layout::{Rect, Constraint, Direction, Layout};
     ///
     /// # fn main() {
-    ///     let chunks = Layout::default()
-    ///         .direction(Direction::Vertical)
-    ///         .constraints([Constraint::Length(5), Constraint::Min(0)].as_ref())
-    ///         .split(Rect{x: 2, y: 2, width: 10, height: 10});
-    ///     assert_eq!(chunks, vec![Rect{x:2, y: 2, width: 10, height: 5},
-    ///                             Rect{x: 2, y: 7, width: 10, height: 5}])
+    ///       let chunks = Layout::default()
+    ///           .direction(Direction::Vertical)
+    ///           .constraints([Constraint::Length(5), Constraint::Min(0)].as_ref())
+    ///           .split(Rect {
+    ///               x: 2,
+    ///               y: 2,
+    ///               width: 10,
+    ///               height: 10,
+    ///           });
+    ///       assert_eq!(
+    ///           chunks,
+    ///           vec![
+    ///               Rect {
+    ///                   x: 2,
+    ///                   y: 2,
+    ///                   width: 10,
+    ///                   height: 5
+    ///               },
+    ///               Rect {
+    ///                   x: 2,
+    ///                   y: 7,
+    ///                   width: 10,
+    ///                   height: 5
+    ///               }
+    ///           ]
+    ///       );
+    ///
+    ///       let chunks = Layout::default()
+    ///           .direction(Direction::Horizontal)
+    ///           .constraints([Constraint::Ratio(1, 3), Constraint::Ratio(2, 3)].as_ref())
+    ///           .split(Rect {
+    ///               x: 0,
+    ///               y: 0,
+    ///               width: 9,
+    ///               height: 2,
+    ///           });
+    ///       assert_eq!(
+    ///           chunks,
+    ///           vec![
+    ///               Rect {
+    ///                   x: 0,
+    ///                   y: 0,
+    ///                   width: 3,
+    ///                   height: 2
+    ///               },
+    ///               Rect {
+    ///                   x: 3,
+    ///                   y: 0,
+    ///                   width: 6,
+    ///                   height: 2
+    ///               }
+    ///           ]
+    ///       );
     /// # }
     ///
     /// ```
@@ -160,6 +207,11 @@ fn split(area: Rect, layout: &Layout) -> Vec<Rect> {
                     Constraint::Percentage(v) => {
                         elements[i].width | EQ(WEAK) | (f64::from(v * dest_area.width) / 100.0)
                     }
+                    Constraint::Ratio(n, d) => {
+                        elements[i].width
+                            | EQ(WEAK)
+                            | (f64::from(dest_area.width) * f64::from(n) / f64::from(d))
+                    }
                     Constraint::Min(v) => elements[i].width | GE(WEAK) | f64::from(v),
                     Constraint::Max(v) => elements[i].width | LE(WEAK) | f64::from(v),
                 });
@@ -177,6 +229,11 @@ fn split(area: Rect, layout: &Layout) -> Vec<Rect> {
                     Constraint::Percentage(v) => {
                         elements[i].height | EQ(WEAK) | (f64::from(v * dest_area.height) / 100.0)
                     }
+                    Constraint::Ratio(n, d) => {
+                        elements[i].height
+                            | EQ(WEAK)
+                            | (f64::from(dest_area.height) * f64::from(n) / f64::from(d))
+                    }
                     Constraint::Min(v) => elements[i].height | GE(WEAK) | f64::from(v),
                     Constraint::Max(v) => elements[i].height | LE(WEAK) | f64::from(v),
                 });
@@ -279,12 +336,25 @@ impl Default for Rect {
 }
 
 impl Rect {
+    /// Creates a new rect, with width and height limited to keep the area under max u16.
+    /// If clipped, aspect ratio will be preserved.
     pub fn new(x: u16, y: u16, width: u16, height: u16) -> Rect {
+        let max_area = u16::max_value();
+        let (clipped_width, clipped_height) =
+            if u32::from(width) * u32::from(height) > u32::from(max_area) {
+                let aspect_ratio = f64::from(width) / f64::from(height);
+                let max_area_f = f64::from(max_area);
+                let height_f = (max_area_f / aspect_ratio).sqrt();
+                let width_f = height_f * aspect_ratio;
+                (width_f as u16, height_f as u16)
+            } else {
+                (width, height)
+            };
         Rect {
             x,
             y,
-            width,
-            height,
+            width: clipped_width,
+            height: clipped_height,
         }
     }
 
@@ -354,3 +424,47 @@ impl Rect {
             && self.y + self.height > other.y
     }
 }
+
+#[test]
+fn test_rect_size_truncation() {
+    for width in 256u16..300u16 {
+        for height in 256u16..300u16 {
+            let rect = Rect::new(0, 0, width, height);
+            rect.area(); // Should not panic.
+            assert!(rect.width < width || rect.height < height);
+            // The target dimensions are rounded down so the math will not be too precise
+            // but let's make sure the ratios don't diverge crazily.
+            assert!(
+                (f64::from(rect.width) / f64::from(rect.height)
+                    - f64::from(width) / f64::from(height))
+                .abs()
+                    < 1.0
+            )
+        }
+    }
+
+    // One dimension below 255, one above. Area above max u16.
+    let width = 900;
+    let height = 100;
+    let rect = Rect::new(0, 0, width, height);
+    assert_ne!(rect.width, 900);
+    assert_ne!(rect.height, 100);
+    assert!(rect.width < width || rect.height < height);
+}
+
+#[test]
+fn test_rect_size_preservation() {
+    for width in 0..256u16 {
+        for height in 0..256u16 {
+            let rect = Rect::new(0, 0, width, height);
+            rect.area(); // Should not panic.
+            assert_eq!(rect.width, width);
+            assert_eq!(rect.height, height);
+        }
+    }
+
+    // One dimension below 255, one above. Area below max u16.
+    let rect = Rect::new(0, 0, 300, 100);
+    assert_eq!(rect.width, 300);
+    assert_eq!(rect.height, 100);
+}

src/lib.rs

@@ -5,17 +5,36 @@
 //!
 //! # Get started
 //!
+//! ## Adding `tui` as a dependency
+//!
+//! ```toml
+//! [dependencies]
+//! tui = "0.5"
+//! termion = "1.5"
+//! ```
+//!
+//! The crate is using the `termion` backend by default but if for some reason you might want to use
+//! the `rustbox` backend instead, you need the to replace your dependency specification by:
+//!
+//! ```toml
+//! [dependencies]
+//! rustbox = "0.11"
+//!
+//! [dependencies.tui]
+//! version = "0.5"
+//! default-features = false
+//! features = ['rustbox']
+//! ```
+//!
+//! The same logic applies for all other available backends.
+//!
 //! ## Creating a `Terminal`
 //!
-//! Every application using `tui` should start by instantiating a `Terminal`. It is
-//! a light abstraction over available backends that provides basic functionalities
-//! such as clearing the screen, hiding the cursor, etc. By default only the `termion`
-//! backend is available.
+//! Every application using `tui` should start by instantiating a `Terminal`. It is a light
+//! abstraction over available backends that provides basic functionalities such as clearing the
+//! screen, hiding the cursor, etc.
 //!
 //! ```rust,no_run
-//! extern crate tui;
-//! extern crate termion;
-//!
 //! use std::io;
 //! use tui::Terminal;
 //! use tui::backend::TermionBackend;
@@ -29,21 +48,10 @@
 //! }
 //! ```
 //!
-//! If for some reason, you might want to use the `rustbox` backend instead, you
-//! need the to replace your `tui` dependency specification by:
-//!
-//! ```toml
-//! [dependencies.tui]
-//! version = "0.2.0"
-//! default-features = false
-//! features = ['rustbox']
-//! ```
-//!
-//! and then create the terminal in a similar way:
+//! If you had previously chosen `rustbox` as a backend, the terminal can be created in a similar
+//! way:
 //!
 //! ```rust,ignore
-//! extern crate tui;
-//!
 //! use tui::Terminal;
 //! use tui::backend::RustboxBackend;
 //!
@@ -54,23 +62,22 @@
 //! }
 //! ```
 //!
+//! You may also refer to the examples to find out how to create a `Terminal` for each available
+//! backend.
+//!
 //! ## Building a User Interface (UI)
 //!
-//! Every component of your interface will be implementing the `Widget` trait.
-//! The library comes with a predefined set of widgets that should met most of
-//! your use cases. You are also free to implement your owns.
+//! Every component of your interface will be implementing the `Widget` trait.  The library comes
+//! with a predefined set of widgets that should met most of your use cases. You are also free to
+//! implement your owns.
 //!
-//! Each widget follows a builder pattern API providing a default configuration
-//! along with methods to customize them. The widget is then registered using
-//! its `render` method that take a `Frame` instance and an area to draw
-//! to.
+//! Each widget follows a builder pattern API providing a default configuration along with methods
+//! to customize them. The widget is then registered using its `render` method that take a `Frame`
+//! instance and an area to draw to.
 //!
 //! The following example renders a block of the size of the terminal:
 //!
 //! ```rust,no_run
-//! extern crate tui;
-//! extern crate termion;
-//!
 //! use std::io;
 //! use termion::raw::IntoRawMode;
 //! use tui::Terminal;
@@ -82,8 +89,8 @@
 //!     let stdout = io::stdout().into_raw_mode()?;
 //!     let backend = TermionBackend::new(stdout);
 //!     let mut terminal = Terminal::new(backend)?;
-//!     let size = terminal.size()?;
 //!     terminal.draw(|mut f| {
+//!         let size = f.size();
 //!         Block::default()
 //!             .title("Block")
 //!             .borders(Borders::ALL)
@@ -99,9 +106,6 @@
 //! full customization. And `Layout` is no exception:
 //!
 //! ```rust,no_run
-//! extern crate tui;
-//! extern crate termion;
-//!
 //! use std::io;
 //! use termion::raw::IntoRawMode;
 //! use tui::Terminal;
@@ -113,7 +117,6 @@
 //!     let stdout = io::stdout().into_raw_mode()?;
 //!     let backend = TermionBackend::new(stdout);
 //!     let mut terminal = Terminal::new(backend)?;
-//!     let size = terminal.size()?;
 //!     terminal.draw(|mut f| {
 //!         let chunks = Layout::default()
 //!             .direction(Direction::Vertical)
@@ -125,7 +128,7 @@
 //!                     Constraint::Percentage(10)
 //!                 ].as_ref()
 //!             )
-//!             .split(size);
+//!             .split(f.size());
 //!         Block::default()
 //!              .title("Block")
 //!              .borders(Borders::ALL)
@@ -138,20 +141,10 @@
 //! }
 //! ```
 //!
-//! This let you describe responsive terminal UI by nesting layouts. You should note
-//! that by default the computed layout tries to fill the available space
-//! completely. So if for any reason you might need a blank space somewhere, try to
-//! pass an additional constraint and don't use the corresponding area.
-
-#[macro_use]
-extern crate bitflags;
-extern crate cassowary;
-extern crate either;
-extern crate itertools;
-#[macro_use]
-extern crate log;
-extern crate unicode_segmentation;
-extern crate unicode_width;
+//! This let you describe responsive terminal UI by nesting layouts. You should note that by
+//! default the computed layout tries to fill the available space completely. So if for any reason
+//! you might need a blank space somewhere, try to pass an additional constraint and don't use the
+//! corresponding area.
 
 pub mod backend;
 pub mod buffer;

src/style.rs

@@ -1,3 +1,5 @@
+use bitflags::bitflags;
+
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub enum Color {
     Reset,
@@ -18,26 +20,89 @@ pub enum Color {
     LightCyan,
     White,
     Rgb(u8, u8, u8),
+    Indexed(u8),
 }
 
-#[derive(Debug, Clone, Copy, PartialEq)]
-pub enum Modifier {
-    Blink,
-    Bold,
-    CrossedOut,
-    Faint,
-    Framed,
-    Invert,
-    Italic,
-    NoBlink,
-    NoBold,
-    NoCrossedOut,
-    NoFaint,
-    NoInvert,
-    NoItalic,
-    NoUnderline,
-    Reset,
-    Underline,
+impl Color {
+    /// Returns a short code associated with the color, used for debug purpose
+    /// only
+    pub(crate) fn code(self) -> &'static str {
+        match self {
+            Color::Reset => "X",
+            Color::Black => "b",
+            Color::Red => "r",
+            Color::Green => "c",
+            Color::Yellow => "y",
+            Color::Blue => "b",
+            Color::Magenta => "m",
+            Color::Cyan => "c",
+            Color::Gray => "w",
+            Color::DarkGray => "B",
+            Color::LightRed => "R",
+            Color::LightGreen => "G",
+            Color::LightYellow => "Y",
+            Color::LightBlue => "B",
+            Color::LightMagenta => "M",
+            Color::LightCyan => "C",
+            Color::White => "W",
+            Color::Indexed(_) => "i",
+            Color::Rgb(_, _, _) => "o",
+        }
+    }
+}
+
+bitflags! {
+    pub struct Modifier: u16 {
+        const BOLD              = 0b0000_0000_0001;
+        const DIM               = 0b0000_0000_0010;
+        const ITALIC            = 0b0000_0000_0100;
+        const UNDERLINED        = 0b0000_0000_1000;
+        const SLOW_BLINK        = 0b0000_0001_0000;
+        const RAPID_BLINK       = 0b0000_0010_0000;
+        const REVERSED          = 0b0000_0100_0000;
+        const HIDDEN            = 0b0000_1000_0000;
+        const CROSSED_OUT       = 0b0001_0000_0000;
+    }
+}
+
+impl Modifier {
+    /// Returns a short code associated with the color, used for debug purpose
+    /// only
+    pub(crate) fn code(self) -> String {
+        use std::fmt::Write;
+
+        let mut result = String::new();
+
+        if self.contains(Modifier::BOLD) {
+            write!(result, "BO").unwrap();
+        }
+        if self.contains(Modifier::DIM) {
+            write!(result, "DI").unwrap();
+        }
+        if self.contains(Modifier::ITALIC) {
+            write!(result, "IT").unwrap();
+        }
+        if self.contains(Modifier::UNDERLINED) {
+            write!(result, "UN").unwrap();
+        }
+        if self.contains(Modifier::SLOW_BLINK) {
+            write!(result, "SL").unwrap();
+        }
+        if self.contains(Modifier::RAPID_BLINK) {
+            write!(result, "RA").unwrap();
+        }
+        if self.contains(Modifier::REVERSED) {
+            write!(result, "RE").unwrap();
+        }
+        if self.contains(Modifier::HIDDEN) {
+            write!(result, "HI").unwrap();
+        }
+        if self.contains(Modifier::CROSSED_OUT) {
+            write!(result, "CR").unwrap();
+        }
+
+        result
+    }
 }
 
 #[derive(Debug, Clone, Copy, PartialEq)]
@@ -52,7 +117,7 @@ impl Default for Style {
         Style {
             fg: Color::Reset,
             bg: Color::Reset,
-            modifier: Modifier::Reset,
+            modifier: Modifier::empty(),
         }
     }
 }
@@ -61,7 +126,7 @@ impl Style {
     pub fn reset(&mut self) {
         self.fg = Color::Reset;
         self.bg = Color::Reset;
-        self.modifier = Modifier::Reset;
+        self.modifier = Modifier::empty();
     }
 
     pub fn fg(mut self, color: Color) -> Style {

src/terminal.rs

@@ -1,9 +1,10 @@
+use log::error;
 use std::io;
 
-use backend::Backend;
-use buffer::Buffer;
-use layout::Rect;
-use widgets::Widget;
+use crate::backend::Backend;
+use crate::buffer::Buffer;
+use crate::layout::Rect;
+use crate::widgets::Widget;
 
 /// Interface to the terminal backed by Termion
 #[derive(Debug)]
@@ -19,8 +20,11 @@ where
     current: usize,
     /// Whether the cursor is currently hidden
     hidden_cursor: bool,
+    /// Terminal size used for rendering.
+    known_size: Rect,
 }
 
+/// Represents a consistent terminal interface for rendering.
 pub struct Frame<'a, B: 'a>
 where
     B: Backend,
@@ -32,6 +36,11 @@ impl<'a, B> Frame<'a, B>
 where
     B: Backend,
 {
+    /// Terminal size, guaranteed not to change when rendering.
+    pub fn size(&self) -> Rect {
+        self.terminal.known_size
+    }
+
     /// Calls the draw method of a given widget on the current buffer
     pub fn render<W>(&mut self, widget: &mut W, area: Rect)
     where
@@ -48,8 +57,8 @@ where
     fn drop(&mut self) {
         // Attempt to restore the cursor state
         if self.hidden_cursor {
-            if let Err(_) = self.show_cursor() {
-                error!("Failed to show the cursor");
+            if let Err(err) = self.show_cursor() {
+                error!("Failed to show the cursor: {}", err);
             }
         }
     }
@@ -68,9 +77,11 @@ where
             buffers: [Buffer::empty(size), Buffer::empty(size)],
             current: 0,
             hidden_cursor: false,
+            known_size: size,
         })
     }
 
+    /// Get a Frame object which provides a consistent view into the terminal state for rendering.
     pub fn get_frame(&mut self) -> Frame<B> {
         Frame { terminal: self }
     }
@@ -87,42 +98,45 @@ where
         &mut self.backend
     }
 
-    /// Builds a string representing the minimal escape sequences and characters set necessary to
-    /// update the UI and writes it to stdout.
+    /// Obtains a difference between the previous and the current buffer and passes it to the
+    /// current backend for drawing.
     pub fn flush(&mut self) -> io::Result<()> {
-        let width = self.buffers[self.current].area.width;
-        let content = self.buffers[self.current]
-            .content
-            .iter()
-            .zip(self.buffers[1 - self.current].content.iter())
-            .enumerate()
-            .filter_map(|(i, (c, p))| {
-                if c != p {
-                    let i = i as u16;
-                    let x = i % width;
-                    let y = i / width;
-                    Some((x, y, c))
-                } else {
-                    None
-                }
-            });
-        self.backend.draw(content)
+        let previous_buffer = &self.buffers[1 - self.current];
+        let current_buffer = &self.buffers[self.current];
+        let updates = previous_buffer.diff(current_buffer);
+        self.backend.draw(updates.into_iter())
     }
 
-    /// Updates the interface so that internal buffers matches the current size of the terminal.
-    /// This leads to a full redraw of the screen.
+    /// Updates the Terminal so that internal buffers match the requested size. Requested size will
+    /// be saved so the size can remain consistent when rendering.
+    /// This leads to a full clear of the screen.
     pub fn resize(&mut self, area: Rect) -> io::Result<()> {
         self.buffers[self.current].resize(area);
         self.buffers[1 - self.current].reset();
         self.buffers[1 - self.current].resize(area);
+        self.known_size = area;
         self.backend.clear()
     }
 
-    /// Flushes the current internal state and prepares the interface for the next draw call
+    /// Queries the backend for size and resizes if it doesn't match the previous size.
+    pub fn autoresize(&mut self) -> io::Result<()> {
+        let size = self.size()?;
+        if self.known_size != size {
+            self.resize(size)?;
+        }
+        Ok(())
+    }
+
+    /// Synchronizes terminal size, calls the rendering closure, flushes the current internal state
+    /// and prepares for the next draw call.
     pub fn draw<F>(&mut self, f: F) -> io::Result<()>
     where
         F: FnOnce(Frame<B>),
     {
+        // Autoresize - otherwise we get glitches if shrinking or potential desync between widgets
+        // and the terminal (if growing), which may OOB.
+        self.autoresize()?;
+
         f(self.get_frame());
 
         // Draw to stdout
@@ -147,9 +161,16 @@ where
         self.hidden_cursor = false;
         Ok(())
     }
+    pub fn get_cursor(&mut self) -> io::Result<(u16, u16)> {
+        self.backend.get_cursor()
+    }
+    pub fn set_cursor(&mut self, x: u16, y: u16) -> io::Result<()> {
+        self.backend.set_cursor(x, y)
+    }
     pub fn clear(&mut self) -> io::Result<()> {
         self.backend.clear()
     }
+    /// Queries the real size of the backend.
     pub fn size(&self) -> io::Result<Rect> {
         self.backend.size()
     }

src/widgets/barchart.rs

@@ -2,18 +2,17 @@ use std::cmp::{max, min};
 
 use unicode_width::UnicodeWidthStr;
 
-use buffer::Buffer;
-use layout::Rect;
-use style::Style;
-use symbols::bar;
-use widgets::{Block, Widget};
+use crate::buffer::Buffer;
+use crate::layout::Rect;
+use crate::style::Style;
+use crate::symbols::bar;
+use crate::widgets::{Block, Widget};
 
 /// Display multiple bars in a single widgets
 ///
 /// # Examples
 ///
 /// ```
-/// # extern crate tui;
 /// # use tui::widgets::{Block, Borders, BarChart};
 /// # use tui::style::{Style, Color, Modifier};
 /// # fn main() {
@@ -22,7 +21,7 @@ use widgets::{Block, Widget};
 ///     .bar_width(3)
 ///     .bar_gap(1)
 ///     .style(Style::default().fg(Color::Yellow).bg(Color::Red))
-///     .value_style(Style::default().fg(Color::Red).modifier(Modifier::Bold))
+///     .value_style(Style::default().fg(Color::Red).modifier(Modifier::BOLD))
 ///     .label_style(Style::default().fg(Color::White))
 ///     .data(&[("B0", 0), ("B1", 2), ("B2", 4), ("B3", 3)])
 ///     .max(4);
@@ -121,7 +120,7 @@ impl<'a> Widget for BarChart<'a> {
             return;
         }
 
-        self.background(&chart_area, buf, self.style.bg);
+        self.background(chart_area, buf, self.style.bg);
 
         let max = self
             .max
@@ -154,7 +153,8 @@ impl<'a> Widget for BarChart<'a> {
                     buf.get_mut(
                         chart_area.left() + i as u16 * (self.bar_width + self.bar_gap) + x,
                         chart_area.top() + j,
-                    ).set_symbol(symbol)
+                    )
+                    .set_symbol(symbol)
                     .set_style(self.style);
                 }
 

src/widgets/block.rs

@@ -1,8 +1,8 @@
-use buffer::Buffer;
-use layout::Rect;
-use style::Style;
-use symbols::line;
-use widgets::{Borders, Widget};
+use crate::buffer::Buffer;
+use crate::layout::Rect;
+use crate::style::Style;
+use crate::symbols::line;
+use crate::widgets::{Borders, Widget};
 
 /// Base widget to be used with all upper level ones. It may be used to display a box border around
 /// the widget and/or add a title.
@@ -10,7 +10,6 @@ use widgets::{Borders, Widget};
 /// # Examples
 ///
 /// ```
-/// # extern crate tui;
 /// # use tui::widgets::{Block, Borders};
 /// # use tui::style::{Style, Color};
 /// # fn main() {
@@ -104,7 +103,7 @@ impl<'a> Widget for Block<'a> {
             return;
         }
 
-        self.background(&area, buf, self.style.bg);
+        self.background(area, buf, self.style.bg);
 
         // Sides
         if self.borders.intersects(Borders::LEFT) {

src/widgets/canvas/line.rs

@@ -1,5 +1,5 @@
 use super::Shape;
-use style::Color;
+use crate::style::Color;
 
 /// Shape to draw a line from (x1, y1) to (x2, y2) with the given color
 pub struct Line {
@@ -23,6 +23,7 @@ pub struct LineIterator {
 
 impl Iterator for LineIterator {
     type Item = (f64, f64);
+
     fn next(&mut self) -> Option<Self::Item> {
         if self.current < self.end {
             let pos = (
@@ -40,6 +41,7 @@ impl Iterator for LineIterator {
 impl<'a> IntoIterator for &'a Line {
     type Item = (f64, f64);
     type IntoIter = LineIterator;
+
     fn into_iter(self) -> Self::IntoIter {
         let dx = self.x1.max(self.x2) - self.x1.min(self.x2);
         let dy = self.y1.max(self.y2) - self.y1.min(self.y2);
@@ -63,6 +65,7 @@ impl<'a> Shape<'a> for Line {
     fn color(&self) -> Color {
         self.color
     }
+
     fn points(&'a self) -> Box<Iterator<Item = (f64, f64)> + 'a> {
         Box::new(self.into_iter())
     }

src/widgets/canvas/map.rs

@@ -1,7 +1,7 @@
-use style::Color;
-use widgets::canvas::points::PointsIterator;
-use widgets::canvas::world::{WORLD_HIGH_RESOLUTION, WORLD_LOW_RESOLUTION};
-use widgets::canvas::Shape;
+use crate::style::Color;
+use crate::widgets::canvas::points::PointsIterator;
+use crate::widgets::canvas::world::{WORLD_HIGH_RESOLUTION, WORLD_LOW_RESOLUTION};
+use crate::widgets::canvas::Shape;
 
 #[derive(Clone, Copy)]
 pub enum MapResolution {

src/widgets/canvas/mod.rs

@@ -1,16 +1,18 @@
 mod line;
 mod map;
 mod points;
+mod rectangle;
 mod world;
 
 pub use self::line::Line;
 pub use self::map::{Map, MapResolution};
 pub use self::points::Points;
+pub use self::rectangle::Rectangle;
 
-use buffer::Buffer;
-use layout::Rect;
-use style::{Color, Style};
-use widgets::{Block, Widget};
+use crate::buffer::Buffer;
+use crate::layout::Rect;
+use crate::style::{Color, Style};
+use crate::widgets::{Block, Widget};
 
 pub const DOTS: [[u16; 2]; 4] = [
     [0x0001, 0x0008],
@@ -132,9 +134,9 @@ impl<'a> Context<'a> {
 /// # Examples
 ///
 /// ```
-/// # extern crate tui;
 /// # use tui::widgets::{Block, Borders};
-/// # use tui::widgets::canvas::{Canvas, Shape, Line, Map, MapResolution};
+/// # use tui::layout::Rect;
+/// # use tui::widgets::canvas::{Canvas, Shape, Line, Rectangle, Map, MapResolution};
 /// # use tui::style::Color;
 /// # fn main() {
 /// Canvas::default()
@@ -142,23 +144,25 @@ impl<'a> Context<'a> {
 ///     .x_bounds([-180.0, 180.0])
 ///     .y_bounds([-90.0, 90.0])
 ///     .paint(|ctx| {
-///         ctx.draw(&Map{
+///         ctx.draw(&Map {
 ///             resolution: MapResolution::High,
 ///             color: Color::White
 ///         });
 ///         ctx.layer();
-///         ctx.draw(&Line{
+///         ctx.draw(&Line {
 ///             x1: 0.0,
 ///             y1: 10.0,
 ///             x2: 10.0,
 ///             y2: 10.0,
 ///             color: Color::White,
 ///         });
-///         ctx.draw(&Line{
-///             x1: 10.0,
-///             y1: 10.0,
-///             x2: 20.0,
-///             y2: 20.0,
+///         ctx.draw(&Rectangle {
+///             rect: Rect {
+///                 x: 10,
+///                 y: 20,
+///                 width: 10,
+///                 height: 10,
+///             },
 ///             color: Color::Red
 ///         });
 ///     });

src/widgets/canvas/points.rs

@@ -1,7 +1,7 @@
 use std::slice;
 
 use super::Shape;
-use style::Color;
+use crate::style::Color;
 
 /// A shape to draw a group of points with the given color
 pub struct Points<'a> {

src/widgets/canvas/rectangle.rs

@@ -0,0 +1,54 @@
+use crate::layout::Rect;
+use crate::style::Color;
+use crate::widgets::canvas::{Line, Shape};
+use itertools::Itertools;
+
+/// Shape to draw a rectangle from a `Rect` with the given color
+pub struct Rectangle {
+    pub rect: Rect,
+    pub color: Color,
+}
+
+impl<'a> Shape<'a> for Rectangle {
+    fn color(&self) -> Color {
+        self.color
+    }
+
+    fn points(&'a self) -> Box<Iterator<Item = (f64, f64)> + 'a> {
+        let left_line = Line {
+            x1: f64::from(self.rect.x),
+            y1: f64::from(self.rect.y),
+            x2: f64::from(self.rect.x),
+            y2: f64::from(self.rect.y + self.rect.height),
+            color: self.color,
+        };
+        let top_line = Line {
+            x1: f64::from(self.rect.x),
+            y1: f64::from(self.rect.y + self.rect.height),
+            x2: f64::from(self.rect.x + self.rect.width),
+            y2: f64::from(self.rect.y + self.rect.height),
+            color: self.color,
+        };
+        let right_line = Line {
+            x1: f64::from(self.rect.x + self.rect.width),
+            y1: f64::from(self.rect.y),
+            x2: f64::from(self.rect.x + self.rect.width),
+            y2: f64::from(self.rect.y + self.rect.height),
+            color: self.color,
+        };
+        let bottom_line = Line {
+            x1: f64::from(self.rect.x),
+            y1: f64::from(self.rect.y),
+            x2: f64::from(self.rect.x + self.rect.width),
+            y2: f64::from(self.rect.y),
+            color: self.color,
+        };
+        Box::new(
+            left_line.into_iter().merge(
+                top_line
+                    .into_iter()
+                    .merge(right_line.into_iter().merge(bottom_line.into_iter())),
+            ),
+        )
+    }
+}

src/widgets/chart.rs

@@ -2,12 +2,12 @@ use std::cmp::max;
 
 use unicode_width::UnicodeWidthStr;
 
-use buffer::Buffer;
-use layout::Rect;
-use style::Style;
-use symbols;
-use widgets::canvas::{Canvas, Points};
-use widgets::{Block, Borders, Widget};
+use crate::buffer::Buffer;
+use crate::layout::Rect;
+use crate::style::Style;
+use crate::symbols;
+use crate::widgets::canvas::{Canvas, Points};
+use crate::widgets::{Block, Borders, Widget};
 
 /// An X or Y axis for the chart widget
 pub struct Axis<'a, L>
@@ -166,7 +166,6 @@ impl Default for ChartLayout {
 /// # Examples
 ///
 /// ```
-/// # extern crate tui;
 /// # use tui::widgets::{Block, Borders, Chart, Axis, Dataset, Marker};
 /// # use tui::style::{Style, Color};
 /// # fn main() {
@@ -175,13 +174,13 @@ impl Default for ChartLayout {
 ///     .x_axis(Axis::default()
 ///         .title("X Axis")
 ///         .title_style(Style::default().fg(Color::Red))
-///         .style(Style::default().fg(Color::Gray))
+///         .style(Style::default().fg(Color::White))
 ///         .bounds([0.0, 10.0])
 ///         .labels(&["0.0", "5.0", "10.0"]))
 ///     .y_axis(Axis::default()
 ///         .title("Y Axis")
 ///         .title_style(Style::default().fg(Color::Red))
-///         .style(Style::default().fg(Color::Gray))
+///         .style(Style::default().fg(Color::White))
 ///         .bounds([0.0, 10.0])
 ///         .labels(&["0.0", "5.0", "10.0"]))
 ///     .datasets(&[Dataset::default()
@@ -357,7 +356,7 @@ where
             return;
         }
 
-        self.background(&chart_area, buf, self.style.bg);
+        self.background(chart_area, buf, self.style.bg);
 
         if let Some((x, y)) = layout.title_x {
             let title = self.x_axis.title.unwrap();
@@ -428,24 +427,26 @@ where
 
         for dataset in self.datasets {
             match dataset.marker {
-                Marker::Dot => for &(x, y) in dataset.data.iter().filter(|&&(x, y)| {
-                    !(x < self.x_axis.bounds[0]
-                        || x > self.x_axis.bounds[1]
-                        || y < self.y_axis.bounds[0]
-                        || y > self.y_axis.bounds[1])
-                }) {
-                    let dy = ((self.y_axis.bounds[1] - y) * f64::from(graph_area.height - 1)
-                        / (self.y_axis.bounds[1] - self.y_axis.bounds[0]))
-                        as u16;
-                    let dx = ((x - self.x_axis.bounds[0]) * f64::from(graph_area.width - 1)
-                        / (self.x_axis.bounds[1] - self.x_axis.bounds[0]))
-                        as u16;
+                Marker::Dot => {
+                    for &(x, y) in dataset.data.iter().filter(|&&(x, y)| {
+                        !(x < self.x_axis.bounds[0]
+                            || x > self.x_axis.bounds[1]
+                            || y < self.y_axis.bounds[0]
+                            || y > self.y_axis.bounds[1])
+                    }) {
+                        let dy = ((self.y_axis.bounds[1] - y) * f64::from(graph_area.height - 1)
+                            / (self.y_axis.bounds[1] - self.y_axis.bounds[0]))
+                            as u16;
+                        let dx = ((x - self.x_axis.bounds[0]) * f64::from(graph_area.width - 1)
+                            / (self.x_axis.bounds[1] - self.x_axis.bounds[0]))
+                            as u16;
 
-                    buf.get_mut(graph_area.left() + dx, graph_area.top() + dy)
-                        .set_symbol(symbols::DOT)
-                        .set_fg(dataset.style.fg)
-                        .set_bg(dataset.style.bg);
-                },
+                        buf.get_mut(graph_area.left() + dx, graph_area.top() + dy)
+                            .set_symbol(symbols::DOT)
+                            .set_fg(dataset.style.fg)
+                            .set_bg(dataset.style.bg);
+                    }
+                }
                 Marker::Braille => {
                     Canvas::default()
                         .background_color(self.style.bg)
@@ -456,7 +457,8 @@ where
                                 coords: dataset.data,
                                 color: dataset.style.fg,
                             });
-                        }).draw(graph_area, buf);
+                        })
+                        .draw(graph_area, buf);
                 }
             }
         }

src/widgets/gauge.rs

@@ -1,28 +1,27 @@
 use unicode_width::UnicodeWidthStr;
 
-use buffer::Buffer;
-use layout::Rect;
-use style::{Color, Style};
-use widgets::{Block, Widget};
+use crate::buffer::Buffer;
+use crate::layout::Rect;
+use crate::style::{Color, Style};
+use crate::widgets::{Block, Widget};
 
 /// A widget to display a task progress.
 ///
 /// # Examples:
 ///
 /// ```
-/// # extern crate tui;
 /// # use tui::widgets::{Widget, Gauge, Block, Borders};
 /// # use tui::style::{Style, Color, Modifier};
 /// # fn main() {
 /// Gauge::default()
 ///     .block(Block::default().borders(Borders::ALL).title("Progress"))
-///     .style(Style::default().fg(Color::White).bg(Color::Black).modifier(Modifier::Italic))
+///     .style(Style::default().fg(Color::White).bg(Color::Black).modifier(Modifier::ITALIC))
 ///     .percent(20);
 /// # }
 /// ```
 pub struct Gauge<'a> {
     block: Option<Block<'a>>,
-    percent: u16,
+    ratio: f64,
     label: Option<&'a str>,
     style: Style,
 }
@@ -31,7 +30,7 @@ impl<'a> Default for Gauge<'a> {
     fn default() -> Gauge<'a> {
         Gauge {
             block: None,
-            percent: 0,
+            ratio: 0.0,
             label: None,
             style: Default::default(),
         }
@@ -45,7 +44,21 @@ impl<'a> Gauge<'a> {
     }
 
     pub fn percent(mut self, percent: u16) -> Gauge<'a> {
-        self.percent = percent;
+        assert!(
+            percent <= 100,
+            "Percentage should be between 0 and 100 inclusively."
+        );
+        self.ratio = f64::from(percent) / 100.0;
+        self
+    }
+
+    /// Sets ratio ([0.0, 1.0]) directly.
+    pub fn ratio(mut self, ratio: f64) -> Gauge<'a> {
+        assert!(
+            ratio <= 1.0 && ratio >= 0.0,
+            "Ratio should be between 0 and 1 inclusively."
+        );
+        self.ratio = ratio;
         self
     }
 
@@ -74,11 +87,11 @@ impl<'a> Widget for Gauge<'a> {
         }
 
         if self.style.bg != Color::Reset {
-            self.background(&gauge_area, buf, self.style.bg);
+            self.background(gauge_area, buf, self.style.bg);
         }
 
         let center = gauge_area.height / 2 + gauge_area.top();
-        let width = (gauge_area.width * self.percent) / 100;
+        let width = (f64::from(gauge_area.width) * self.ratio).round() as u16;
         let end = gauge_area.left() + width;
         for y in gauge_area.top()..gauge_area.bottom() {
             // Gauge
@@ -88,7 +101,7 @@ impl<'a> Widget for Gauge<'a> {
 
             if y == center {
                 // Label
-                let precent_label = format!("{}%", self.percent);
+                let precent_label = format!("{}%", (self.ratio * 100.0).round());
                 let label = self.label.unwrap_or(&precent_label);
                 let label_width = label.width() as u16;
                 let middle = (gauge_area.width - label_width) / 2 + gauge_area.left();
@@ -104,3 +117,26 @@ impl<'a> Widget for Gauge<'a> {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    #[should_panic]
+    fn gauge_invalid_percentage() {
+        Gauge::default().percent(110);
+    }
+
+    #[test]
+    #[should_panic]
+    fn gauge_invalid_ratio_upper_bound() {
+        Gauge::default().ratio(1.1);
+    }
+
+    #[test]
+    #[should_panic]
+    fn gauge_invalid_ratio_lower_bound() {
+        Gauge::default().ratio(-0.5);
+    }
+}

src/widgets/list.rs

@@ -1,12 +1,12 @@
-use std::iter;
-use std::iter::Iterator;
+use std::convert::AsRef;
+use std::iter::{self, Iterator};
 
 use unicode_width::UnicodeWidthStr;
 
-use buffer::Buffer;
-use layout::{Corner, Rect};
-use style::Style;
-use widgets::{Block, Text, Widget};
+use crate::buffer::Buffer;
+use crate::layout::{Corner, Rect};
+use crate::style::Style;
+use crate::widgets::{Block, Text, Widget};
 
 pub struct List<'b, L>
 where
@@ -86,7 +86,7 @@ where
             return;
         }
 
-        self.background(&list_area, buf, self.style.bg);
+        self.background(list_area, buf, self.style.bg);
 
         for (i, item) in self
             .items
@@ -117,7 +117,6 @@ where
 /// # Examples
 ///
 /// ```
-/// # extern crate tui;
 /// # use tui::widgets::{Block, Borders, SelectableList};
 /// # use tui::style::{Style, Color, Modifier};
 /// # fn main() {
@@ -126,7 +125,7 @@ where
 ///     .items(&["Item 1", "Item 2", "Item 3"])
 ///     .select(Some(1))
 ///     .style(Style::default().fg(Color::White))
-///     .highlight_style(Style::default().modifier(Modifier::Italic))
+///     .highlight_style(Style::default().modifier(Modifier::ITALIC))
 ///     .highlight_symbol(">>");
 /// # }
 /// ```
@@ -167,7 +166,7 @@ impl<'b> SelectableList<'b> {
     where
         I: AsRef<str> + 'b,
     {
-        self.items = items.iter().map(|i| i.as_ref()).collect::<Vec<&str>>();
+        self.items = items.iter().map(AsRef::as_ref).collect::<Vec<&str>>();
         self
     }
 
@@ -236,7 +235,8 @@ impl<'b> Widget for SelectableList<'b> {
                 } else {
                     Text::styled(item, self.style)
                 }
-            }).skip(offset as usize);
+            })
+            .skip(offset as usize);
         List::new(items)
             .block(self.block.unwrap_or_default())
             .style(self.style)

src/widgets/mod.rs

@@ -1,3 +1,4 @@
+use bitflags::bitflags;
 use std::borrow::Cow;
 
 mod barchart;
@@ -7,6 +8,7 @@ mod chart;
 mod gauge;
 mod list;
 mod paragraph;
+mod reflow;
 mod sparkline;
 mod table;
 mod tabs;
@@ -21,11 +23,11 @@ pub use self::sparkline::Sparkline;
 pub use self::table::{Row, Table};
 pub use self::tabs::Tabs;
 
-use backend::Backend;
-use buffer::Buffer;
-use layout::Rect;
-use style::{Color, Style};
-use terminal::Frame;
+use crate::backend::Backend;
+use crate::buffer::Buffer;
+use crate::layout::Rect;
+use crate::style::{Color, Style};
+use crate::terminal::Frame;
 
 /// Bitflags that can be composed to set the visible borders essentially on the block widget.
 bitflags! {
@@ -66,7 +68,7 @@ pub trait Widget {
     /// implement a custom widget.
     fn draw(&mut self, area: Rect, buf: &mut Buffer);
     /// Helper method to quickly set the background of all cells inside the specified area.
-    fn background(&self, area: &Rect, buf: &mut Buffer, color: Color) {
+    fn background(&self, area: Rect, buf: &mut Buffer, color: Color) {
         for y in area.top()..area.bottom() {
             for x in area.left()..area.right() {
                 buf.get_mut(x, y).set_bg(color);

src/widgets/paragraph.rs

@@ -1,19 +1,26 @@
 use either::Either;
-use itertools::{multipeek, MultiPeek};
 use unicode_segmentation::UnicodeSegmentation;
 use unicode_width::UnicodeWidthStr;
 
-use buffer::Buffer;
-use layout::{Alignment, Rect};
-use style::Style;
-use widgets::{Block, Text, Widget};
+use crate::buffer::Buffer;
+use crate::layout::{Alignment, Rect};
+use crate::style::Style;
+use crate::widgets::reflow::{LineComposer, LineTruncator, Styled, WordWrapper};
+use crate::widgets::{Block, Text, Widget};
+
+fn get_line_offset(line_width: u16, text_area_width: u16, alignment: Alignment) -> u16 {
+    match alignment {
+        Alignment::Center => (text_area_width / 2).saturating_sub(line_width / 2),
+        Alignment::Right => text_area_width.saturating_sub(line_width),
+        Alignment::Left => 0,
+    }
+}
 
 /// A widget to display some text.
 ///
 /// # Examples
 ///
 /// ```
-/// # extern crate tui;
 /// # use tui::widgets::{Block, Borders, Paragraph, Text};
 /// # use tui::style::{Style, Color};
 /// # use tui::layout::{Alignment};
@@ -96,7 +103,7 @@ where
     }
 }
 
-impl<'a, 't, T> Widget for Paragraph<'a, 't, T>
+impl<'a, 't, 'b, T> Widget for Paragraph<'a, 't, T>
 where
     T: Iterator<Item = &'t Text<'t>>,
 {
@@ -113,91 +120,40 @@ where
             return;
         }
 
-        self.background(&text_area, buf, self.style.bg);
+        self.background(text_area, buf, self.style.bg);
 
         let style = self.style;
-        let styled = self.text.by_ref().flat_map(|t| match *t {
+        let mut styled = self.text.by_ref().flat_map(|t| match *t {
             Text::Raw(ref d) => {
                 let data: &'t str = d; // coerce to &str
-                Either::Left(UnicodeSegmentation::graphemes(data, true).map(|g| (g, style)))
+                Either::Left(UnicodeSegmentation::graphemes(data, true).map(|g| Styled(g, style)))
             }
             Text::Styled(ref d, s) => {
                 let data: &'t str = d; // coerce to &str
-                Either::Right(UnicodeSegmentation::graphemes(data, true).map(move |g| (g, s)))
+                Either::Right(UnicodeSegmentation::graphemes(data, true).map(move |g| Styled(g, s)))
             }
         });
-        let mut styled = multipeek(styled);
 
-        fn get_cur_line_len<'a, I: Iterator<Item = (&'a str, Style)>>(
-            styled: &mut MultiPeek<I>,
-        ) -> u16 {
-            let mut line_len = 0;
-            while match &styled.peek() {
-                Some(&(x, _)) => x != "\n",
-                None => false,
-            } {
-                line_len += 1;
-            }
-            line_len
-        };
-
-        let mut x = match self.alignment {
-            Alignment::Center => {
-                (text_area.width / 2).saturating_sub(get_cur_line_len(&mut styled) / 2)
-            }
-            Alignment::Right => (text_area.width).saturating_sub(get_cur_line_len(&mut styled)),
-            Alignment::Left => 0,
+        let mut line_composer: Box<dyn LineComposer> = if self.wrapping {
+            Box::new(WordWrapper::new(&mut styled, text_area.width))
+        } else {
+            Box::new(LineTruncator::new(&mut styled, text_area.width))
         };
         let mut y = 0;
-
-        let mut remove_leading_whitespaces = false;
-        while let Some((string, style)) = styled.next() {
-            if string == "\n" {
-                x = match self.alignment {
-                    Alignment::Center => {
-                        (text_area.width / 2).saturating_sub(get_cur_line_len(&mut styled) / 2)
-                    }
-
-                    Alignment::Right => {
-                        (text_area.width).saturating_sub(get_cur_line_len(&mut styled))
-                    }
-                    Alignment::Left => 0,
-                };
-                y += 1;
-                continue;
+        while let Some((current_line, current_line_width)) = line_composer.next_line() {
+            if y >= self.scroll {
+                let mut x = get_line_offset(current_line_width, text_area.width, self.alignment);
+                for Styled(symbol, style) in current_line {
+                    buf.get_mut(text_area.left() + x, text_area.top() + y - self.scroll)
+                        .set_symbol(symbol)
+                        .set_style(*style);
+                    x += symbol.width() as u16;
+                }
             }
-            if x >= text_area.width && self.wrapping {
-                x = match self.alignment {
-                    Alignment::Center => {
-                        (text_area.width / 2).saturating_sub(get_cur_line_len(&mut styled) / 2)
-                    }
-
-                    Alignment::Right => {
-                        (text_area.width).saturating_sub(get_cur_line_len(&mut styled) + 1)
-                    }
-                    Alignment::Left => 0,
-                };
-                y += 1;
-                remove_leading_whitespaces = true
-            }
-
-            if remove_leading_whitespaces && string == " " {
-                continue;
-            }
-            remove_leading_whitespaces = false;
-
-            if y > text_area.height + self.scroll - 1 {
+            y += 1;
+            if y >= text_area.height + self.scroll {
                 break;
             }
-
-            if y < self.scroll {
-                continue;
-            }
-
-            buf.get_mut(text_area.left() + x, text_area.top() + y - self.scroll)
-                .set_symbol(string)
-                .set_style(style);
-            x += string.width() as u16;
         }
     }
 }

src/widgets/reflow.rs

@@ -0,0 +1,446 @@
+use crate::style::Style;
+use unicode_width::UnicodeWidthStr;
+
+const NBSP: &str = "\u{00a0}";
+
+#[derive(Copy, Clone, Debug)]
+pub struct Styled<'a>(pub &'a str, pub Style);
+
+/// A state machine to pack styled symbols into lines.
+/// Cannot implement it as Iterator since it yields slices of the internal buffer (need streaming
+/// iterators for that).
+pub trait LineComposer<'a> {
+    fn next_line(&mut self) -> Option<(&[Styled<'a>], u16)>;
+}
+
+/// A state machine that wraps lines on word boundaries.
+pub struct WordWrapper<'a, 'b> {
+    symbols: &'b mut Iterator<Item = Styled<'a>>,
+    max_line_width: u16,
+    current_line: Vec<Styled<'a>>,
+    next_line: Vec<Styled<'a>>,
+}
+
+impl<'a, 'b> WordWrapper<'a, 'b> {
+    pub fn new(
+        symbols: &'b mut Iterator<Item = Styled<'a>>,
+        max_line_width: u16,
+    ) -> WordWrapper<'a, 'b> {
+        WordWrapper {
+            symbols,
+            max_line_width,
+            current_line: vec![],
+            next_line: vec![],
+        }
+    }
+}
+
+impl<'a, 'b> LineComposer<'a> for WordWrapper<'a, 'b> {
+    fn next_line(&mut self) -> Option<(&[Styled<'a>], u16)> {
+        if self.max_line_width == 0 {
+            return None;
+        }
+        std::mem::swap(&mut self.current_line, &mut self.next_line);
+        self.next_line.truncate(0);
+
+        let mut current_line_width = self
+            .current_line
+            .iter()
+            .map(|Styled(c, _)| c.width() as u16)
+            .sum();
+
+        let mut symbols_to_last_word_end: usize = 0;
+        let mut width_to_last_word_end: u16 = 0;
+        let mut prev_whitespace = false;
+        let mut symbols_exhausted = true;
+        for Styled(symbol, style) in &mut self.symbols {
+            symbols_exhausted = false;
+            let symbol_whitespace = symbol.chars().all(&char::is_whitespace);
+
+            // Ignore characters wider that the total max width.
+            if symbol.width() as u16 > self.max_line_width
+                // Skip leading whitespace.
+                || symbol_whitespace && symbol != "\n" && current_line_width == 0
+            {
+                continue;
+            }
+
+            // Break on newline and discard it.
+            if symbol == "\n" {
+                if prev_whitespace {
+                    current_line_width = width_to_last_word_end;
+                    self.current_line.truncate(symbols_to_last_word_end);
+                }
+                break;
+            }
+
+            // Mark the previous symbol as word end.
+            if symbol_whitespace && !prev_whitespace && symbol != NBSP {
+                symbols_to_last_word_end = self.current_line.len();
+                width_to_last_word_end = current_line_width;
+            }
+
+            self.current_line.push(Styled(symbol, style));
+            current_line_width += symbol.width() as u16;
+
+            if current_line_width > self.max_line_width {
+                // If there was no word break in the text, wrap at the end of the line.
+                let (truncate_at, truncated_width) = if symbols_to_last_word_end != 0 {
+                    (symbols_to_last_word_end, width_to_last_word_end)
+                } else {
+                    (self.current_line.len() - 1, self.max_line_width)
+                };
+
+                // Push the remainder to the next line but strip leading whitespace:
+                {
+                    let remainder = &self.current_line[truncate_at..];
+                    if let Some(remainder_nonwhite) = remainder
+                        .iter()
+                        .position(|Styled(c, _)| !c.chars().all(&char::is_whitespace))
+                    {
+                        self.next_line
+                            .extend_from_slice(&remainder[remainder_nonwhite..]);
+                    }
+                }
+                self.current_line.truncate(truncate_at);
+                current_line_width = truncated_width;
+                break;
+            }
+
+            prev_whitespace = symbol_whitespace;
+        }
+
+        // Even if the iterator is exhausted, pass the previous remainder.
+        if symbols_exhausted && self.current_line.is_empty() {
+            None
+        } else {
+            Some((&self.current_line[..], current_line_width))
+        }
+    }
+}
+
+/// A state machine that truncates overhanging lines.
+pub struct LineTruncator<'a, 'b> {
+    symbols: &'b mut Iterator<Item = Styled<'a>>,
+    max_line_width: u16,
+    current_line: Vec<Styled<'a>>,
+}
+
+impl<'a, 'b> LineTruncator<'a, 'b> {
+    pub fn new(
+        symbols: &'b mut Iterator<Item = Styled<'a>>,
+        max_line_width: u16,
+    ) -> LineTruncator<'a, 'b> {
+        LineTruncator {
+            symbols,
+            max_line_width,
+            current_line: vec![],
+        }
+    }
+}
+
+impl<'a, 'b> LineComposer<'a> for LineTruncator<'a, 'b> {
+    fn next_line(&mut self) -> Option<(&[Styled<'a>], u16)> {
+        if self.max_line_width == 0 {
+            return None;
+        }
+
+        self.current_line.truncate(0);
+        let mut current_line_width = 0;
+
+        let mut skip_rest = false;
+        let mut symbols_exhausted = true;
+        for Styled(symbol, style) in &mut self.symbols {
+            symbols_exhausted = false;
+
+            // Ignore characters wider that the total max width.
+            if symbol.width() as u16 > self.max_line_width {
+                continue;
+            }
+
+            // Break on newline and discard it.
+            if symbol == "\n" {
+                break;
+            }
+
+            if current_line_width + symbol.width() as u16 > self.max_line_width {
+                // Exhaust the remainder of the line.
+                skip_rest = true;
+                break;
+            }
+
+            current_line_width += symbol.width() as u16;
+            self.current_line.push(Styled(symbol, style));
+        }
+
+        if skip_rest {
+            for Styled(symbol, _) in &mut self.symbols {
+                if symbol == "\n" {
+                    break;
+                }
+            }
+        }
+
+        if symbols_exhausted && self.current_line.is_empty() {
+            None
+        } else {
+            Some((&self.current_line[..], current_line_width))
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use unicode_segmentation::UnicodeSegmentation;
+
+    enum Composer {
+        WordWrapper,
+        LineTruncator,
+    }
+
+    fn run_composer(which: Composer, text: &str, text_area_width: u16) -> (Vec<String>, Vec<u16>) {
+        let style = Default::default();
+        let mut styled = UnicodeSegmentation::graphemes(text, true).map(|g| Styled(g, style));
+        let mut composer: Box<dyn LineComposer> = match which {
+            Composer::WordWrapper => Box::new(WordWrapper::new(&mut styled, text_area_width)),
+            Composer::LineTruncator => Box::new(LineTruncator::new(&mut styled, text_area_width)),
+        };
+        let mut lines = vec![];
+        let mut widths = vec![];
+        while let Some((styled, width)) = composer.next_line() {
+            let line = styled
+                .iter()
+                .map(|Styled(g, _style)| *g)
+                .collect::<String>();
+            assert!(width <= text_area_width);
+            lines.push(line);
+            widths.push(width);
+        }
+        (lines, widths)
+    }
+
+    #[test]
+    fn line_composer_one_line() {
+        let width = 40;
+        for i in 1..width {
+            let text = "a".repeat(i);
+            let (word_wrapper, _) = run_composer(Composer::WordWrapper, &text, width as u16);
+            let (line_truncator, _) = run_composer(Composer::LineTruncator, &text, width as u16);
+            let expected = vec![text];
+            assert_eq!(word_wrapper, expected);
+            assert_eq!(line_truncator, expected);
+        }
+    }
+
+    #[test]
+    fn line_composer_short_lines() {
+        let width = 20;
+        let text =
+            "abcdefg\nhijklmno\npabcdefg\nhijklmn\nopabcdefghijk\nlmnopabcd\n\n\nefghijklmno";
+        let (word_wrapper, _) = run_composer(Composer::WordWrapper, text, width);
+        let (line_truncator, _) = run_composer(Composer::LineTruncator, text, width);
+
+        let wrapped: Vec<&str> = text.split('\n').collect();
+        assert_eq!(word_wrapper, wrapped);
+        assert_eq!(line_truncator, wrapped);
+    }
+
+    #[test]
+    fn line_composer_long_word() {
+        let width = 20;
+        let text = "abcdefghijklmnopabcdefghijklmnopabcdefghijklmnopabcdefghijklmno";
+        let (word_wrapper, _) = run_composer(Composer::WordWrapper, text, width as u16);
+        let (line_truncator, _) = run_composer(Composer::LineTruncator, text, width as u16);
+
+        let wrapped = vec![
+            &text[..width],
+            &text[width..width * 2],
+            &text[width * 2..width * 3],
+            &text[width * 3..],
+        ];
+        assert_eq!(
+            word_wrapper, wrapped,
+            "WordWrapper should deect the line cannot be broken on word boundary and \
+             break it at line width limit."
+        );
+        assert_eq!(line_truncator, vec![&text[..width]]);
+    }
+
+    #[test]
+    fn line_composer_long_sentence() {
+        let width = 20;
+        let text =
+            "abcd efghij klmnopabcd efgh ijklmnopabcdefg hijkl mnopab c d e f g h i j k l m n o";
+        let text_multi_space =
+            "abcd efghij    klmnopabcd efgh     ijklmnopabcdefg hijkl mnopab c d e f g h i j k l \
+             m n o";
+        let (word_wrapper_single_space, _) =
+            run_composer(Composer::WordWrapper, text, width as u16);
+        let (word_wrapper_multi_space, _) =
+            run_composer(Composer::WordWrapper, text_multi_space, width as u16);
+        let (line_truncator, _) = run_composer(Composer::LineTruncator, text, width as u16);
+
+        let word_wrapped = vec![
+            "abcd efghij",
+            "klmnopabcd efgh",
+            "ijklmnopabcdefg",
+            "hijkl mnopab c d e f",
+            "g h i j k l m n o",
+        ];
+        assert_eq!(word_wrapper_single_space, word_wrapped);
+        assert_eq!(word_wrapper_multi_space, word_wrapped);
+
+        assert_eq!(line_truncator, vec![&text[..width]]);
+    }
+
+    #[test]
+    fn line_composer_zero_width() {
+        let width = 0;
+        let text = "abcd efghij klmnopabcd efgh ijklmnopabcdefg hijkl mnopab ";
+        let (word_wrapper, _) = run_composer(Composer::WordWrapper, text, width);
+        let (line_truncator, _) = run_composer(Composer::LineTruncator, text, width);
+
+        let expected: Vec<&str> = Vec::new();
+        assert_eq!(word_wrapper, expected);
+        assert_eq!(line_truncator, expected);
+    }
+
+    #[test]
+    fn line_composer_max_line_width_of_1() {
+        let width = 1;
+        let text = "abcd efghij klmnopabcd efgh ijklmnopabcdefg hijkl mnopab ";
+        let (word_wrapper, _) = run_composer(Composer::WordWrapper, text, width);
+        let (line_truncator, _) = run_composer(Composer::LineTruncator, text, width);
+
+        let expected: Vec<&str> = UnicodeSegmentation::graphemes(text, true)
+            .filter(|g| g.chars().any(|c| !c.is_whitespace()))
+            .collect();
+        assert_eq!(word_wrapper, expected);
+        assert_eq!(line_truncator, vec!["a"]);
+    }
+
+    #[test]
+    fn line_composer_max_line_width_of_1_double_width_characters() {
+        let width = 1;
+        let text = "コンピュータ上で文字を扱う場合、典型的には文字\naaaによる通信を行う場合にその\
+                    両端点では、";
+        let (word_wrapper, _) = run_composer(Composer::WordWrapper, text, width);
+        let (line_truncator, _) = run_composer(Composer::LineTruncator, text, width);
+        assert_eq!(word_wrapper, vec!["", "a", "a", "a"]);
+        assert_eq!(line_truncator, vec!["", "a"]);
+    }
+
+    /// Tests WordWrapper with words some of which exceed line length and some not.
+    #[test]
+    fn line_composer_word_wrapper_mixed_length() {
+        let width = 20;
+        let text = "abcd efghij klmnopabcdefghijklmnopabcdefghijkl mnopab cdefghi j klmno";
+        let (word_wrapper, _) = run_composer(Composer::WordWrapper, text, width);
+        assert_eq!(
+            word_wrapper,
+            vec![
+                "abcd efghij",
+                "klmnopabcdefghijklmn",
+                "opabcdefghijkl",
+                "mnopab cdefghi j",
+                "klmno",
+            ]
+        )
+    }
+
+    #[test]
+    fn line_composer_double_width_chars() {
+        let width = 20;
+        let text = "コンピュータ上で文字を扱う場合、典型的には文字による通信を行う場合にその両端点\
+                    では、";
+        let (word_wrapper, word_wrapper_width) = run_composer(Composer::WordWrapper, &text, width);
+        let (line_truncator, _) = run_composer(Composer::LineTruncator, &text, width);
+        assert_eq!(line_truncator, vec!["コンピュータ上で文字"]);
+        let wrapped = vec![
+            "コンピュータ上で文字",
+            "を扱う場合、典型的に",
+            "は文字による通信を行",
+            "う場合にその両端点で",
+            "は、",
+        ];
+        assert_eq!(word_wrapper, wrapped);
+        assert_eq!(word_wrapper_width, vec![width, width, width, width, 4]);
+    }
+
+    #[test]
+    fn line_composer_leading_whitespace_removal() {
+        let width = 20;
+        let text = "AAAAAAAAAAAAAAAAAAAA    AAA";
+        let (word_wrapper, _) = run_composer(Composer::WordWrapper, text, width);
+        let (line_truncator, _) = run_composer(Composer::LineTruncator, text, width);
+        assert_eq!(word_wrapper, vec!["AAAAAAAAAAAAAAAAAAAA", "AAA",]);
+        assert_eq!(line_truncator, vec!["AAAAAAAAAAAAAAAAAAAA"]);
+    }
+
+    /// Tests truncation of leading whitespace.
+    #[test]
+    fn line_composer_lots_of_spaces() {
+        let width = 20;
+        let text = "                                                                     ";
+        let (word_wrapper, _) = run_composer(Composer::WordWrapper, text, width);
+        let (line_truncator, _) = run_composer(Composer::LineTruncator, text, width);
+        assert_eq!(word_wrapper, vec![""]);
+        assert_eq!(line_truncator, vec!["                    "]);
+    }
+
+    /// Tests an input starting with a letter, folowed by spaces - some of the behaviour is
+    /// incidental.
+    #[test]
+    fn line_composer_char_plus_lots_of_spaces() {
+        let width = 20;
+        let text = "a                                                                     ";
+        let (word_wrapper, _) = run_composer(Composer::WordWrapper, text, width);
+        let (line_truncator, _) = run_composer(Composer::LineTruncator, text, width);
+        // What's happening below is: the first line gets consumed, trailing spaces discarded,
+        // after 20 of which a word break occurs (probably shouldn't). The second line break
+        // discards all whitespace. The result should probably be vec!["a"] but it doesn't matter
+        // that much.
+        assert_eq!(word_wrapper, vec!["a", ""]);
+        assert_eq!(line_truncator, vec!["a                   "]);
+    }
+
+    #[test]
+    fn line_composer_word_wrapper_double_width_chars_mixed_with_spaces() {
+        let width = 20;
+        // Japanese seems not to use spaces but we should break on spaces anyway... We're using it
+        // to test double-width chars.
+        // You are more than welcome to add word boundary detection based of alterations of
+        // hiragana and katakana...
+        // This happens to also be a test case for mixed width because regular spaces are single width.
+        let text = "コンピュ ータ上で文字を扱う場合、 典型的には文 字による 通信を行 う場合にその両端点では、";
+        let (word_wrapper, word_wrapper_width) = run_composer(Composer::WordWrapper, text, width);
+        assert_eq!(
+            word_wrapper,
+            vec![
+                "コンピュ",
+                "ータ上で文字を扱う場",
+                "合、 典型的には文",
+                "字による 通信を行",
+                "う場合にその両端点で",
+                "は、",
+            ]
+        );
+        // Odd-sized lines have a space in them.
+        assert_eq!(word_wrapper_width, vec![8, 20, 17, 17, 20, 4]);
+    }
+
+    /// Ensure words separated by nbsp are wrapped as if they were a single one.
+    #[test]
+    fn line_composer_word_wrapper_nbsp() {
+        let width = 20;
+        let text = "AAAAAAAAAAAAAAA AAAA\u{00a0}AAA";
+        let (word_wrapper, _) = run_composer(Composer::WordWrapper, text, width);
+        assert_eq!(word_wrapper, vec!["AAAAAAAAAAAAAAA", "AAAA\u{00a0}AAA",]);
+
+        // Ensure that if the character was a regular space, it would be wrapped differently.
+        let text_space = text.replace("\u{00a0}", " ");
+        let (word_wrapper_space, _) = run_composer(Composer::WordWrapper, &text_space, width);
+        assert_eq!(word_wrapper_space, vec!["AAAAAAAAAAAAAAA AAAA", "AAA",]);
+    }
+}

src/widgets/sparkline.rs

@@ -1,17 +1,16 @@
 use std::cmp::min;
 
-use buffer::Buffer;
-use layout::Rect;
-use style::Style;
-use symbols::bar;
-use widgets::{Block, Widget};
+use crate::buffer::Buffer;
+use crate::layout::Rect;
+use crate::style::Style;
+use crate::symbols::bar;
+use crate::widgets::{Block, Widget};
 
 /// Widget to render a sparkline over one or more lines.
 ///
 /// # Examples
 ///
 /// ```
-/// # extern crate tui;
 /// # use tui::widgets::{Block, Borders, Sparkline};
 /// # use tui::style::{Style, Color};
 /// # fn main() {
@@ -90,7 +89,13 @@ impl<'a> Widget for Sparkline<'a> {
             .data
             .iter()
             .take(max_index)
-            .map(|e| e * u64::from(spark_area.height) * 8 / max)
+            .map(|e| {
+                if max != 0 {
+                    e * u64::from(spark_area.height) * 8 / max
+                } else {
+                    0
+                }
+            })
             .collect::<Vec<u64>>();
         for j in (0..spark_area.height).rev() {
             for (i, d) in data.iter_mut().enumerate() {
@@ -119,3 +124,24 @@ impl<'a> Widget for Sparkline<'a> {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn it_does_not_panic_if_max_is_zero() {
+        let mut widget = Sparkline::default().data(&[0, 0, 0]);
+        let area = Rect::new(0, 0, 3, 1);
+        let mut buffer = Buffer::empty(area);
+        widget.draw(area, &mut buffer);
+    }
+
+    #[test]
+    fn it_does_not_panic_if_max_is_set_to_zero() {
+        let mut widget = Sparkline::default().data(&[0, 1, 2]).max(0);
+        let area = Rect::new(0, 0, 3, 1);
+        let mut buffer = Buffer::empty(area);
+        widget.draw(area, &mut buffer);
+    }
+}

src/widgets/table.rs

@@ -1,10 +1,10 @@
 use std::fmt::Display;
 use std::iter::Iterator;
 
-use buffer::Buffer;
-use layout::Rect;
-use style::Style;
-use widgets::{Block, Widget};
+use crate::buffer::Buffer;
+use crate::layout::Rect;
+use crate::style::Style;
+use crate::widgets::{Block, Widget};
 
 /// Holds data to be displayed in a Table widget
 pub enum Row<D, I>
@@ -167,7 +167,7 @@ where
         };
 
         // Set the background
-        self.background(&table_area, buf, self.style.bg);
+        self.background(table_area, buf, self.style.bg);
 
         // Save widths of the columns that will fit in the given area
         let mut x = 0;

src/widgets/tabs.rs

@@ -1,25 +1,26 @@
 use unicode_width::UnicodeWidthStr;
 
-use buffer::Buffer;
-use layout::Rect;
-use style::Style;
-use symbols::line;
-use widgets::{Block, Widget};
+use crate::buffer::Buffer;
+use crate::layout::Rect;
+use crate::style::Style;
+use crate::symbols::line;
+use crate::widgets::{Block, Widget};
 
 /// A widget to display available tabs in a multiple panels context.
 ///
 /// # Examples
 ///
 /// ```
-/// # extern crate tui;
 /// # use tui::widgets::{Block, Borders, Tabs};
 /// # use tui::style::{Style, Color};
+/// # use tui::symbols::{DOT};
 /// # fn main() {
 /// Tabs::default()
 ///     .block(Block::default().title("Tabs").borders(Borders::ALL))
 ///     .titles(&["Tab1", "Tab2", "Tab3", "Tab4"])
 ///     .style(Style::default().fg(Color::White))
-///     .highlight_style(Style::default().fg(Color::Yellow));
+///     .highlight_style(Style::default().fg(Color::Yellow))
+///     .divider(DOT);
 /// # }
 /// ```
 pub struct Tabs<'a, T>
@@ -36,6 +37,8 @@ where
     style: Style,
     /// The style used to display the selected item
     highlight_style: Style,
+    /// Tab divider
+    divider: &'a str,
 }
 
 impl<'a, T> Default for Tabs<'a, T>
@@ -49,6 +52,7 @@ where
             selected: 0,
             style: Default::default(),
             highlight_style: Default::default(),
+            divider: line::VERTICAL,
         }
     }
 }
@@ -81,6 +85,11 @@ where
         self.highlight_style = style;
         self
     }
+
+    pub fn divider(mut self, divider: &'a str) -> Tabs<'a, T> {
+        self.divider = divider;
+        self
+    }
 }
 
 impl<'a, T> Widget for Tabs<'a, T>
@@ -100,14 +109,17 @@ where
             return;
         }
 
-        self.background(&tabs_area, buf, self.style.bg);
+        self.background(tabs_area, buf, self.style.bg);
 
         let mut x = tabs_area.left();
-        for (title, style) in self.titles.iter().enumerate().map(|(i, t)| {
+        let titles_length = self.titles.len();
+        let divider_width = self.divider.width() as u16;
+        for (title, style, last_title) in self.titles.iter().enumerate().map(|(i, t)| {
+            let lt = i + 1 == titles_length;
             if i == self.selected {
-                (t, self.highlight_style)
+                (t, self.highlight_style, lt)
             } else {
-                (t, self.style)
+                (t, self.style, lt)
             }
         }) {
             x += 1;
@@ -116,14 +128,11 @@ where
             } else {
                 buf.set_string(x, tabs_area.top(), title.as_ref(), style);
                 x += title.as_ref().width() as u16 + 1;
-                if x >= tabs_area.right() {
+                if x >= tabs_area.right() || last_title {
                     break;
                 } else {
-                    buf.get_mut(x, tabs_area.top())
-                        .set_symbol(line::VERTICAL)
-                        .set_fg(self.style.fg)
-                        .set_bg(self.style.bg);
-                    x += 1;
+                    buf.set_string(x, tabs_area.top(), self.divider, style);
+                    x += divider_width;
                 }
             }
         }

tests/block.rs

@@ -0,0 +1,45 @@
+use tui::backend::TestBackend;
+use tui::buffer::Buffer;
+use tui::layout::Rect;
+use tui::style::{Color, Style};
+use tui::widgets::{Block, Borders, Widget};
+use tui::Terminal;
+
+#[test]
+fn it_draws_a_block() {
+    let backend = TestBackend::new(10, 10);
+    let mut terminal = Terminal::new(backend).unwrap();
+    terminal
+        .draw(|mut f| {
+            Block::default()
+                .title("Title")
+                .borders(Borders::ALL)
+                .title_style(Style::default().fg(Color::LightBlue))
+                .render(
+                    &mut f,
+                    Rect {
+                        x: 0,
+                        y: 0,
+                        width: 8,
+                        height: 8,
+                    },
+                );
+        })
+        .unwrap();
+    let mut expected = Buffer::with_lines(vec![
+        "┌Title─┐  ",
+        "│      │  ",
+        "│      │  ",
+        "│      │  ",
+        "│      │  ",
+        "│      │  ",
+        "│      │  ",
+        "└──────┘  ",
+        "          ",
+        "          ",
+    ]);
+    for x in 1..=5 {
+        expected.get_mut(x, 0).set_fg(Color::LightBlue);
+    }
+    assert_eq!(&expected, terminal.backend().buffer());
+}

tests/gauge.rs

@@ -0,0 +1,42 @@
+use tui::backend::TestBackend;
+use tui::buffer::Buffer;
+use tui::layout::{Constraint, Direction, Layout};
+use tui::widgets::{Block, Borders, Gauge, Widget};
+use tui::Terminal;
+
+#[test]
+fn gauge_render() {
+    let backend = TestBackend::new(40, 10);
+    let mut terminal = Terminal::new(backend).unwrap();
+    terminal
+        .draw(|mut f| {
+            let chunks = Layout::default()
+                .direction(Direction::Vertical)
+                .margin(2)
+                .constraints([Constraint::Percentage(50), Constraint::Percentage(50)].as_ref())
+                .split(f.size());
+
+            Gauge::default()
+                .block(Block::default().title("Percentage").borders(Borders::ALL))
+                .percent(43)
+                .render(&mut f, chunks[0]);
+            Gauge::default()
+                .block(Block::default().title("Ratio").borders(Borders::ALL))
+                .ratio(0.2113139343131)
+                .render(&mut f, chunks[1]);
+        })
+        .unwrap();
+    let expected = Buffer::with_lines(vec![
+        "                                        ",
+        "                                        ",
+        "  ┌Percentage────────────────────────┐  ",
+        "  │               43%                │  ",
+        "  └──────────────────────────────────┘  ",
+        "  ┌Ratio─────────────────────────────┐  ",
+        "  │               21%                │  ",
+        "  └──────────────────────────────────┘  ",
+        "                                        ",
+        "                                        ",
+    ]);
+    assert_eq!(&expected, terminal.backend().buffer());
+}

tests/paragraph.rs

@@ -0,0 +1,141 @@
+use tui::backend::TestBackend;
+use tui::buffer::Buffer;
+use tui::layout::Alignment;
+use tui::widgets::{Block, Borders, Paragraph, Text, Widget};
+use tui::Terminal;
+
+const SAMPLE_STRING: &str =
+    "The library is based on the principle of immediate rendering with \
+     intermediate buffers. This means that at each new frame you should build all widgets that are \
+     supposed to be part of the UI. While providing a great flexibility for rich and \
+     interactive UI, this may introduce overhead for highly dynamic content.";
+
+#[test]
+fn paragraph_render_wrap() {
+    let render = |alignment| {
+        let backend = TestBackend::new(20, 10);
+        let mut terminal = Terminal::new(backend).unwrap();
+
+        terminal
+            .draw(|mut f| {
+                let size = f.size();
+                let text = [Text::raw(SAMPLE_STRING)];
+                Paragraph::new(text.iter())
+                    .block(Block::default().borders(Borders::ALL))
+                    .alignment(alignment)
+                    .wrap(true)
+                    .render(&mut f, size);
+            })
+            .unwrap();
+        terminal.backend().buffer().clone()
+    };
+
+    assert_eq!(
+        render(Alignment::Left),
+        Buffer::with_lines(vec![
+            "┌──────────────────┐",
+            "│The library is    │",
+            "│based on the      │",
+            "│principle of      │",
+            "│immediate         │",
+            "│rendering with    │",
+            "│intermediate      │",
+            "│buffers. This     │",
+            "│means that at each│",
+            "└──────────────────┘",
+        ])
+    );
+    assert_eq!(
+        render(Alignment::Right),
+        Buffer::with_lines(vec![
+            "┌──────────────────┐",
+            "│    The library is│",
+            "│      based on the│",
+            "│      principle of│",
+            "│         immediate│",
+            "│    rendering with│",
+            "│      intermediate│",
+            "│     buffers. This│",
+            "│means that at each│",
+            "└──────────────────┘",
+        ])
+    );
+    assert_eq!(
+        render(Alignment::Center),
+        Buffer::with_lines(vec![
+            "┌──────────────────┐",
+            "│  The library is  │",
+            "│   based on the   │",
+            "│   principle of   │",
+            "│     immediate    │",
+            "│  rendering with  │",
+            "│   intermediate   │",
+            "│   buffers. This  │",
+            "│means that at each│",
+            "└──────────────────┘",
+        ])
+    );
+}
+
+#[test]
+fn paragraph_render_double_width() {
+    let backend = TestBackend::new(10, 10);
+    let mut terminal = Terminal::new(backend).unwrap();
+
+    let s =
+        "コンピュータ上で文字を扱う場合、典型的には文字による通信を行う場合にその両端点では、";
+    terminal
+        .draw(|mut f| {
+            let size = f.size();
+            let text = [Text::raw(s)];
+            Paragraph::new(text.iter())
+                .block(Block::default().borders(Borders::ALL))
+                .wrap(true)
+                .render(&mut f, size);
+        })
+        .unwrap();
+
+    let expected = Buffer::with_lines(vec![
+        "┌────────┐",
+        "│コンピュ│",
+        "│ータ上で│",
+        "│文字を扱│",
+        "│う場合、│",
+        "│典型的に│",
+        "│は文字に│",
+        "│よる通信│",
+        "│を行う場│",
+        "└────────┘",
+    ]);
+    assert_eq!(&expected, terminal.backend().buffer());
+}
+
+#[test]
+fn paragraph_render_mixed_width() {
+    let backend = TestBackend::new(10, 7);
+    let mut terminal = Terminal::new(backend).unwrap();
+
+    let s = "aコンピュータ上で文字を扱う場合、";
+    terminal
+        .draw(|mut f| {
+            let size = f.size();
+            let text = [Text::raw(s)];
+            Paragraph::new(text.iter())
+                .block(Block::default().borders(Borders::ALL))
+                .wrap(true)
+                .render(&mut f, size);
+        })
+        .unwrap();
+
+    let expected = Buffer::with_lines(vec![
+        // The internal width is 8 so only 4 slots for double-width characters.
+        "┌────────┐",
+        "│aコンピ │", // Here we have 1 latin character so only 3 double-width ones can fit.
+        "│ュータ上│",
+        "│で文字を│",
+        "│扱う場合│",
+        "│、      │",
+        "└────────┘",
+    ]);
+    assert_eq!(&expected, terminal.backend().buffer());
+}

tests/size.rs

@@ -0,0 +1,11 @@
+use tui::backend::{Backend, TestBackend};
+use tui::Terminal;
+
+#[test]
+fn buffer_size_limited() {
+    let backend = TestBackend::new(400, 400);
+    let terminal = Terminal::new(backend).unwrap();
+    let size = terminal.backend().size().unwrap();
+    assert_eq!(size.width, 255);
+    assert_eq!(size.height, 255);
+}