feat(text): add a way to wrap text without Paragraph

It reduces the amount of dependencies, among other improvements.

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,30 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: bug
+assignees: ''
+
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**To Reproduce**
+If possible include a code sample exhibiting the problem.
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Screenshots**
+If applicable, add screenshots to help explain your problem.
+
+**Desktop (please complete the following information):**
+ - OS: [e.g. Linux,Windows]
+ - Terminal Emulator [e.g xterm, Konsole, Terminal, iTerm2, ConEmu]
+ - Font [e.g Inconsolata, Monospace]
+ - Crate version [e.g. 0.7]
+ - Backend [e.g termion, crossterm]
+
+**Additional context**
+Add any other context about the problem here.

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,20 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: ''
+labels: enhancement
+assignees: ''
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.

.github/workflows/ci.yml

@@ -0,0 +1,81 @@
+on: [push, pull_request]
+
+name: CI
+
+jobs:
+  linux:
+    name: Linux
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        rust: ["1.44.0", "stable"]
+    steps:
+      - name: "Install dependencies"
+        run: sudo apt-get install libncurses5-dev
+      - uses: actions/checkout@v1
+      - uses: actions-rs/toolchain@v1
+        with:
+          profile: default
+          toolchain: ${{ matrix.rust }}
+          override: true
+      - name: "Format"
+        uses: actions-rs/cargo@v1
+        with:
+          command: fmt
+          args: --all -- --check
+      - name: "Check"
+        uses: actions-rs/cargo@v1
+        with:
+          command: check
+          args: --examples
+      - name: "Check (crossterm)"
+        uses: actions-rs/cargo@v1
+        with:
+          command: check
+          args: --no-default-features --features=crossterm --example crossterm_demo
+      - name: "Check (rustbox)"
+        uses: actions-rs/cargo@v1
+        with:
+          command: test
+          args: --no-default-features --features=rustbox --example rustbox_demo
+      - name: "Check (curses)"
+        uses: actions-rs/cargo@v1
+        with:
+          command: check
+          args: --no-default-features --features=curses --example curses_demo
+      - name: "Test"
+        uses: actions-rs/cargo@v1
+        with:
+          command: test
+        env:
+          RUST_BACKTRACE: full
+      - name: "Clippy"
+        uses: actions-rs/cargo@v1
+        with:
+          command: clippy
+          args: --all-targets --all-features -- -D warnings
+  windows:
+    name: Windows
+    runs-on: windows-latest
+    strategy:
+      matrix:
+        rust: ["1.44.0", "stable"]
+    steps:
+      - uses: actions/checkout@v1
+      - uses: actions-rs/toolchain@v1
+        with:
+          profile: default
+          toolchain: ${{ matrix.rust }}
+          override: true
+      - name: "Check (crossterm)"
+        uses: actions-rs/cargo@v1
+        with:
+          command: check
+          args: --no-default-features --features=crossterm --example crossterm_demo
+      - name: "Test (crossterm)"
+        uses: actions-rs/cargo@v1
+        with:
+          command: test
+          args: --no-default-features --features=crossterm --tests --examples
+        env:
+          RUST_BACKTRACE: full

.gitignore

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

.travis.yml

@@ -1,21 +0,0 @@
-language: rust
-
-rust:
-  - stable
-  - beta
-  - nightly
-
-cache: cargo
-
-matrix:
-  fast_finish: true
-  allow_failures:
-    - rust: nightly
-
-before_script:
-  - rustup component add rustfmt-preview
-
-script:
-  - if [ "$TRAVIS_RUST_VERSION" == "stable" ]; then make fmt; fi
-  - make build
-  - make test

CHANGELOG.md

@@ -2,9 +2,510 @@
 
 ## To be released
 
-## v0.3.1-beta.1 - 2018-09-08
+## v0.12.0 - 2020-09-27
 
-### Changed
+### Features
+
+* Make it easier to work with string with multiple lines in `Text` (#361).
+
+### Fixes
+
+* Fix a style leak in `Graph` so components drawn on top of the plotted data (i.e legend and axis
+titles) are not affected by the style of the `Dataset`s (#388).
+* Make sure `BarChart` shows bars with the max height only when the plotted data is actually equal
+to the max (#383).
+
+## v0.11.0 - 2020-09-20
+
+### Features
+
+* Add the dot character as a new type of canvas marker (#350).
+* Support more style modifiers on Windows (#368).
+
+### Fixes
+
+* Clearing the terminal through `Terminal::clear` will cause the whole UI to be redrawn (#380).
+* Fix incorrect output when the first diff to draw is on the second cell of the terminal (#347).
+
+## v0.10.0 - 2020-07-17
+
+### Breaking changes
+
+#### Easier cursor management
+
+A new method has been added to `Frame` called `set_cursor`. It lets you specify where the cursor
+should be placed after the draw call. Furthermore like any other widgets, if you do not set a cursor
+position during a draw call, the cursor is automatically hidden.
+
+For example:
+
+```rust
+fn draw_input(f: &mut Frame, app: &App) {
+  if app.editing {
+    let input_width = app.input.width() as u16;
+    // The cursor will be placed just after the last character of the input
+    f.set_cursor((input_width + 1, 0));
+  } else {
+    // We are no longer editing, the cursor does not have to be shown, set_cursor is not called and
+    // thus automatically hidden.
+  }
+}
+```
+
+In order to make this possible, the draw closure takes in input `&mut Frame` instead of `mut Frame`.
+
+#### Advanced text styling
+
+It has been reported several times that the text styling capabilities were somewhat limited in many
+places of the crate. To solve the issue, this release includes a new set of text primitives that are
+now used by a majority of widgets to provide flexible text styling.
+
+`Text` is replaced by the following types:
+- `Span`: a string with a unique style.
+- `Spans`: a string with multiple styles.
+- `Text`: a multi-lines string with multiple styles.
+
+However, you do not always need this complexity so the crate provides `From` implementations to
+let you use simple strings as a default and switch to the previous primitives when you need
+additional styling capabilities.
+
+For example, the title of a `Block` can be set in the following ways:
+
+```rust
+// A title with no styling
+Block::default().title("My title");
+// A yellow title
+Block::default().title(Span::styled("My title", Style::default().fg(Color::Yellow)));
+// A title where "My" is bold and "title" is a simple string
+Block::default().title(vec![
+    Span::styled("My", Style::default().add_modifier(Modifier::BOLD)),
+    Span::from("title")
+]);
+```
+
+- `Buffer::set_spans` and `Buffer::set_span` were added.
+- `Paragraph::new` expects an input that can be converted to a `Text`.
+- `Block::title_style` is deprecated.
+- `Block::title` expects a `Spans`.
+- `Tabs` expects a list of `Spans`.
+- `Gauge` custom label is now a `Span`.
+- `Axis` title and labels are `Spans` (as a consequence `Chart` no longer has generic bounds).
+
+#### Incremental styling
+
+Previously `Style` was used to represent an exhaustive set of style rules to be applied to an UI
+element. It implied that whenever you wanted to change even only one property you had to provide the
+complete style. For example, if you had a `Block` where you wanted to have a green background and
+a title in bold, you had to do the following:
+
+```rust
+let style = Style::default().bg(Color::Green);
+Block::default()
+  .style(style)
+  .title("My title")
+  // Here we reused the style otherwise the background color would have been reset
+  .title_style(style.modifier(Modifier::BOLD));
+```
+
+In this new release, you may now write this as:
+
+```rust
+Block::default()
+    .style(Style::default().bg(Color::Green))
+    // The style is not overidden anymore, we simply add new style rule for the title.
+    .title(Span::styled("My title", Style::default().add_modifier(Modifier::BOLD)))
+```
+
+In addition, the crate now provides a method `patch` to combine two styles into a new set of style
+rules:
+
+```rust
+let style = Style::default().modifer(Modifier::BOLD);
+let style = style.patch(Style::default().add_modifier(Modifier::ITALIC));
+// style.modifer == Modifier::BOLD | Modifier::ITALIC, the modifier has been enriched not overidden
+```
+
+- `Style::modifier` has been removed in favor of `Style::add_modifier` and `Style::remove_modifier`.
+- `Buffer::set_style` has been added. `Buffer::set_background` is deprecated.
+- `BarChart::style` no longer set the style of the bars. Use `BarChart::bar_style` in replacement.
+- `Gauge::style` no longer set the style of the gauge. Use `Gauge::gauge_style` in replacement.
+
+#### List with item on multiple lines
+
+The `List` widget has been refactored once again to support items with variable heights and complex
+styling.
+
+- `List::new` expects an input that can be converted to a `Vec<ListItem>` where `ListItem` is a
+wrapper around the item content to provide additional styling capabilities. `ListItem` contains a
+`Text`.
+- `List::items` has been removed.
+
+```rust
+// Before
+let items = vec![
+  "Item1",
+  "Item2",
+  "Item3"
+];
+List::default().items(items.iters());
+
+// After
+let items = vec![
+  ListItem::new("Item1"),
+  ListItem::new("Item2"),
+  ListItem::new("Item3"),
+];
+List::new(items);
+```
+
+See the examples for more advanced usages.
+
+#### More wrapping options
+
+`Paragraph::wrap` expects `Wrap` instead of `bool` to let users decided whether they want to trim
+whitespaces when the text is wrapped.
+
+```rust
+// before
+Paragraph::new(text).wrap(true)
+// after
+Paragraph::new(text).wrap(Wrap { trim: true }) // to have the same behavior
+Paragraph::new(text).wrap(Wrap { trim: false }) // to use the new behavior
+```
+
+#### Horizontal scrolling in paragraph
+
+You can now scroll horizontally in `Paragraph`. The argument of `Paragraph::scroll` has thus be
+changed from `u16` to `(u16, u16)`.
+
+### Features
+
+#### Serialization of style
+
+You can now serialize and de-serialize `Style` using the optional `serde` feature.
+
+## v0.9.5 - 2020-05-21
+
+### Bug Fixes
+
+* Fix out of bounds panic in `widgets::Tabs` when the widget is rendered on
+small areas.
+
+## v0.9.4 - 2020-05-12
+
+### Bug Fixes
+
+* Ignore zero-width graphemes in `Buffer::set_stringn`.
+
+## v0.9.3 - 2020-05-11
+
+### Bug Fixes
+
+* Fix usize overflows in `widgets::Chart` when a dataset is empty.
+
+## v0.9.2 - 2020-05-10
+
+### Bug Fixes
+
+* Fix usize overflows in `widgets::canvas::Line` drawing algorithm.
+
+## v0.9.1 - 2020-04-16
+
+### Bug Fixes
+
+* The `List` widget now takes into account the width of the `highlight_symbol`
+when calculating the total width of its items. It prevents items to overflow
+outside of the widget area.
+
+## v0.9.0 - 2020-04-14
+
+### Features
+
+* Introduce stateful widgets, i.e widgets that can take advantage of keeping
+some state around between two draw calls (#210 goes a bit more into the
+details).
+* Allow a `Table` row to be selected.
+```rust
+// State initialization
+let mut state = TableState::default();
+
+// In the terminal.draw closure
+let header = ["Col1", "Col2", "Col"];
+let rows = [
+  Row::Data(["Row11", "Row12", "Row13"].into_iter())
+];
+let table = Table::new(header.into_iter(), rows.into_iter());
+f.render_stateful_widget(table, area, &mut state);
+
+// In response to some event:
+state.select(Some(1));
+```
+* Add a way to choose the type of border used to draw a block. You can now
+choose from plain, rounded, double and thick lines.
+* Add a `graph_type` property on the `Dataset` of a `Chart` widget. By
+default it will be `Scatter` where the points are drawn as is. An other
+option is `Line` where a line will be draw between each consecutive points
+of the dataset.
+* Style methods are now const, allowing you to initialize const `Style`
+objects.
+* Improve control over whether the legend in the `Chart` widget is shown or
+not. You can now set custom constraints using
+`Chart::hidden_legend_constraints`.
+* Add `Table::header_gap` to add some space between the header and the first
+row.
+* Remove `log` from the dependencies
+* Add a way to use a restricted set of unicode symbols in several widgets to
+improve portability in exchange of a degraded output. (see `BarChart::bar_set`,
+`Sparkline::bar_set` and `Canvas::marker`). You can check how the
+`--enhanced-graphics` flag is used in the demos.
+
+### Breaking Changes
+
+* `Widget::render` has been deleted. You should now use `Frame::render_widget`
+to render a widget on the corresponding `Frame`. This makes the `Widget`
+implementation totally decoupled from the `Frame`.
+```rust
+// Before
+Block::default().render(&mut f, size);
+
+// After
+let block = Block::default();
+f.render_widget(block, size);
+```
+* `Widget::draw` has been renamed to `Widget::render` and the signature has
+been updated to reflect that widgets are consumable objects. Thus the method
+takes `self` instead of `&mut self`.
+```rust
+// Before
+impl Widget for MyWidget {
+  fn draw(&mut self, area: Rect, buf: &mut Buffer) {
+  }
+}
+
+/// After
+impl Widget for MyWidget {
+  fn render(self, arera: Rect, buf: &mut Buffer) {
+  }
+}
+```
+* `Widget::background` has been replaced by `Buffer::set_background`
+```rust
+// Before
+impl Widget for MyWidget {
+  fn render(self, arera: Rect, buf: &mut Buffer) {
+    self.background(area, buf, self.style.bg);
+  }
+}
+
+// After
+impl Widget for MyWidget {
+  fn render(self, arera: Rect, buf: &mut Buffer) {
+    buf.set_background(area, self.style.bg);
+  }
+}
+```
+* Update the `Shape` trait for objects that can be draw on a `Canvas` widgets.
+Instead of returning an iterator over its points, a `Shape` is given a
+`Painter` object that provides a `paint` as well as a `get_point` method. This
+gives the `Shape` more information about the surface it will be drawn to. In
+particular, this change allows the `Line` shape to use a more precise and
+efficient drawing algorithm (Bresenham's line algorithm).
+* `SelectableList` has been deleted. You can now take advantage of the
+associated `ListState` of the `List` widget to select an item.
+```rust
+// Before
+List::new(&["Item1", "Item2", "Item3"])
+  .select(Some(1))
+  .render(&mut f, area);
+
+// After
+
+// State initialization
+let mut state = ListState::default();
+
+// In the terminal.draw closure
+let list = List::new(&["Item1", "Item2", "Item3"]);
+f.render_stateful_widget(list, area, &mut state);
+
+// In response to some events
+state.select(Some(1));
+```
+* `widgets::Marker` has been moved to `symbols::Marker`
+
+## v0.8.0 - 2019-12-15
+
+### Breaking Changes
+
+* Bump crossterm to 0.14.
+* Add cross symbol to the symbols list.
+
+### Bug Fixes
+
+* Use the value of `title_style` to style the title of `Axis`.
+
+## v0.7.0 - 2019-11-29
+
+### Breaking Changes
+
+* Use `Constraint` instead of integers to specify the widths of the `Table`
+widget's columns. This will allow more responsive tables.
+
+```rust
+Table::new(header, row)
+  .widths(&[15, 15, 10])
+  .render(f, chunk);
+```
+
+becomes:
+
+```rust
+Table::new(header, row)
+  .widths(&[
+    Constraint::Length(15),
+    Constraint::Length(15),
+    Constraint::Length(10),
+  ])
+  .render(f, chunk);
+```
+
+* Bump crossterm to 0.13.
+* Use Github Actions for CI (Travis and Azure Pipelines integrations have been deleted).
+
+### Features
+
+* Add support for horizontal and vertical margins in `Layout`.
+
+## v0.6.2 - 2019-07-16
+
+### Features
+
+* `Text` implements PartialEq
+
+### Bug Fixes
+
+* Avoid overflow errors in canvas
+
+## v0.6.1 - 2019-06-16
+
+### Bug Fixes
+
+* Avoid a division by zero when all values in a barchart are equal to 0.
+* Fix the inverted cursor position in the curses backend.
+* Ensure that the correct terminal size is returned when using the crossterm
+backend.
+* Avoid highlighting the separator after the selected item in the Tabs widget.
+
+## v0.6.0 - 2019-05-18
+
+### Breaking Changes
+
+* Update crossterm backend
+
+## v0.5.1 - 2019-04-14
+
+### Bug Fixes
+
+* Fix a panic in the Sparkline widget
+
+## v0.5.0 - 2019-03-10
+
+### Features
+
+* 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.
+
+### Breaking Changes
+
+* 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().add_modifier(Modifier::Italic);
+```
+
+one should use:
+
+```rust
+let style = Style::default().add_modifier(Modifier::ITALIC);
+// or
+let style = Style::default().add_modifier(Modifier::ITALIC | Modifier::BOLD);
+```
+
+### Bug Fixes
+
+* 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
+
+### Features
+
+* 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.
+
+### Breaking Changes
+
+* Upgrade to Rust 2018 edition.
+
+### Bug Fixes
+
+* 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
+
+### Features
+
+* Add experimental test backend
+
+## v0.3.0-beta.3 - 2018-09-24
+
+### Features
+
+* `show_cursor` is called when `Terminal` is dropped if the cursor is hidden.
+
+## v0.3.0-beta.2 - 2018-09-23
+
+### Breaking Changes
+
+* Remove custom `termion` backends. This is motivated by the fact that
+`termion` structs are meant to be combined/wrapped to provide additional
+functionalities to the terminal (e.g AlternateScreen, Mouse support, ...).
+Thus providing exclusive types do not make a lot of sense and give a false
+hint that additional features cannot be used together. The recommended
+approach is now to create your own version of `stdout`:
+
+```rust
+let stdout = io::stdout().into_raw_mode()?;
+let stdout = MouseTerminal::from(stdout);
+let stdout = AlternateScreen::from(stdout);
+```
+
+and then to create the corresponding `termion` backend:
+
+```rust
+let backend = TermionBackend::new(stdout);
+```
+
+The resulting code is more verbose but it works with all combinations of
+additional `termion` features.
+
+## v0.3.0-beta.1 - 2018-09-08
+
+### Breaking Changes
 
 * Replace `Item` by a generic and flexible `Text` that can be used in both
 `Paragraph` and `List` widgets.
@@ -12,11 +513,11 @@
 
 ## v0.3.0-beta.0 - 2018-09-04
 
-### Added
+### Features
 
 * Add a basic `Crossterm` backend
 
-### Changed
+### Breaking Changes
 
 * Remove `Group` and introduce `Layout` in its place
   - `Terminal` is no longer required to compute a layout
@@ -36,24 +537,24 @@ of `Text` items
 
 ## v0.2.3 - 2018-06-09
 
-### Added
+### Features
 
 * Add `start_corner` option for `List`
 * Add more text aligment options for `Paragraph`
 
 ## v0.2.2 - 2018-05-06
 
-### Added
+### Features
 
 * `Terminal` implements `Debug`
 
-### Changed
+### Breaking Changes
 
 * Use `FnOnce` instead of `FnMut` in Group::render
 
 ## v0.2.1 - 2018-04-01
 
-### Added
+### Features
 
 * Add `AlternateScreenBackend` in `termion` backend
 * Add `TermionBackend::with_stdout` in order to let an user of the library
@@ -61,7 +562,7 @@ provides its own termion struct
 * Add tests and documentation for `Buffer::pos_of`
 * Remove leading whitespaces when wrapping text
 
-### Fixed
+### Bug Fixes
 
 * Fix `debug_assert` in `Buffer::pos_of`
 * Pass the style of `SelectableList` to the underlying `List`
@@ -70,21 +571,16 @@ provides its own termion struct
 
 ## v0.2.0 - 2017-12-26
 
-### Added
+### Features
 
 * Add `MouseBackend` in `termion` backend to handle scroll and mouse events
 * Add generic `Item` for items in a `List`
+* Drop `log4rs` as a dev-dependencies in favor of `stderrlog`
 
-### Changed
+### Breaking Changes
 
 * Rename `TermionBackend` to `RawBackend` (to distinguish it from the `MouseBackend`)
 * Generic parameters for `List` to allow passing iterators as items
 * Generic parameters for `Table` to allow using iterators as rows and header
 * Generic parameters for `Tabs`
 * Rename `border` bitflags to `Borders`
-
-* Run latest `rustfmt` on all sources
-
-### Removed
-
-* Drop `log4rs` as a dev-dependencies in favor of `stderrlog`

Cargo.toml

@@ -1,44 +1,126 @@
 [package]
 name = "tui"
-version = "0.3.0-beta.1"
+version = "0.12.0"
 authors = ["Florian Dehau <work@fdehau.com>"]
 description = """
 A library to build rich terminal user interfaces or dashboards
 """
+documentation = "https://docs.rs/tui/0.10.0/tui/"
 keywords = ["tui", "terminal", "dashboard"]
 repository = "https://github.com/fdehau/tui-rs"
 license = "MIT"
-exclude = ["docs/*", ".travis.yml"]
+exclude = ["assets/*", ".github"]
 autoexamples = true
+edition = "2018"
 
 [badges]
-travis-ci = { repository = "fdehau/tui-rs" }
 
 [features]
 default = ["termion"]
+curses = ["easycurses", "pancurses"]
 
 [dependencies]
 bitflags = "1.0"
 cassowary = "0.3"
-itertools = "0.7"
-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.18", optional = true }
+easycurses = { version = "0.12.2", optional = true }
+pancurses = { version = "0.16.1", optional = true, features = ["win32a"] }
+serde = { version = "1", "optional" = true, features = ["derive"]}
 
 [dev-dependencies]
-stderrlog = "0.4"
-rand = "0.4"
+rand = "0.7"
+argh = "0.1"
 
 [[example]]
-name = "rustbox"
-path = "examples/rustbox.rs"
+name = "canvas"
+path = "examples/canvas.rs"
+required-features = ["termion"]
+
+[[example]]
+name = "user_input"
+path = "examples/user_input.rs"
+required-features = ["termion"]
+
+[[example]]
+name = "gauge"
+path = "examples/gauge.rs"
+required-features = ["termion"]
+
+[[example]]
+name = "barchart"
+path = "examples/barchart.rs"
+required-features = ["termion"]
+
+[[example]]
+name = "chart"
+path = "examples/chart.rs"
+required-features = ["termion"]
+
+[[example]]
+name = "paragraph"
+path = "examples/paragraph.rs"
+required-features = ["termion"]
+
+[[example]]
+name = "list"
+path = "examples/list.rs"
+required-features = ["termion"]
+
+[[example]]
+name = "table"
+path = "examples/table.rs"
+required-features = ["termion"]
+
+[[example]]
+name = "tabs"
+path = "examples/tabs.rs"
+required-features = ["termion"]
+
+[[example]]
+name = "custom_widget"
+path = "examples/custom_widget.rs"
+required-features = ["termion"]
+
+[[example]]
+name = "layout"
+path = "examples/layout.rs"
+required-features = ["termion"]
+
+[[example]]
+name = "popup"
+path = "examples/popup.rs"
+required-features = ["termion"]
+
+[[example]]
+name = "block"
+path = "examples/block.rs"
+required-features = ["termion"]
+
+[[example]]
+name = "sparkline"
+path = "examples/sparkline.rs"
+required-features = ["termion"]
+
+[[example]]
+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 ======================================
 
@@ -7,6 +6,7 @@
 RUST_CHANNEL ?= stable
 CARGO_FLAGS =
 RUSTUP_INSTALLED = $(shell command -v rustup 2> /dev/null)
+TEST_FILTER ?=
 
 ifndef RUSTUP_INSTALLED
   CARGO = cargo
@@ -21,7 +21,7 @@ endif
 
 # ================================ Help =======================================
 
-
+.PHONY: help
 help: ## Print all the available commands
 	@grep -E '^[a-zA-Z_-]+:.*?## .*$$' $(MAKEFILE_LIST) | \
 	  awk 'BEGIN {FS = ":.*?## "}; {printf "\033[36m%-20s\033[0m %s\n", $$1, $$2}'
@@ -29,39 +29,57 @@ help: ## Print all the available commands
 
 # =============================== Build =======================================
 
+.PHONY: check
 check: ## Validate the project code
 	$(CARGO) check
 
+.PHONY: build
 build: ## Build the project in debug mode
 	$(CARGO) build $(CARGO_FLAGS)
 
+.PHONY: release
 release: CARGO_FLAGS += --release
 release: build ## Build the project in release mode
 
 
 # ================================ Lint =======================================
 
-RUSTFMT_WRITEMODE ?= 'diff'
-
+.PHONY: lint
 lint: fmt clippy ## Lint project files
 
+.PHONY: fmt
 fmt: ## Check the format of the source code
 	cargo fmt --all -- --check
 
-clippy: RUST_CHANNEL = nightly
+.PHONY: clippy
 clippy: ## Check the style of the source code and catch common errors
-	$(CARGO) clippy --features="termion rustbox"
+	$(CARGO) clippy --all-targets --all-features -- -D warnings
 
 
 # ================================ Test =======================================
 
-
+.PHONY: test
 test: ## Run the tests
-	$(CARGO) test
+	$(CARGO) test --all-features $(TEST_FILTER)
+
+# =============================== Examples ====================================
+
+.PHONY: build-examples
+build-examples: ## Build all examples
+	@$(CARGO) build --release --examples --all-features
+
+.PHONY: run-examples
+run-examples: build-examples ## Run all examples
+	@for file in examples/*.rs; do \
+	  name=$$(basename $${file/.rs/}); \
+	  $(CARGO) run --all-features --release --example $$name; \
+	  done;
 
 # ================================ Doc ========================================
 
 
+.PHONY: doc
+doc: RUST_CHANNEL = nightly
 doc: ## Build the documentation (available at ./target/doc)
 	$(CARGO) doc
 
@@ -70,22 +88,29 @@ doc: ## Build the documentation (available at ./target/doc)
 
 # Requires watchman and watchman-make (https://facebook.github.io/watchman/docs/install.html)
 
+.PHONY: watch
 watch: ## Watch file changes and build the project if any
 	watchman-make -p 'src/**/*.rs' -t check build
 
+.PHONY: watch-test
 watch-test: ## Watch files changes and run the tests if any
 	watchman-make -p 'src/**/*.rs' 'tests/**/*.rs' 'examples/**/*.rs' -t test
 
+.PHONY: watch-doc
+watch-doc: RUST_CHANNEL = nightly
 watch-doc: ## Watch file changes and rebuild the documentation if any
-	watchman-make -p 'src/**/*.rs' -t doc
+	$(CARGO) watch -x doc -x 'test --doc'
 
 # ================================= Pipelines =================================
 
+.PHONY: stable
 stable: RUST_CHANNEL = stable
-stable: build test ## Run build and tests for stable
+stable: build lint test ## Run build and tests for stable
 
+.PHONY: beta
 beta: RUST_CHANNEL = beta
-beta: build test ## Run build and tests for beta
+beta: build lint test ## Run build and tests for beta
 
+.PHONY: nightly
 nightly: RUST_CHANNEL = nightly
 nightly: build lint test ## Run build, lint and tests for nightly

README.md

@@ -1,23 +1,25 @@
 # tui-rs
 
-[![Build Status](https://travis-ci.org/fdehau/tui-rs.svg?branch=master)](https://travis-ci.org/fdehau/tui-rs)
+[![Build Status](https://github.com/fdehau/tui-rs/workflows/CI/badge.svg)](https://github.com/fdehau/tui-rs/actions?query=workflow%3ACI+)
 [![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/)
 
-<img src="./docs/demo.gif" alt="Demo cast under Linux Termite with Inconsolata font 12pt">
+<img src="./assets/demo.gif" alt="Demo cast under Linux Termite with Inconsolata font 12pt">
 
 `tui-rs` is a [Rust](https://www.rust-lang.org) library to build rich terminal
 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/crossterm-rs/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
@@ -30,11 +32,40 @@ comes from the terminal emulator than the library itself.
 Moreover, the library does not provide any input handling nor any event system and
 you may rely on the previously cited libraries to achieve such features.
 
+### Rust version requirements
+
+Since version 0.10.0, `tui` requires **rustc version 1.44.0 or greater**.
+
 ### [Documentation](https://docs.rs/tui)
 
 ### Demo
 
-The [source code](examples/demo.rs) of the demo gif.
+The demo shown in the gif can be run with all available backends
+(`examples/*_demo.rs` files). For example to see the `termion` version one could
+run:
+
+```
+cargo run --example termion_demo --release -- --tick-rate 200
+```
+
+where `tick-rate` is the UI refresh rate in ms.
+
+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).
+
+Beware that the `termion_demo` only works on Unix platforms. If you are a Windows user,
+you can see the same demo using the `crossterm` backend with the following command:
+
+```
+cargo run --example crossterm_demo --no-default-features --features="crossterm" --release -- --tick-rate 200
+```
+
+If the user interface contains glyphs that are not displayed correctly by your terminal, you may want to run
+the demo without those symbols:
+
+```
+cargo run --example crossterm_demo --no-default-features --features="crossterm" --release -- --tick-rate 200 --enhanced-graphics false
+```
 
 ### Widgets
 
@@ -44,7 +75,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,10 +85,29 @@ 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)
 
+### Apps using tui
+
+* [spotify-tui](https://github.com/Rigellute/spotify-tui)
+* [bandwhich](https://github.com/imsnif/bandwhich)
+* [kmon](https://github.com/orhun/kmon)
+* [ytop](https://github.com/cjbassi/ytop)
+* [zenith](https://github.com/bvaisvil/zenith)
+* [bottom](https://github.com/ClementTsang/bottom)
+* [oha](https://github.com/hatoo/oha)
+* [gitui](https://github.com/extrawurst/gitui)
+* [rust-sadari-cli](https://github.com/24seconds/rust-sadari-cli)
+* [desed](https://github.com/SoptikHa2/desed)
+* [diskonaut](https://github.com/imsnif/diskonaut)
+* [tickrs](https://github.com/tarkah/tickrs)
+* [rusty-krab-manager](https://github.com/aryakaul/rusty-krab-manager)
+* [termchat](https://github.com/lemunozm/termchat)
+
 ### Alternatives
 
 You might want to checkout [Cursive](https://github.com/gyscos/Cursive) for an

examples/barchart.rs

@@ -1,29 +1,24 @@
-extern crate termion;
-extern crate tui;
+#[allow(dead_code)]
+mod util;
 
-use std::io;
-use std::sync::mpsc;
-use std::thread;
-use std::time;
-
-use termion::event;
-use termion::input::TermRead;
-
-use tui::backend::MouseBackend;
-use tui::layout::{Constraint, Direction, Layout, Rect};
-use tui::style::{Color, Modifier, Style};
-use tui::widgets::{BarChart, Block, Borders, Widget};
-use tui::Terminal;
+use crate::util::event::{Event, Events};
+use std::{error::Error, io};
+use termion::{event::Key, input::MouseTerminal, raw::IntoRawMode, screen::AlternateScreen};
+use tui::{
+    backend::TermionBackend,
+    layout::{Constraint, Direction, Layout},
+    style::{Color, Modifier, Style},
+    widgets::{BarChart, Block, Borders},
+    Terminal,
+};
 
 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),
@@ -53,112 +48,85 @@ impl<'a> App<'a> {
         }
     }
 
-    fn advance(&mut self) {
+    fn update(&mut self) {
         let value = self.data.pop().unwrap();
         self.data.insert(0, value);
     }
 }
 
-enum Event {
-    Input(event::Key),
-    Tick,
-}
-
-fn main() {
+fn main() -> Result<(), Box<dyn Error>> {
     // Terminal initialization
-    let backend = MouseBackend::new().unwrap();
-    let mut terminal = Terminal::new(backend).unwrap();
+    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)?;
 
-    // Channels
-    let (tx, rx) = mpsc::channel();
-    let input_tx = tx.clone();
-    let clock_tx = tx.clone();
-
-    // Input
-    thread::spawn(move || {
-        let stdin = io::stdin();
-        for c in stdin.keys() {
-            let evt = c.unwrap();
-            input_tx.send(Event::Input(evt)).unwrap();
-            if evt == event::Key::Char('q') {
-                break;
-            }
-        }
-    });
-
-    // Tick
-    thread::spawn(move || loop {
-        clock_tx.send(Event::Tick).unwrap();
-        thread::sleep(time::Duration::from_millis(500));
-    });
+    // Setup event handlers
+    let events = Events::new();
 
     // App
     let mut app = App::new();
 
-    // First draw call
-    terminal.clear().unwrap();
-    terminal.hide_cursor().unwrap();
-    app.size = terminal.size().unwrap();
-    draw(&mut terminal, &app).unwrap();
-
     loop {
-        let size = terminal.size().unwrap();
-        if app.size != size {
-            terminal.resize(size).unwrap();
-            app.size = size;
-        }
+        terminal.draw(|f| {
+            let chunks = Layout::default()
+                .direction(Direction::Vertical)
+                .margin(2)
+                .constraints([Constraint::Percentage(50), Constraint::Percentage(50)].as_ref())
+                .split(f.size());
+            let barchart = BarChart::default()
+                .block(Block::default().title("Data1").borders(Borders::ALL))
+                .data(&app.data)
+                .bar_width(9)
+                .bar_style(Style::default().fg(Color::Yellow))
+                .value_style(Style::default().fg(Color::Black).bg(Color::Yellow));
+            f.render_widget(barchart, chunks[0]);
 
-        let evt = rx.recv().unwrap();
-        match evt {
-            Event::Input(input) => if input == event::Key::Char('q') {
-                break;
-            },
-            Event::Tick => {
-                app.advance();
-            }
-        }
-        draw(&mut terminal, &app).unwrap();
-    }
-
-    terminal.show_cursor().unwrap();
-}
-
-fn draw(t: &mut Terminal<MouseBackend>, app: &App) -> Result<(), io::Error> {
-    t.draw(|mut f| {
-        let chunks = Layout::default()
-            .direction(Direction::Vertical)
-            .margin(2)
-            .constraints([Constraint::Percentage(50), Constraint::Percentage(50)].as_ref())
-            .split(app.size);
-        BarChart::default()
-            .block(Block::default().title("Data1").borders(Borders::ALL))
-            .data(&app.data)
-            .bar_width(9)
-            .style(Style::default().fg(Color::Yellow))
-            .value_style(Style::default().fg(Color::Black).bg(Color::Yellow))
-            .render(&mut f, chunks[0]);
-        {
             let chunks = Layout::default()
                 .direction(Direction::Horizontal)
                 .constraints([Constraint::Percentage(50), Constraint::Percentage(50)].as_ref())
                 .split(chunks[1]);
-            BarChart::default()
+
+            let barchart = BarChart::default()
                 .block(Block::default().title("Data2").borders(Borders::ALL))
                 .data(&app.data)
                 .bar_width(5)
                 .bar_gap(3)
-                .style(Style::default().fg(Color::Green))
-                .value_style(Style::default().bg(Color::Green).modifier(Modifier::Bold))
-                .render(&mut f, chunks[0]);
-            BarChart::default()
+                .bar_style(Style::default().fg(Color::Green))
+                .value_style(
+                    Style::default()
+                        .bg(Color::Green)
+                        .add_modifier(Modifier::BOLD),
+                );
+            f.render_widget(barchart, chunks[0]);
+
+            let barchart = BarChart::default()
                 .block(Block::default().title("Data3").borders(Borders::ALL))
                 .data(&app.data)
-                .style(Style::default().fg(Color::Red))
+                .bar_style(Style::default().fg(Color::Red))
                 .bar_width(7)
                 .bar_gap(0)
                 .value_style(Style::default().bg(Color::Red))
-                .label_style(Style::default().fg(Color::Cyan).modifier(Modifier::Italic))
-                .render(&mut f, chunks[1]);
+                .label_style(
+                    Style::default()
+                        .fg(Color::Cyan)
+                        .add_modifier(Modifier::ITALIC),
+                );
+            f.render_widget(barchart, chunks[1]);
+        })?;
+
+        match events.next()? {
+            Event::Input(input) => {
+                if input == Key::Char('q') {
+                    break;
+                }
+            }
+            Event::Tick => {
+                app.update();
+            }
         }
-    })
+    }
+
+    Ok(())
 }

examples/block.rs

@@ -1,84 +1,86 @@
-extern crate termion;
-extern crate tui;
+#[allow(dead_code)]
+mod util;
 
-use std::io;
-use termion::event;
-use termion::input::TermRead;
+use crate::util::event::{Event, Events};
+use std::{error::Error, io};
+use termion::{event::Key, input::MouseTerminal, raw::IntoRawMode, screen::AlternateScreen};
+use tui::{
+    backend::TermionBackend,
+    layout::{Constraint, Direction, Layout},
+    style::{Color, Modifier, Style},
+    text::Span,
+    widgets::{Block, BorderType, Borders},
+    Terminal,
+};
 
-use tui::backend::MouseBackend;
-use tui::layout::{Constraint, Direction, Layout, Rect};
-use tui::style::{Color, Modifier, Style};
-use tui::widgets::{Block, Borders, Widget};
-use tui::Terminal;
+fn main() -> Result<(), Box<dyn Error>> {
+    // Terminal initialization
+    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)?;
 
-fn main() {
-    let mut terminal = Terminal::new(MouseBackend::new().unwrap()).unwrap();
-    let stdin = io::stdin();
-    terminal.clear().unwrap();
-    terminal.hide_cursor().unwrap();
+    // Setup event handlers
+    let events = Events::new();
 
-    let mut term_size = terminal.size().unwrap();
-    draw(&mut terminal, term_size).unwrap();
-    for c in stdin.keys() {
-        let size = terminal.size().unwrap();
-        if term_size != size {
-            terminal.resize(size).unwrap();
-            term_size = size;
-        }
-        draw(&mut terminal, term_size).unwrap();
-        let evt = c.unwrap();
-        if evt == event::Key::Char('q') {
-            break;
-        }
-    }
-    terminal.show_cursor().unwrap();
-}
-
-fn draw(t: &mut Terminal<MouseBackend>, size: Rect) -> Result<(), io::Error> {
-    t.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
-        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(size);
-        {
+    loop {
+        terminal.draw(|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();
+            let block = Block::default()
+                .borders(Borders::ALL)
+                .title("Main block with round corners")
+                .border_type(BorderType::Rounded);
+            f.render_widget(block, size);
             let chunks = Layout::default()
+                .direction(Direction::Vertical)
+                .margin(4)
+                .constraints([Constraint::Percentage(50), Constraint::Percentage(50)].as_ref())
+                .split(f.size());
+
+            let top_chunks = Layout::default()
                 .direction(Direction::Horizontal)
                 .constraints([Constraint::Percentage(50), Constraint::Percentage(50)].as_ref())
                 .split(chunks[0]);
-            Block::default()
-                .title("With background")
-                .title_style(Style::default().fg(Color::Yellow))
-                .style(Style::default().bg(Color::Green))
-                .render(&mut f, chunks[0]);
-            Block::default()
-                .title("Styled title")
-                .title_style(
-                    Style::default()
-                        .fg(Color::White)
-                        .bg(Color::Red)
-                        .modifier(Modifier::Bold),
-                )
-                .render(&mut f, chunks[1]);
-        }
-        {
-            let chunks = Layout::default()
+            let block = Block::default()
+                .title(vec![
+                    Span::styled("With", Style::default().fg(Color::Yellow)),
+                    Span::from(" background"),
+                ])
+                .style(Style::default().bg(Color::Green));
+            f.render_widget(block, top_chunks[0]);
+
+            let block = Block::default().title(Span::styled(
+                "Styled title",
+                Style::default()
+                    .fg(Color::White)
+                    .bg(Color::Red)
+                    .add_modifier(Modifier::BOLD),
+            ));
+            f.render_widget(block, top_chunks[1]);
+
+            let bottom_chunks = Layout::default()
                 .direction(Direction::Horizontal)
                 .constraints([Constraint::Percentage(50), Constraint::Percentage(50)].as_ref())
                 .split(chunks[1]);
-            Block::default()
-                .title("With borders")
-                .borders(Borders::ALL)
-                .render(&mut f, chunks[0]);
-            Block::default()
-                .title("With styled borders")
+            let block = Block::default().title("With borders").borders(Borders::ALL);
+            f.render_widget(block, bottom_chunks[0]);
+            let block = Block::default()
+                .title("With styled borders and doubled borders")
                 .border_style(Style::default().fg(Color::Cyan))
                 .borders(Borders::LEFT | Borders::RIGHT)
-                .render(&mut f, chunks[1]);
+                .border_type(BorderType::Double);
+            f.render_widget(block, bottom_chunks[1]);
+        })?;
+
+        if let Event::Input(key) = events.next()? {
+            if key == Key::Char('q') {
+                break;
+            }
         }
-    })
+    }
+    Ok(())
 }

examples/canvas.rs

@@ -1,29 +1,27 @@
-extern crate termion;
-extern crate tui;
+#[allow(dead_code)]
+mod util;
 
-use std::io;
-use std::sync::mpsc;
-use std::thread;
-use std::time;
-
-use termion::event;
-use termion::input::TermRead;
-
-use tui::backend::MouseBackend;
-use tui::layout::{Constraint, Direction, Layout, Rect};
-use tui::style::Color;
-use tui::widgets::canvas::{Canvas, Line, Map, MapResolution};
-use tui::widgets::{Block, Borders, Widget};
-use tui::Terminal;
+use crate::util::event::{Config, Event, Events};
+use std::{error::Error, io, time::Duration};
+use termion::{event::Key, input::MouseTerminal, raw::IntoRawMode, screen::AlternateScreen};
+use tui::{
+    backend::TermionBackend,
+    layout::{Constraint, Direction, Layout, Rect},
+    style::Color,
+    widgets::{
+        canvas::{Canvas, Map, MapResolution, Rectangle},
+        Block, Borders,
+    },
+    Terminal,
+};
 
 struct App {
-    size: Rect,
     x: f64,
     y: f64,
-    ball: Rect,
+    ball: Rectangle,
     playground: Rect,
-    vx: u16,
-    vy: u16,
+    vx: f64,
+    vy: f64,
     dir_x: bool,
     dir_y: bool,
 }
@@ -31,24 +29,31 @@ struct App {
 impl App {
     fn new() -> App {
         App {
-            size: Default::default(),
             x: 0.0,
             y: 0.0,
-            ball: Rect::new(10, 30, 10, 10),
+            ball: Rectangle {
+                x: 10.0,
+                y: 30.0,
+                width: 10.0,
+                height: 10.0,
+                color: Color::Yellow,
+            },
             playground: Rect::new(10, 10, 100, 100),
-            vx: 1,
-            vy: 1,
+            vx: 1.0,
+            vy: 1.0,
             dir_x: true,
             dir_y: true,
         }
     }
 
-    fn advance(&mut self) {
-        if self.ball.left() < self.playground.left() || self.ball.right() > self.playground.right()
+    fn update(&mut self) {
+        if self.ball.x < self.playground.left() as f64
+            || self.ball.x + self.ball.width > self.playground.right() as f64
         {
             self.dir_x = !self.dir_x;
         }
-        if self.ball.top() < self.playground.top() || self.ball.bottom() > self.playground.bottom()
+        if self.ball.y < self.playground.top() as f64
+            || self.ball.y + self.ball.height > self.playground.bottom() as f64
         {
             self.dir_y = !self.dir_y;
         }
@@ -67,138 +72,77 @@ impl App {
     }
 }
 
-enum Event {
-    Input(event::Key),
-    Tick,
-}
-
-fn main() {
+fn main() -> Result<(), Box<dyn Error>> {
     // Terminal initialization
-    let backend = MouseBackend::new().unwrap();
-    let mut terminal = Terminal::new(backend).unwrap();
+    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)?;
 
-    // Channels
-    let (tx, rx) = mpsc::channel();
-    let input_tx = tx.clone();
-    let clock_tx = tx.clone();
-
-    // Input
-    thread::spawn(move || {
-        let stdin = io::stdin();
-        for c in stdin.keys() {
-            let evt = c.unwrap();
-            input_tx.send(Event::Input(evt)).unwrap();
-            if evt == event::Key::Char('q') {
-                break;
-            }
-        }
-    });
-
-    // Tick
-    thread::spawn(move || loop {
-        clock_tx.send(Event::Tick).unwrap();
-        thread::sleep(time::Duration::from_millis(500));
-    });
+    // Setup event handlers
+    let config = Config {
+        tick_rate: Duration::from_millis(250),
+        ..Default::default()
+    };
+    let events = Events::with_config(config);
 
     // App
     let mut app = App::new();
 
-    // First draw call
-    terminal.clear().unwrap();
-    terminal.hide_cursor().unwrap();
-    app.size = terminal.size().unwrap();
-    draw(&mut terminal, &app).unwrap();
-
     loop {
-        let size = terminal.size().unwrap();
-        if size != app.size {
-            terminal.resize(size).unwrap();
-            app.size = size;
-        }
+        terminal.draw(|f| {
+            let chunks = Layout::default()
+                .direction(Direction::Horizontal)
+                .constraints([Constraint::Percentage(50), Constraint::Percentage(50)].as_ref())
+                .split(f.size());
+            let canvas = Canvas::default()
+                .block(Block::default().borders(Borders::ALL).title("World"))
+                .paint(|ctx| {
+                    ctx.draw(&Map {
+                        color: Color::White,
+                        resolution: MapResolution::High,
+                    });
+                    ctx.print(app.x, -app.y, "You are here", Color::Yellow);
+                })
+                .x_bounds([-180.0, 180.0])
+                .y_bounds([-90.0, 90.0]);
+            f.render_widget(canvas, chunks[0]);
+            let canvas = Canvas::default()
+                .block(Block::default().borders(Borders::ALL).title("Pong"))
+                .paint(|ctx| {
+                    ctx.draw(&app.ball);
+                })
+                .x_bounds([10.0, 110.0])
+                .y_bounds([10.0, 110.0]);
+            f.render_widget(canvas, chunks[1]);
+        })?;
 
-        let evt = rx.recv().unwrap();
-        match evt {
+        match events.next()? {
             Event::Input(input) => match input {
-                event::Key::Char('q') => {
+                Key::Char('q') => {
                     break;
                 }
-                event::Key::Down => {
+                Key::Down => {
                     app.y += 1.0;
                 }
-                event::Key::Up => {
+                Key::Up => {
                     app.y -= 1.0;
                 }
-                event::Key::Right => {
+                Key::Right => {
                     app.x += 1.0;
                 }
-                event::Key::Left => {
+                Key::Left => {
                     app.x -= 1.0;
                 }
 
                 _ => {}
             },
             Event::Tick => {
-                app.advance();
+                app.update();
             }
         }
-        draw(&mut terminal, &app).unwrap();
     }
 
-    terminal.show_cursor().unwrap();
-}
-
-fn draw(t: &mut Terminal<MouseBackend>, app: &App) -> Result<(), io::Error> {
-    t.draw(|mut f| {
-        let chunks = Layout::default()
-            .direction(Direction::Horizontal)
-            .constraints([Constraint::Percentage(50), Constraint::Percentage(50)].as_ref())
-            .split(app.size);
-        Canvas::default()
-            .block(Block::default().borders(Borders::ALL).title("World"))
-            .paint(|ctx| {
-                ctx.draw(&Map {
-                    color: Color::White,
-                    resolution: MapResolution::High,
-                });
-                ctx.print(app.x, -app.y, "You are here", Color::Yellow);
-            })
-            .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("List"))
-            .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()),
-                    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])
-            .y_bounds([10.0, 110.0])
-            .render(&mut f, chunks[1]);
-    })
+    Ok(())
 }

examples/chart.rs

@@ -1,25 +1,34 @@
-extern crate termion;
-extern crate tui;
-
+#[allow(dead_code)]
 mod util;
-use util::*;
 
-use std::io;
-use std::sync::mpsc;
-use std::thread;
-use std::time;
+use crate::util::{
+    event::{Event, Events},
+    SinSignal,
+};
+use std::{error::Error, io};
+use termion::{event::Key, input::MouseTerminal, raw::IntoRawMode, screen::AlternateScreen};
+use tui::{
+    backend::TermionBackend,
+    layout::{Constraint, Direction, Layout},
+    style::{Color, Modifier, Style},
+    symbols,
+    text::Span,
+    widgets::{Axis, Block, Borders, Chart, Dataset, GraphType},
+    Terminal,
+};
 
-use termion::event;
-use termion::input::TermRead;
-
-use tui::backend::MouseBackend;
-use tui::layout::Rect;
-use tui::style::{Color, Modifier, Style};
-use tui::widgets::{Axis, Block, Borders, Chart, Dataset, Marker, Widget};
-use tui::Terminal;
+const DATA: [(f64, f64); 5] = [(0.0, 0.0), (1.0, 1.0), (2.0, 2.0), (3.0, 3.0), (4.0, 4.0)];
+const DATA2: [(f64, f64); 7] = [
+    (0.0, 0.0),
+    (10.0, 1.0),
+    (20.0, 0.5),
+    (30.0, 1.5),
+    (40.0, 1.0),
+    (50.0, 2.5),
+    (60.0, 3.0),
+];
 
 struct App {
-    size: Rect,
     signal1: SinSignal,
     data1: Vec<(f64, f64)>,
     signal2: SinSignal,
@@ -34,7 +43,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,
@@ -43,7 +51,7 @@ impl App {
         }
     }
 
-    fn advance(&mut self) {
+    fn update(&mut self) {
         for _ in 0..5 {
             self.data1.remove(0);
         }
@@ -57,111 +65,182 @@ impl App {
     }
 }
 
-enum Event {
-    Input(event::Key),
-    Tick,
-}
-
-fn main() {
+fn main() -> Result<(), Box<dyn Error>> {
     // Terminal initialization
-    let backend = MouseBackend::new().unwrap();
-    let mut terminal = Terminal::new(backend).unwrap();
+    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)?;
 
-    // Channels
-    let (tx, rx) = mpsc::channel();
-    let input_tx = tx.clone();
-    let clock_tx = tx.clone();
-
-    // Input
-    thread::spawn(move || {
-        let stdin = io::stdin();
-        for c in stdin.keys() {
-            let evt = c.unwrap();
-            input_tx.send(Event::Input(evt)).unwrap();
-            if evt == event::Key::Char('q') {
-                break;
-            }
-        }
-    });
-
-    // Tick
-    thread::spawn(move || loop {
-        clock_tx.send(Event::Tick).unwrap();
-        thread::sleep(time::Duration::from_millis(500));
-    });
+    let events = Events::new();
 
     // App
     let mut app = App::new();
 
-    // First draw call
-    terminal.clear().unwrap();
-    terminal.hide_cursor().unwrap();
-    app.size = terminal.size().unwrap();
-    draw(&mut terminal, &app).unwrap();
-
     loop {
-        let size = terminal.size().unwrap();
-        if app.size != size {
-            terminal.resize(size).unwrap();
-            app.size = size;
-        }
-
-        let evt = rx.recv().unwrap();
-        match evt {
-            Event::Input(input) => if input == event::Key::Char('q') {
-                break;
-            },
-            Event::Tick => {
-                app.advance();
-            }
-        }
-        draw(&mut terminal, &app).unwrap();
-    }
-
-    terminal.show_cursor().unwrap();
-}
-
-fn draw(t: &mut Terminal<MouseBackend>, app: &App) -> Result<(), io::Error> {
-    t.draw(|mut f| {
-        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(&[
+        terminal.draw(|f| {
+            let size = f.size();
+            let chunks = Layout::default()
+                .direction(Direction::Vertical)
+                .constraints(
+                    [
+                        Constraint::Ratio(1, 3),
+                        Constraint::Ratio(1, 3),
+                        Constraint::Ratio(1, 3),
+                    ]
+                    .as_ref(),
+                )
+                .split(size);
+            let x_labels = vec![
+                Span::styled(
+                    format!("{}", app.window[0]),
+                    Style::default().add_modifier(Modifier::BOLD),
+                ),
+                Span::raw(format!("{}", (app.window[0] + app.window[1]) / 2.0)),
+                Span::styled(
+                    format!("{}", app.window[1]),
+                    Style::default().add_modifier(Modifier::BOLD),
+                ),
+            ];
+            let datasets = vec![
                 Dataset::default()
                     .name("data2")
-                    .marker(Marker::Dot)
+                    .marker(symbols::Marker::Dot)
                     .style(Style::default().fg(Color::Cyan))
                     .data(&app.data1),
                 Dataset::default()
                     .name("data3")
-                    .marker(Marker::Braille)
+                    .marker(symbols::Marker::Braille)
                     .style(Style::default().fg(Color::Yellow))
                     .data(&app.data2),
-            ])
-            .render(&mut f, app.size);
-    })
+            ];
+
+            let chart = Chart::new(datasets)
+                .block(
+                    Block::default()
+                        .title(Span::styled(
+                            "Chart 1",
+                            Style::default()
+                                .fg(Color::Cyan)
+                                .add_modifier(Modifier::BOLD),
+                        ))
+                        .borders(Borders::ALL),
+                )
+                .x_axis(
+                    Axis::default()
+                        .title("X Axis")
+                        .style(Style::default().fg(Color::Gray))
+                        .labels(x_labels)
+                        .bounds(app.window),
+                )
+                .y_axis(
+                    Axis::default()
+                        .title("Y Axis")
+                        .style(Style::default().fg(Color::Gray))
+                        .labels(vec![
+                            Span::styled("-20", Style::default().add_modifier(Modifier::BOLD)),
+                            Span::raw("0"),
+                            Span::styled("20", Style::default().add_modifier(Modifier::BOLD)),
+                        ])
+                        .bounds([-20.0, 20.0]),
+                );
+            f.render_widget(chart, chunks[0]);
+
+            let datasets = vec![Dataset::default()
+                .name("data")
+                .marker(symbols::Marker::Braille)
+                .style(Style::default().fg(Color::Yellow))
+                .graph_type(GraphType::Line)
+                .data(&DATA)];
+            let chart = Chart::new(datasets)
+                .block(
+                    Block::default()
+                        .title(Span::styled(
+                            "Chart 2",
+                            Style::default()
+                                .fg(Color::Cyan)
+                                .add_modifier(Modifier::BOLD),
+                        ))
+                        .borders(Borders::ALL),
+                )
+                .x_axis(
+                    Axis::default()
+                        .title("X Axis")
+                        .style(Style::default().fg(Color::Gray))
+                        .bounds([0.0, 5.0])
+                        .labels(vec![
+                            Span::styled("0", Style::default().add_modifier(Modifier::BOLD)),
+                            Span::raw("2.5"),
+                            Span::styled("5.0", Style::default().add_modifier(Modifier::BOLD)),
+                        ]),
+                )
+                .y_axis(
+                    Axis::default()
+                        .title("Y Axis")
+                        .style(Style::default().fg(Color::Gray))
+                        .bounds([0.0, 5.0])
+                        .labels(vec![
+                            Span::styled("0", Style::default().add_modifier(Modifier::BOLD)),
+                            Span::raw("2.5"),
+                            Span::styled("5.0", Style::default().add_modifier(Modifier::BOLD)),
+                        ]),
+                );
+            f.render_widget(chart, chunks[1]);
+
+            let datasets = vec![Dataset::default()
+                .name("data")
+                .marker(symbols::Marker::Braille)
+                .style(Style::default().fg(Color::Yellow))
+                .graph_type(GraphType::Line)
+                .data(&DATA2)];
+            let chart = Chart::new(datasets)
+                .block(
+                    Block::default()
+                        .title(Span::styled(
+                            "Chart 3",
+                            Style::default()
+                                .fg(Color::Cyan)
+                                .add_modifier(Modifier::BOLD),
+                        ))
+                        .borders(Borders::ALL),
+                )
+                .x_axis(
+                    Axis::default()
+                        .title("X Axis")
+                        .style(Style::default().fg(Color::Gray))
+                        .bounds([0.0, 50.0])
+                        .labels(vec![
+                            Span::styled("0", Style::default().add_modifier(Modifier::BOLD)),
+                            Span::raw("25"),
+                            Span::styled("50", Style::default().add_modifier(Modifier::BOLD)),
+                        ]),
+                )
+                .y_axis(
+                    Axis::default()
+                        .title("Y Axis")
+                        .style(Style::default().fg(Color::Gray))
+                        .bounds([0.0, 5.0])
+                        .labels(vec![
+                            Span::styled("0", Style::default().add_modifier(Modifier::BOLD)),
+                            Span::raw("2.5"),
+                            Span::styled("5", Style::default().add_modifier(Modifier::BOLD)),
+                        ]),
+                );
+            f.render_widget(chart, chunks[2]);
+        })?;
+
+        match events.next()? {
+            Event::Input(input) => {
+                if input == Key::Char('q') {
+                    break;
+                }
+            }
+            Event::Tick => {
+                app.update();
+            }
+        }
+    }
+
+    Ok(())
 }

examples/crossterm.rs

@@ -1,50 +0,0 @@
-extern crate crossterm;
-extern crate tui;
-
-use std::error::Error;
-use std::io;
-
-use tui::backend::CrosstermBackend;
-use tui::layout::{Constraint, Direction, Layout};
-use tui::style::{Color, Modifier, Style};
-use tui::widgets::{Block, Borders, Paragraph, Text, Widget};
-use tui::Terminal;
-
-fn main() {
-    let mut terminal = Terminal::new(CrosstermBackend::new()).unwrap();
-    terminal.clear().unwrap();
-    terminal.hide_cursor().unwrap();
-    draw(&mut terminal).unwrap();
-    loop {
-        {
-            let input = crossterm::input(terminal.backend().screen());
-            match input.read_char() {
-                Ok(c) => if c == 'q' {
-                    break;
-                },
-                Err(e) => panic!("{}", e.description()),
-            };
-        }
-        draw(&mut terminal).unwrap();
-    }
-    terminal.show_cursor().unwrap();
-}
-
-fn draw(t: &mut Terminal<CrosstermBackend>) -> io::Result<()> {
-    let size = t.size()?;
-    t.draw(|mut f| {
-        let text = [
-            Text::Data("It "),
-            Text::StyledData("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);
-    })
-}

examples/crossterm_demo.rs

@@ -0,0 +1,108 @@
+#[allow(dead_code)]
+mod demo;
+#[allow(dead_code)]
+mod util;
+
+use crate::demo::{ui, App};
+use argh::FromArgs;
+use crossterm::{
+    event::{self, DisableMouseCapture, EnableMouseCapture, Event as CEvent, KeyCode},
+    execute,
+    terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
+};
+use std::{
+    error::Error,
+    io::{stdout, Write},
+    sync::mpsc,
+    thread,
+    time::{Duration, Instant},
+};
+use tui::{backend::CrosstermBackend, Terminal};
+
+enum Event<I> {
+    Input(I),
+    Tick,
+}
+
+/// Crossterm demo
+#[derive(Debug, FromArgs)]
+struct Cli {
+    /// time in ms between two ticks.
+    #[argh(option, default = "250")]
+    tick_rate: u64,
+    /// whether unicode symbols are used to improve the overall look of the app
+    #[argh(option, default = "true")]
+    enhanced_graphics: bool,
+}
+
+fn main() -> Result<(), Box<dyn Error>> {
+    let cli: Cli = argh::from_env();
+
+    enable_raw_mode()?;
+
+    let mut stdout = stdout();
+    execute!(stdout, EnterAlternateScreen, EnableMouseCapture)?;
+
+    let backend = CrosstermBackend::new(stdout);
+
+    let mut terminal = Terminal::new(backend)?;
+
+    // Setup input handling
+    let (tx, rx) = mpsc::channel();
+
+    let tick_rate = Duration::from_millis(cli.tick_rate);
+    thread::spawn(move || {
+        let mut last_tick = Instant::now();
+        loop {
+            // poll for tick rate duration, if no events, sent tick event.
+            let timeout = tick_rate
+                .checked_sub(last_tick.elapsed())
+                .unwrap_or_else(|| Duration::from_secs(0));
+            if event::poll(timeout).unwrap() {
+                if let CEvent::Key(key) = event::read().unwrap() {
+                    tx.send(Event::Input(key)).unwrap();
+                }
+            }
+            if last_tick.elapsed() >= tick_rate {
+                tx.send(Event::Tick).unwrap();
+                last_tick = Instant::now();
+            }
+        }
+    });
+
+    let mut app = App::new("Crossterm Demo", cli.enhanced_graphics);
+
+    terminal.clear()?;
+
+    loop {
+        terminal.draw(|f| ui::draw(f, &mut app))?;
+        match rx.recv()? {
+            Event::Input(event) => match event.code {
+                KeyCode::Char('q') => {
+                    disable_raw_mode()?;
+                    execute!(
+                        terminal.backend_mut(),
+                        LeaveAlternateScreen,
+                        DisableMouseCapture
+                    )?;
+                    terminal.show_cursor()?;
+                    break;
+                }
+                KeyCode::Char(c) => app.on_key(c),
+                KeyCode::Left => app.on_left(),
+                KeyCode::Up => app.on_up(),
+                KeyCode::Right => app.on_right(),
+                KeyCode::Down => app.on_down(),
+                _ => {}
+            },
+            Event::Tick => {
+                app.on_tick();
+            }
+        }
+        if app.should_quit {
+            break;
+        }
+    }
+
+    Ok(())
+}

examples/curses_demo.rs

@@ -0,0 +1,74 @@
+mod demo;
+#[allow(dead_code)]
+mod util;
+
+use crate::demo::{ui, App};
+use argh::FromArgs;
+use std::{
+    error::Error,
+    io,
+    time::{Duration, Instant},
+};
+use tui::{backend::CursesBackend, Terminal};
+
+/// Curses demo
+#[derive(Debug, FromArgs)]
+struct Cli {
+    /// time in ms between two ticks.
+    #[argh(option, default = "250")]
+    tick_rate: u64,
+    /// whether unicode symbols are used to improve the overall look of the app
+    #[argh(option, default = "true")]
+    enhanced_graphics: bool,
+}
+
+fn main() -> Result<(), Box<dyn Error>> {
+    let cli: Cli = argh::from_env();
+
+    let mut backend =
+        CursesBackend::new().ok_or_else(|| 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", cli.enhanced_graphics);
+
+    let mut last_tick = Instant::now();
+    let tick_rate = Duration::from_millis(cli.tick_rate);
+    loop {
+        terminal.draw(|f| ui::draw(f, &mut app))?;
+        if let Some(input) = terminal.backend_mut().get_curses_mut().get_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,11 +1,12 @@
-extern crate tui;
+#[allow(dead_code)]
+mod util;
 
-use tui::backend::MouseBackend;
-use tui::buffer::Buffer;
-use tui::layout::Rect;
-use tui::style::Style;
-use tui::widgets::Widget;
-use tui::Terminal;
+use crate::util::event::{Event, Events};
+use std::{error::Error, io};
+use termion::{event::Key, input::MouseTerminal, raw::IntoRawMode, screen::AlternateScreen};
+use tui::{
+    backend::TermionBackend, buffer::Buffer, layout::Rect, style::Style, widgets::Widget, Terminal,
+};
 
 struct Label<'a> {
     text: &'a str,
@@ -18,25 +19,41 @@ impl<'a> Default for Label<'a> {
 }
 
 impl<'a> Widget for Label<'a> {
-    fn draw(&mut self, area: Rect, buf: &mut Buffer) {
+    fn render(self, area: Rect, buf: &mut Buffer) {
         buf.set_string(area.left(), area.top(), self.text, Style::default());
     }
 }
 
 impl<'a> Label<'a> {
-    fn text(&mut self, text: &'a str) -> &mut Label<'a> {
+    fn text(mut self, text: &'a str) -> Label<'a> {
         self.text = text;
         self
     }
 }
 
-fn main() {
-    let mut terminal = Terminal::new(MouseBackend::new().unwrap()).unwrap();
-    let size = terminal.size().unwrap();
-    terminal.clear().unwrap();
-    terminal
-        .draw(|mut f| {
-            Label::default().text("Test").render(&mut f, size);
-        })
-        .unwrap();
+fn main() -> Result<(), Box<dyn Error>> {
+    // Terminal initialization
+    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)?;
+
+    let events = Events::new();
+
+    loop {
+        terminal.draw(|f| {
+            let size = f.size();
+            let label = Label::default().text("Test");
+            f.render_widget(label, size);
+        })?;
+
+        if let Event::Input(key) = events.next()? {
+            if key == Key::Char('q') {
+                break;
+            }
+        }
+    }
+
+    Ok(())
 }

examples/demo.rs

@@ -1,522 +0,0 @@
-#[macro_use]
-extern crate log;
-extern crate stderrlog;
-extern crate termion;
-extern crate tui;
-
-mod util;
-
-use std::io;
-use std::sync::mpsc;
-use std::thread;
-use std::time;
-
-use termion::event;
-use termion::input::TermRead;
-
-use tui::backend::MouseBackend;
-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::*;
-
-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: MyTabs<'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>>,
-}
-
-enum Event {
-    Input(event::Key),
-    Tick,
-}
-
-fn main() {
-    stderrlog::new()
-        .module(module_path!())
-        .verbosity(4)
-        .init()
-        .unwrap();
-    info!("Start");
-
-    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: MyTabs {
-            titles: vec!["Tab0", "Tab1"],
-            selection: 0,
-        },
-        show_chart: true,
-        progress: 0,
-        data: rand_signal.clone().take(300).collect(),
-        data2: sin_signal.clone().take(100).collect(),
-        data3: sin_signal2.clone().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",
-            },
-        ],
-    };
-    let (tx, rx) = mpsc::channel();
-    let input_tx = tx.clone();
-
-    for _ in 0..100 {
-        sin_signal.next();
-    }
-    for _ in 0..200 {
-        sin_signal2.next();
-    }
-
-    thread::spawn(move || {
-        let stdin = io::stdin();
-        for c in stdin.keys() {
-            let evt = c.unwrap();
-            input_tx.send(Event::Input(evt)).unwrap();
-            if evt == event::Key::Char('q') {
-                break;
-            }
-        }
-    });
-
-    thread::spawn(move || {
-        let tx = tx.clone();
-        loop {
-            tx.send(Event::Tick).unwrap();
-            thread::sleep(time::Duration::from_millis(250));
-        }
-    });
-
-    let backend = MouseBackend::new().unwrap();
-    let mut terminal = Terminal::new(backend).unwrap();
-    terminal.clear().unwrap();
-    terminal.hide_cursor().unwrap();
-
-    loop {
-        let size = terminal.size().unwrap();
-        if size != app.size {
-            terminal.resize(size).unwrap();
-            app.size = size;
-        }
-        draw(&mut terminal, &app).unwrap();
-        let evt = rx.recv().unwrap();
-        match evt {
-            Event::Input(input) => match input {
-                event::Key::Char('q') => {
-                    break;
-                }
-                event::Key::Up => {
-                    if app.selected > 0 {
-                        app.selected -= 1
-                    };
-                }
-                event::Key::Down => if app.selected < app.items.len() - 1 {
-                    app.selected += 1;
-                },
-                event::Key::Left => {
-                    app.tabs.previous();
-                }
-                event::Key::Right => {
-                    app.tabs.next();
-                }
-                event::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;
-                }
-            }
-        }
-    }
-    terminal.show_cursor().unwrap();
-    terminal.clear().unwrap();
-}
-
-fn draw(t: &mut Terminal<MouseBackend>, app: &App) -> Result<(), io::Error> {
-    t.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.selection)
-            .render(&mut f, chunks[0]);
-        match app.tabs.selection {
-            0 => {
-                draw_first_tab(&mut f, app, chunks[1]);
-            }
-            1 => {
-                draw_second_tab(&mut f, app, chunks[1]);
-            }
-            _ => {}
-        };
-    })
-}
-
-fn draw_first_tab(f: &mut Frame<MouseBackend>, 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<MouseBackend>, 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<MouseBackend>, 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<MouseBackend>, 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<MouseBackend>, 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);
-    Table::new(
-        ["Server", "Location", "Status"].into_iter(),
-        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)
-        }),
-    ).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,230 @@
+use crate::util::{RandomSignal, SinSignal, StatefulList, TabsState};
+
+const TASKS: [&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: [(&str, &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: [(&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 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: f64,
+    pub sparkline: Signal<RandomSignal>,
+    pub tasks: StatefulList<&'a str>,
+    pub logs: StatefulList<(&'a str, &'a str)>,
+    pub signals: Signals,
+    pub barchart: Vec<(&'a str, u64)>,
+    pub servers: Vec<Server<'a>>,
+    pub enhanced_graphics: bool,
+}
+
+impl<'a> App<'a> {
+    pub fn new(title: &'a str, enhanced_graphics: bool) -> 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.0,
+            sparkline: Signal {
+                source: rand_signal,
+                points: sparkline_points,
+                tick_rate: 1,
+            },
+            tasks: StatefulList::with_items(TASKS.to_vec()),
+            logs: StatefulList::with_items(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",
+                },
+            ],
+            enhanced_graphics,
+        }
+    }
+
+    pub fn on_up(&mut self) {
+        self.tasks.previous();
+    }
+
+    pub fn on_down(&mut self) {
+        self.tasks.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 += 0.001;
+        if self.progress > 1.0 {
+            self.progress = 0.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,373 @@
+use crate::demo::App;
+use tui::{
+    backend::Backend,
+    layout::{Constraint, Direction, Layout, Rect},
+    style::{Color, Modifier, Style},
+    symbols,
+    text::{Span, Spans},
+    widgets::canvas::{Canvas, Line, Map, MapResolution, Rectangle},
+    widgets::{
+        Axis, BarChart, Block, Borders, Chart, Dataset, Gauge, LineGauge, List, ListItem,
+        Paragraph, Row, Sparkline, Table, Tabs, Wrap,
+    },
+    Frame,
+};
+
+pub fn draw<B: Backend>(f: &mut Frame<B>, app: &mut App) {
+    let chunks = Layout::default()
+        .constraints([Constraint::Length(3), Constraint::Min(0)].as_ref())
+        .split(f.size());
+    let titles = app
+        .tabs
+        .titles
+        .iter()
+        .map(|t| Spans::from(Span::styled(*t, Style::default().fg(Color::Green))))
+        .collect();
+    let tabs = Tabs::new(titles)
+        .block(Block::default().borders(Borders::ALL).title(app.title))
+        .highlight_style(Style::default().fg(Color::Yellow))
+        .select(app.tabs.index);
+    f.render_widget(tabs, chunks[0]);
+    match app.tabs.index {
+        0 => draw_first_tab(f, app, chunks[1]),
+        1 => draw_second_tab(f, app, chunks[1]),
+        _ => {}
+    };
+}
+
+fn draw_first_tab<B>(f: &mut Frame<B>, app: &mut App, area: Rect)
+where
+    B: Backend,
+{
+    let chunks = Layout::default()
+        .constraints(
+            [
+                Constraint::Length(9),
+                Constraint::Min(8),
+                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: &mut App, area: Rect)
+where
+    B: Backend,
+{
+    let chunks = Layout::default()
+        .constraints(
+            [
+                Constraint::Length(2),
+                Constraint::Length(3),
+                Constraint::Length(1),
+            ]
+            .as_ref(),
+        )
+        .margin(1)
+        .split(area);
+    let block = Block::default().borders(Borders::ALL).title("Graphs");
+    f.render_widget(block, area);
+
+    let label = format!("{:.2}%", app.progress * 100.0);
+    let gauge = Gauge::default()
+        .block(Block::default().title("Gauge:"))
+        .gauge_style(
+            Style::default()
+                .fg(Color::Magenta)
+                .bg(Color::Black)
+                .add_modifier(Modifier::ITALIC | Modifier::BOLD),
+        )
+        .label(label)
+        .ratio(app.progress);
+    f.render_widget(gauge, chunks[0]);
+
+    let sparkline = Sparkline::default()
+        .block(Block::default().title("Sparkline:"))
+        .style(Style::default().fg(Color::Green))
+        .data(&app.sparkline.points)
+        .bar_set(if app.enhanced_graphics {
+            symbols::bar::NINE_LEVELS
+        } else {
+            symbols::bar::THREE_LEVELS
+        });
+    f.render_widget(sparkline, chunks[1]);
+
+    let line_gauge = LineGauge::default()
+        .block(Block::default().title("LineGauge:"))
+        .gauge_style(Style::default().fg(Color::Magenta))
+        .line_set(if app.enhanced_graphics {
+            symbols::line::THICK
+        } else {
+            symbols::line::NORMAL
+        })
+        .ratio(app.progress);
+    f.render_widget(line_gauge, chunks[2]);
+}
+
+fn draw_charts<B>(f: &mut Frame<B>, app: &mut 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]);
+
+            // Draw tasks
+            let tasks: Vec<ListItem> = app
+                .tasks
+                .items
+                .iter()
+                .map(|i| ListItem::new(vec![Spans::from(Span::raw(*i))]))
+                .collect();
+            let tasks = List::new(tasks)
+                .block(Block::default().borders(Borders::ALL).title("List"))
+                .highlight_style(Style::default().add_modifier(Modifier::BOLD))
+                .highlight_symbol("> ");
+            f.render_stateful_widget(tasks, chunks[0], &mut app.tasks.state);
+
+            // Draw logs
+            let info_style = Style::default().fg(Color::Blue);
+            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 logs: Vec<ListItem> = app
+                .logs
+                .items
+                .iter()
+                .map(|&(evt, level)| {
+                    let s = match level {
+                        "ERROR" => error_style,
+                        "CRITICAL" => critical_style,
+                        "WARNING" => warning_style,
+                        _ => info_style,
+                    };
+                    let content = vec![Spans::from(vec![
+                        Span::styled(format!("{:<9}", level), s),
+                        Span::raw(evt),
+                    ])];
+                    ListItem::new(content)
+                })
+                .collect();
+            let logs = List::new(logs).block(Block::default().borders(Borders::ALL).title("List"));
+            f.render_stateful_widget(logs, chunks[1], &mut app.logs.state);
+        }
+
+        let barchart = BarChart::default()
+            .block(Block::default().borders(Borders::ALL).title("Bar chart"))
+            .data(&app.barchart)
+            .bar_width(3)
+            .bar_gap(2)
+            .bar_set(if app.enhanced_graphics {
+                symbols::bar::NINE_LEVELS
+            } else {
+                symbols::bar::THREE_LEVELS
+            })
+            .value_style(
+                Style::default()
+                    .fg(Color::Black)
+                    .bg(Color::Green)
+                    .add_modifier(Modifier::ITALIC),
+            )
+            .label_style(Style::default().fg(Color::Yellow))
+            .bar_style(Style::default().fg(Color::Green));
+        f.render_widget(barchart, chunks[1]);
+    }
+    if app.show_chart {
+        let x_labels = vec![
+            Span::styled(
+                format!("{}", app.signals.window[0]),
+                Style::default().add_modifier(Modifier::BOLD),
+            ),
+            Span::raw(format!(
+                "{}",
+                (app.signals.window[0] + app.signals.window[1]) / 2.0
+            )),
+            Span::styled(
+                format!("{}", app.signals.window[1]),
+                Style::default().add_modifier(Modifier::BOLD),
+            ),
+        ];
+        let datasets = vec![
+            Dataset::default()
+                .name("data2")
+                .marker(symbols::Marker::Dot)
+                .style(Style::default().fg(Color::Cyan))
+                .data(&app.signals.sin1.points),
+            Dataset::default()
+                .name("data3")
+                .marker(if app.enhanced_graphics {
+                    symbols::Marker::Braille
+                } else {
+                    symbols::Marker::Dot
+                })
+                .style(Style::default().fg(Color::Yellow))
+                .data(&app.signals.sin2.points),
+        ];
+        let chart = Chart::new(datasets)
+            .block(
+                Block::default()
+                    .title(Span::styled(
+                        "Chart",
+                        Style::default()
+                            .fg(Color::Cyan)
+                            .add_modifier(Modifier::BOLD),
+                    ))
+                    .borders(Borders::ALL),
+            )
+            .x_axis(
+                Axis::default()
+                    .title("X Axis")
+                    .style(Style::default().fg(Color::Gray))
+                    .bounds(app.signals.window)
+                    .labels(x_labels),
+            )
+            .y_axis(
+                Axis::default()
+                    .title("Y Axis")
+                    .style(Style::default().fg(Color::Gray))
+                    .bounds([-20.0, 20.0])
+                    .labels(vec![
+                        Span::styled("-20", Style::default().add_modifier(Modifier::BOLD)),
+                        Span::raw("0"),
+                        Span::styled("20", Style::default().add_modifier(Modifier::BOLD)),
+                    ]),
+            );
+        f.render_widget(chart, chunks[1]);
+    }
+}
+
+fn draw_text<B>(f: &mut Frame<B>, area: Rect)
+where
+    B: Backend,
+{
+    let text = vec![
+        Spans::from("This is a paragraph with several lines. You can change style your text the way you want"),
+        Spans::from(""),
+        Spans::from(vec![
+            Span::from("For example: "),
+            Span::styled("under", Style::default().fg(Color::Red)),
+            Span::raw(" "),
+            Span::styled("the", Style::default().fg(Color::Green)),
+            Span::raw(" "),
+            Span::styled("rainbow", Style::default().fg(Color::Blue)),
+            Span::raw("."),
+        ]),
+        Spans::from(vec![
+            Span::raw("Oh and if you didn't "),
+            Span::styled("notice", Style::default().add_modifier(Modifier::ITALIC)),
+            Span::raw(" you can "),
+            Span::styled("automatically", Style::default().add_modifier(Modifier::BOLD)),
+            Span::raw(" "),
+            Span::styled("wrap", Style::default().add_modifier(Modifier::REVERSED)),
+            Span::raw(" your "),
+            Span::styled("text", Style::default().add_modifier(Modifier::UNDERLINED)),
+            Span::raw(".")
+        ]),
+        Spans::from(
+            "One more thing is that it should display unicode characters: 10€"
+        ),
+    ];
+    let block = Block::default().borders(Borders::ALL).title(Span::styled(
+        "Footer",
+        Style::default()
+            .fg(Color::Magenta)
+            .add_modifier(Modifier::BOLD),
+    ));
+    let paragraph = Paragraph::new(text).block(block).wrap(Wrap { trim: true });
+    f.render_widget(paragraph, area);
+}
+
+fn draw_second_tab<B>(f: &mut Frame<B>, app: &mut 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)
+        .add_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)
+    });
+    let table = Table::new(header.iter(), rows)
+        .block(Block::default().title("Servers").borders(Borders::ALL))
+        .header_style(Style::default().fg(Color::Yellow))
+        .widths(&[
+            Constraint::Length(15),
+            Constraint::Length(15),
+            Constraint::Length(10),
+        ]);
+    f.render_widget(table, chunks[0]);
+
+    let map = 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 {
+                x: 0.0,
+                y: 30.0,
+                width: 10.0,
+                height: 10.0,
+                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);
+            }
+        })
+        .marker(if app.enhanced_graphics {
+            symbols::Marker::Braille
+        } else {
+            symbols::Marker::Dot
+        })
+        .x_bounds([-180.0, 180.0])
+        .y_bounds([-90.0, 90.0]);
+    f.render_widget(map, chunks[1]);
+}

examples/gauge.rs

@@ -1,40 +1,35 @@
-extern crate termion;
-extern crate tui;
+#[allow(dead_code)]
+mod util;
 
-use std::io;
-use std::sync::mpsc;
-use std::thread;
-use std::time;
-
-use termion::event;
-use termion::input::TermRead;
-
-use tui::backend::MouseBackend;
-use tui::layout::{Constraint, Direction, Layout, Rect};
-use tui::style::{Color, Modifier, Style};
-use tui::widgets::{Block, Borders, Gauge, Widget};
-use tui::Terminal;
+use crate::util::event::{Event, Events};
+use std::{error::Error, io};
+use termion::{event::Key, input::MouseTerminal, raw::IntoRawMode, screen::AlternateScreen};
+use tui::{
+    backend::TermionBackend,
+    layout::{Constraint, Direction, Layout},
+    style::{Color, Modifier, Style},
+    widgets::{Block, Borders, Gauge},
+    Terminal,
+};
 
 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,
         }
     }
 
-    fn advance(&mut self) {
+    fn update(&mut self) {
         self.progress1 += 5;
         if self.progress1 > 100 {
             self.progress1 = 0;
@@ -43,9 +38,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 {
@@ -54,105 +49,78 @@ impl App {
     }
 }
 
-enum Event {
-    Input(event::Key),
-    Tick,
-}
-
-fn main() {
+fn main() -> Result<(), Box<dyn Error>> {
     // Terminal initialization
-    let backend = MouseBackend::new().unwrap();
-    let mut terminal = Terminal::new(backend).unwrap();
+    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)?;
 
-    // Channels
-    let (tx, rx) = mpsc::channel();
-    let input_tx = tx.clone();
-    let clock_tx = tx.clone();
+    let events = Events::new();
 
-    // Input
-    thread::spawn(move || {
-        let stdin = io::stdin();
-        for c in stdin.keys() {
-            let evt = c.unwrap();
-            input_tx.send(Event::Input(evt)).unwrap();
-            if evt == event::Key::Char('q') {
-                break;
-            }
-        }
-    });
-
-    // Tick
-    thread::spawn(move || loop {
-        clock_tx.send(Event::Tick).unwrap();
-        thread::sleep(time::Duration::from_millis(500));
-    });
-
-    // App
     let mut app = App::new();
 
-    // First draw call
-    terminal.clear().unwrap();
-    terminal.hide_cursor().unwrap();
-    app.size = terminal.size().unwrap();
-    draw(&mut terminal, &app).unwrap();
-
     loop {
-        let size = terminal.size().unwrap();
-        if size != app.size {
-            terminal.resize(size).unwrap();
-            app.size = size;
-        }
+        terminal.draw(|f| {
+            let chunks = Layout::default()
+                .direction(Direction::Vertical)
+                .margin(2)
+                .constraints(
+                    [
+                        Constraint::Percentage(25),
+                        Constraint::Percentage(25),
+                        Constraint::Percentage(25),
+                        Constraint::Percentage(25),
+                    ]
+                    .as_ref(),
+                )
+                .split(f.size());
 
-        let evt = rx.recv().unwrap();
-        match evt {
-            Event::Input(input) => if input == event::Key::Char('q') {
-                break;
-            },
+            let gauge = Gauge::default()
+                .block(Block::default().title("Gauge1").borders(Borders::ALL))
+                .gauge_style(Style::default().fg(Color::Yellow))
+                .percent(app.progress1);
+            f.render_widget(gauge, chunks[0]);
+
+            let label = format!("{}/100", app.progress2);
+            let gauge = Gauge::default()
+                .block(Block::default().title("Gauge2").borders(Borders::ALL))
+                .gauge_style(Style::default().fg(Color::Magenta).bg(Color::Green))
+                .percent(app.progress2)
+                .label(label);
+            f.render_widget(gauge, chunks[1]);
+
+            let gauge = Gauge::default()
+                .block(Block::default().title("Gauge3").borders(Borders::ALL))
+                .gauge_style(Style::default().fg(Color::Yellow))
+                .ratio(app.progress3);
+            f.render_widget(gauge, chunks[2]);
+
+            let label = format!("{}/100", app.progress2);
+            let gauge = Gauge::default()
+                .block(Block::default().title("Gauge4"))
+                .gauge_style(
+                    Style::default()
+                        .fg(Color::Cyan)
+                        .add_modifier(Modifier::ITALIC),
+                )
+                .percent(app.progress4)
+                .label(label);
+            f.render_widget(gauge, chunks[3]);
+        })?;
+
+        match events.next()? {
+            Event::Input(input) => {
+                if input == Key::Char('q') {
+                    break;
+                }
+            }
             Event::Tick => {
-                app.advance();
+                app.update();
             }
         }
-        draw(&mut terminal, &app).unwrap();
     }
 
-    terminal.show_cursor().unwrap();
-}
-
-fn draw(t: &mut Terminal<MouseBackend>, app: &App) -> Result<(), io::Error> {
-    t.draw(|mut f| {
-        let chunks = Layout::default()
-            .direction(Direction::Vertical)
-            .margin(2)
-            .constraints(
-                [
-                    Constraint::Percentage(25),
-                    Constraint::Percentage(25),
-                    Constraint::Percentage(25),
-                    Constraint::Percentage(25),
-                ].as_ref(),
-            )
-            .split(app.size);
-        Gauge::default()
-            .block(Block::default().title("Gauge1").borders(Borders::ALL))
-            .style(Style::default().fg(Color::Yellow))
-            .percent(app.progress1)
-            .render(&mut f, chunks[0]);
-        Gauge::default()
-            .block(Block::default().title("Gauge2").borders(Borders::ALL))
-            .style(Style::default().fg(Color::Magenta).bg(Color::Green))
-            .percent(app.progress2)
-            .label(&format!("{}/100", app.progress2))
-            .render(&mut f, chunks[1]);
-        Gauge::default()
-            .block(Block::default().title("Gauge2").borders(Borders::ALL))
-            .style(Style::default().fg(Color::Yellow))
-            .percent(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))
-            .percent(app.progress4)
-            .label(&format!("{}/100", app.progress2))
-            .render(&mut f, chunks[3]);
-    })
+    Ok(())
 }

examples/layout.rs

@@ -1,107 +1,52 @@
-extern crate log;
-extern crate stderrlog;
-extern crate termion;
-extern crate tui;
+#[allow(dead_code)]
+mod util;
 
-use std::io;
-use std::sync::mpsc;
-use std::thread;
-
-use termion::event;
-use termion::input::TermRead;
-
-use tui::backend::MouseBackend;
-use tui::layout::{Constraint, Direction, Layout, Rect};
-use tui::widgets::{Block, Borders, Widget};
-use tui::Terminal;
-
-struct App {
-    size: Rect,
-}
-
-impl App {
-    fn new() -> App {
-        App {
-            size: Rect::default(),
-        }
-    }
-}
-
-enum Event {
-    Input(event::Key),
-}
-
-fn main() {
-    stderrlog::new().verbosity(4).init().unwrap();
+use crate::util::event::{Event, Events};
+use std::{error::Error, io};
+use termion::{event::Key, input::MouseTerminal, raw::IntoRawMode, screen::AlternateScreen};
+use tui::{
+    backend::TermionBackend,
+    layout::{Constraint, Direction, Layout},
+    widgets::{Block, Borders},
+    Terminal,
+};
 
+fn main() -> Result<(), Box<dyn Error>> {
     // Terminal initialization
-    let backend = MouseBackend::new().unwrap();
-    let mut terminal = Terminal::new(backend).unwrap();
+    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)?;
 
-    // Channels
-    let (tx, rx) = mpsc::channel();
-    let input_tx = tx.clone();
+    let events = Events::new();
 
-    // Input
-    thread::spawn(move || {
-        let stdin = io::stdin();
-        for c in stdin.keys() {
-            let evt = c.unwrap();
-            input_tx.send(Event::Input(evt)).unwrap();
-            if evt == event::Key::Char('q') {
+    loop {
+        terminal.draw(|f| {
+            let chunks = Layout::default()
+                .direction(Direction::Vertical)
+                .constraints(
+                    [
+                        Constraint::Percentage(10),
+                        Constraint::Percentage(80),
+                        Constraint::Percentage(10),
+                    ]
+                    .as_ref(),
+                )
+                .split(f.size());
+
+            let block = Block::default().title("Block").borders(Borders::ALL);
+            f.render_widget(block, chunks[0]);
+            let block = Block::default().title("Block 2").borders(Borders::ALL);
+            f.render_widget(block, chunks[2]);
+        })?;
+
+        if let Event::Input(input) = events.next()? {
+            if let Key::Char('q') = input {
                 break;
             }
         }
-    });
-
-    // App
-    let mut app = App::new();
-
-    // First draw call
-    terminal.clear().unwrap();
-    terminal.hide_cursor().unwrap();
-    app.size = terminal.size().unwrap();
-    draw(&mut terminal, &app).unwrap();
-
-    loop {
-        let size = terminal.size().unwrap();
-        if size != app.size {
-            terminal.resize(size).unwrap();
-            app.size = size;
-        }
-
-        let evt = rx.recv().unwrap();
-        match evt {
-            Event::Input(input) => if let event::Key::Char('q') = input {
-                break;
-            },
-        }
-        draw(&mut terminal, &app).unwrap();
     }
 
-    terminal.show_cursor().unwrap();
-}
-
-fn draw(t: &mut Terminal<MouseBackend>, app: &App) -> Result<(), io::Error> {
-    t.draw(|mut f| {
-        let chunks = Layout::default()
-            .direction(Direction::Vertical)
-            .constraints(
-                [
-                    Constraint::Percentage(10),
-                    Constraint::Percentage(80),
-                    Constraint::Percentage(10),
-                ].as_ref(),
-            )
-            .split(app.size);
-
-        Block::default()
-            .title("Block")
-            .borders(Borders::ALL)
-            .render(&mut f, chunks[0]);
-        Block::default()
-            .title("Block 2")
-            .borders(Borders::ALL)
-            .render(&mut f, chunks[2]);
-    })
+    Ok(())
 }

examples/list.rs

@@ -1,41 +1,56 @@
-extern crate termion;
-extern crate tui;
+#[allow(dead_code)]
+mod util;
 
-use std::io;
-use std::sync::mpsc;
-use std::thread;
-use std::time;
-
-use termion::event;
-use termion::input::TermRead;
-
-use tui::backend::MouseBackend;
-use tui::layout::{Constraint, Corner, Direction, Layout, Rect};
-use tui::style::{Color, Modifier, Style};
-use tui::widgets::{Block, Borders, List, SelectableList, Text, Widget};
-use tui::Terminal;
+use crate::util::{
+    event::{Event, Events},
+    StatefulList,
+};
+use std::{error::Error, io};
+use termion::{event::Key, input::MouseTerminal, raw::IntoRawMode, screen::AlternateScreen};
+use tui::{
+    backend::TermionBackend,
+    layout::{Constraint, Corner, Direction, Layout},
+    style::{Color, Modifier, Style},
+    text::{Span, Spans},
+    widgets::{Block, Borders, List, ListItem},
+    Terminal,
+};
 
 struct App<'a> {
-    size: Rect,
-    items: Vec<&'a str>,
-    selected: Option<usize>,
+    items: StatefulList<(&'a str, usize)>,
     events: Vec<(&'a str, &'a str)>,
-    info_style: Style,
-    warning_style: Style,
-    error_style: Style,
-    critical_style: Style,
 }
 
 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",
-                "Item18", "Item19", "Item20", "Item21", "Item22", "Item23", "Item24",
-            ],
-            selected: None,
+            items: StatefulList::with_items(vec![
+                ("Item0", 1),
+                ("Item1", 2),
+                ("Item2", 1),
+                ("Item3", 3),
+                ("Item4", 1),
+                ("Item5", 4),
+                ("Item6", 1),
+                ("Item7", 3),
+                ("Item8", 1),
+                ("Item9", 6),
+                ("Item10", 1),
+                ("Item11", 3),
+                ("Item12", 1),
+                ("Item13", 2),
+                ("Item14", 1),
+                ("Item15", 1),
+                ("Item16", 4),
+                ("Item17", 1),
+                ("Item18", 5),
+                ("Item19", 4),
+                ("Item20", 1),
+                ("Item21", 2),
+                ("Item22", 1),
+                ("Item23", 3),
+                ("Item24", 1),
+            ]),
             events: vec![
                 ("Event1", "INFO"),
                 ("Event2", "INFO"),
@@ -64,10 +79,6 @@ impl<'a> App<'a> {
                 ("Event25", "INFO"),
                 ("Event26", "INFO"),
             ],
-            info_style: Style::default().fg(Color::White),
-            warning_style: Style::default().fg(Color::Yellow),
-            error_style: Style::default().fg(Color::Magenta),
-            critical_style: Style::default().fg(Color::Red),
         }
     }
 
@@ -77,85 +88,98 @@ impl<'a> App<'a> {
     }
 }
 
-enum Event {
-    Input(event::Key),
-    Tick,
-}
-
-fn main() {
+fn main() -> Result<(), Box<dyn Error>> {
     // Terminal initialization
-    let backend = MouseBackend::new().unwrap();
-    let mut terminal = Terminal::new(backend).unwrap();
+    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)?;
 
-    // Channels
-    let (tx, rx) = mpsc::channel();
-    let input_tx = tx.clone();
-    let clock_tx = tx.clone();
-
-    // Input
-    thread::spawn(move || {
-        let stdin = io::stdin();
-        for c in stdin.keys() {
-            let evt = c.unwrap();
-            input_tx.send(Event::Input(evt)).unwrap();
-            if evt == event::Key::Char('q') {
-                break;
-            }
-        }
-    });
-
-    // Tick
-    thread::spawn(move || loop {
-        clock_tx.send(Event::Tick).unwrap();
-        thread::sleep(time::Duration::from_millis(500));
-    });
+    let events = Events::new();
 
     // App
     let mut app = App::new();
 
-    // First draw call
-    terminal.clear().unwrap();
-    terminal.hide_cursor().unwrap();
-    app.size = terminal.size().unwrap();
-    draw(&mut terminal, &app).unwrap();
-
     loop {
-        let size = terminal.size().unwrap();
-        if size != app.size {
-            terminal.resize(size).unwrap();
-            app.size = size;
-        }
+        terminal.draw(|f| {
+            let chunks = Layout::default()
+                .direction(Direction::Horizontal)
+                .constraints([Constraint::Percentage(50), Constraint::Percentage(50)].as_ref())
+                .split(f.size());
 
-        let evt = rx.recv().unwrap();
-        match evt {
+            let items: Vec<ListItem> = app
+                .items
+                .items
+                .iter()
+                .map(|i| {
+                    let mut lines = vec![Spans::from(i.0)];
+                    for _ in 0..i.1 {
+                        lines.push(Spans::from(Span::styled(
+                            "Lorem ipsum dolor sit amet, consectetur adipiscing elit.",
+                            Style::default().add_modifier(Modifier::ITALIC),
+                        )));
+                    }
+                    ListItem::new(lines).style(Style::default().fg(Color::Black).bg(Color::White))
+                })
+                .collect();
+            let items = List::new(items)
+                .block(Block::default().borders(Borders::ALL).title("List"))
+                .highlight_style(
+                    Style::default()
+                        .bg(Color::LightGreen)
+                        .add_modifier(Modifier::BOLD),
+                )
+                .highlight_symbol(">> ");
+            f.render_stateful_widget(items, chunks[0], &mut app.items.state);
+
+            let events: Vec<ListItem> = app
+                .events
+                .iter()
+                .map(|&(evt, level)| {
+                    let s = match level {
+                        "CRITICAL" => Style::default().fg(Color::Red),
+                        "ERROR" => Style::default().fg(Color::Magenta),
+                        "WARNING" => Style::default().fg(Color::Yellow),
+                        "INFO" => Style::default().fg(Color::Blue),
+                        _ => Style::default(),
+                    };
+                    let header = Spans::from(vec![
+                        Span::styled(format!("{:<9}", level), s),
+                        Span::raw(" "),
+                        Span::styled(
+                            "2020-01-01 10:00:00",
+                            Style::default().add_modifier(Modifier::ITALIC),
+                        ),
+                    ]);
+                    let log = Spans::from(vec![Span::raw(evt)]);
+                    ListItem::new(vec![
+                        Spans::from("-".repeat(chunks[1].width as usize)),
+                        header,
+                        Spans::from(""),
+                        log,
+                    ])
+                })
+                .collect();
+            let events_list = List::new(events)
+                .block(Block::default().borders(Borders::ALL).title("List"))
+                .start_corner(Corner::BottomLeft);
+            f.render_widget(events_list, chunks[1]);
+        })?;
+
+        match events.next()? {
             Event::Input(input) => match input {
-                event::Key::Char('q') => {
+                Key::Char('q') => {
                     break;
                 }
-                event::Key::Left => {
-                    app.selected = None;
+                Key::Left => {
+                    app.items.unselect();
                 }
-                event::Key::Down => {
-                    app.selected = if let Some(selected) = app.selected {
-                        if selected >= app.items.len() - 1 {
-                            Some(0)
-                        } else {
-                            Some(selected + 1)
-                        }
-                    } else {
-                        Some(0)
-                    }
+                Key::Down => {
+                    app.items.next();
                 }
-                event::Key::Up => {
-                    app.selected = if let Some(selected) = app.selected {
-                        if selected > 0 {
-                            Some(selected - 1)
-                        } else {
-                            Some(app.items.len() - 1)
-                        }
-                    } else {
-                        Some(0)
-                    }
+                Key::Up => {
+                    app.items.previous();
                 }
                 _ => {}
             },
@@ -163,45 +187,7 @@ fn main() {
                 app.advance();
             }
         }
-        draw(&mut terminal, &app).unwrap();
     }
 
-    terminal.show_cursor().unwrap();
-    terminal.clear().unwrap();
-}
-
-fn draw(t: &mut Terminal<MouseBackend>, app: &App) -> Result<(), io::Error> {
-    t.draw(|mut f| {
-        let chunks = Layout::default()
-            .direction(Direction::Horizontal)
-            .constraints([Constraint::Percentage(50), Constraint::Percentage(50)].as_ref())
-            .split(app.size);
-
-        let style = Style::default().fg(Color::Black).bg(Color::White);
-        SelectableList::default()
-            .block(Block::default().borders(Borders::ALL).title("List"))
-            .items(&app.items)
-            .select(app.selected)
-            .style(style)
-            .highlight_style(style.fg(Color::LightGreen).modifier(Modifier::Bold))
-            .highlight_symbol(">")
-            .render(&mut f, chunks[0]);
-        {
-            let events = app.events.iter().map(|&(evt, level)| {
-                Text::styled(
-                    format!("{}: {}", level, evt),
-                    match level {
-                        "ERROR" => app.error_style,
-                        "CRITICAL" => app.critical_style,
-                        "WARNING" => app.warning_style,
-                        _ => app.info_style,
-                    },
-                )
-            });
-            List::new(events)
-                .block(Block::default().borders(Borders::ALL).title("List"))
-                .start_corner(Corner::BottomLeft)
-                .render(&mut f, chunks[1]);
-        }
-    })
+    Ok(())
 }

examples/paragraph.rs

@@ -1,83 +1,111 @@
-extern crate termion;
-extern crate tui;
+#[allow(dead_code)]
+mod util;
 
-use std::io;
-use termion::event;
-use termion::input::TermRead;
+use crate::util::event::{Event, Events};
+use std::{error::Error, io};
+use termion::{event::Key, input::MouseTerminal, raw::IntoRawMode, screen::AlternateScreen};
+use tui::{
+    backend::TermionBackend,
+    layout::{Alignment, Constraint, Direction, Layout},
+    style::{Color, Modifier, Style},
+    text::{Span, Spans},
+    widgets::{Block, Borders, Paragraph, Wrap},
+    Terminal,
+};
 
-use tui::backend::MouseBackend;
-use tui::layout::{Alignment, Constraint, Direction, Layout, Rect};
-use tui::style::{Color, Modifier, Style};
-use tui::widgets::{Block, Paragraph, Text, Widget};
-use tui::Terminal;
+fn main() -> Result<(), Box<dyn Error>> {
+    // Terminal initialization
+    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)?;
 
-fn main() {
-    let mut terminal = Terminal::new(MouseBackend::new().unwrap()).unwrap();
-    let stdin = io::stdin();
-    terminal.clear().unwrap();
-    terminal.hide_cursor().unwrap();
+    let events = Events::new();
 
-    let mut term_size = terminal.size().unwrap();
-    draw(&mut terminal, term_size).unwrap();
+    let mut scroll: u16 = 0;
+    loop {
+        terminal.draw(|f| {
+            let size = f.size();
 
-    for c in stdin.keys() {
-        let size = terminal.size().unwrap();
-        if size != term_size {
-            terminal.resize(size).unwrap();
-            term_size = 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');
 
-        draw(&mut terminal, term_size).unwrap();
-        let evt = c.unwrap();
-        if evt == event::Key::Char('q') {
-            break;
+            let block = Block::default()
+                .style(Style::default().bg(Color::White).fg(Color::Black));
+            f.render_widget(block, size);
+
+            let chunks = Layout::default()
+                .direction(Direction::Vertical)
+                .margin(5)
+                .constraints(
+                    [
+                        Constraint::Percentage(25),
+                        Constraint::Percentage(25),
+                        Constraint::Percentage(25),
+                        Constraint::Percentage(25),
+                    ]
+                    .as_ref(),
+                )
+                .split(size);
+
+            let text = vec![
+                Spans::from("This is a line "),
+                Spans::from(Span::styled("This is a line   ", Style::default().fg(Color::Red))),
+                Spans::from(Span::styled("This is a line", Style::default().bg(Color::Blue))),
+                Spans::from(Span::styled(
+                    "This is a longer line",
+                    Style::default().add_modifier(Modifier::CROSSED_OUT),
+                )),
+                Spans::from(Span::styled(&long_line, Style::default().bg(Color::Green))),
+                Spans::from(Span::styled(
+                    "This is a line",
+                    Style::default().fg(Color::Green).add_modifier(Modifier::ITALIC),
+                )),
+            ];
+
+            let create_block = |title| {
+                Block::default()
+                    .borders(Borders::ALL)
+                    .style(Style::default().bg(Color::White).fg(Color::Black))
+                    .title(Span::styled(title, Style::default().add_modifier(Modifier::BOLD)))
+            };
+            let paragraph = Paragraph::new(text.clone())
+                .style(Style::default().bg(Color::White).fg(Color::Black))
+                .block(create_block("Left, no wrap"))
+                .alignment(Alignment::Left);
+            f.render_widget(paragraph, chunks[0]);
+            let paragraph = Paragraph::new(text.clone())
+                .style(Style::default().bg(Color::White).fg(Color::Black))
+                .block(create_block("Left, wrap"))
+                .alignment(Alignment::Left)
+                .wrap(Wrap { trim: true });
+            f.render_widget(paragraph, chunks[1]);
+            let paragraph = Paragraph::new(text.clone())
+                .style(Style::default().bg(Color::White).fg(Color::Black))
+                .block(create_block("Center, wrap"))
+                .alignment(Alignment::Center)
+                .wrap(Wrap { trim: true })
+                .scroll((scroll, 0));
+            f.render_widget(paragraph, chunks[2]);
+            let paragraph = Paragraph::new(text)
+                .style(Style::default().bg(Color::White).fg(Color::Black))
+                .block(create_block("Right, wrap"))
+                .alignment(Alignment::Right)
+                .wrap(Wrap { trim: true });
+            f.render_widget(paragraph, chunks[3]);
+        })?;
+
+        scroll += 1;
+        scroll %= 10;
+
+        if let Event::Input(key) = events.next()? {
+            if key == Key::Char('q') {
+                break;
+            }
         }
     }
-    terminal.show_cursor().unwrap();
-}
-
-fn draw(t: &mut Terminal<MouseBackend>, size: Rect) -> Result<(), io::Error> {
-    t.draw(|mut f| {
-        Block::default()
-            .style(Style::default().bg(Color::White))
-            .render(&mut f, size);
-
-        let chunks = Layout::default()
-            .direction(Direction::Vertical)
-            .margin(5)
-            .constraints(
-                [
-                    Constraint::Percentage(30),
-                    Constraint::Percentage(30),
-                    Constraint::Percentage(30),
-                ].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::styled(
-                "This a longer line\n",
-                Style::default().modifier(Modifier::CrossedOut),
-            ),
-            Text::styled(
-                "This a line\n",
-                Style::default().fg(Color::Green).modifier(Modifier::Italic),
-            ),
-        ];
-
-        Paragraph::new(text.iter())
-            .alignment(Alignment::Left)
-            .render(&mut f, chunks[0]);
-        Paragraph::new(text.iter())
-            .alignment(Alignment::Center)
-            .wrap(true)
-            .render(&mut f, chunks[1]);
-        Paragraph::new(text.iter())
-            .alignment(Alignment::Right)
-            .wrap(true)
-            .render(&mut f, chunks[2]);
-    })
+    Ok(())
 }

examples/popup.rs

@@ -0,0 +1,106 @@
+#[allow(dead_code)]
+mod util;
+
+use crate::util::event::{Event, Events};
+use std::{error::Error, io};
+use termion::{event::Key, input::MouseTerminal, raw::IntoRawMode, screen::AlternateScreen};
+use tui::{
+    backend::TermionBackend,
+    layout::{Alignment, Constraint, Direction, Layout, Rect},
+    style::{Color, Modifier, Style},
+    text::{Span, Spans},
+    widgets::{Block, Borders, Clear, Paragraph, Wrap},
+    Terminal,
+};
+
+/// helper function to create a centered rect using up
+/// certain percentage of the available rect `r`
+fn centered_rect(percent_x: u16, percent_y: u16, r: Rect) -> Rect {
+    let popup_layout = Layout::default()
+        .direction(Direction::Vertical)
+        .constraints(
+            [
+                Constraint::Percentage((100 - percent_y) / 2),
+                Constraint::Percentage(percent_y),
+                Constraint::Percentage((100 - percent_y) / 2),
+            ]
+            .as_ref(),
+        )
+        .split(r);
+
+    Layout::default()
+        .direction(Direction::Horizontal)
+        .constraints(
+            [
+                Constraint::Percentage((100 - percent_x) / 2),
+                Constraint::Percentage(percent_x),
+                Constraint::Percentage((100 - percent_x) / 2),
+            ]
+            .as_ref(),
+        )
+        .split(popup_layout[1])[1]
+}
+
+fn main() -> Result<(), Box<dyn Error>> {
+    // Terminal initialization
+    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)?;
+
+    let events = Events::new();
+
+    loop {
+        terminal.draw(|f| {
+            let size = f.size();
+
+            let chunks = Layout::default()
+                .direction(Direction::Horizontal)
+                .constraints([Constraint::Percentage(50), Constraint::Percentage(50)].as_ref())
+                .split(size);
+
+                let s = "Veeeeeeeeeeeeeeeery    loooooooooooooooooong   striiiiiiiiiiiiiiiiiiiiiiiiiing.   ";
+                let mut long_line = s.repeat(usize::from(size.width)*usize::from(size.height)/300);
+                long_line.push('\n');
+
+            let text = vec![
+                Spans::from("This is a line "),
+                Spans::from(Span::styled("This is a line   ", Style::default().fg(Color::Red))),
+                Spans::from(Span::styled("This is a line", Style::default().bg(Color::Blue))),
+                Spans::from(Span::styled(
+                    "This is a longer line\n",
+                    Style::default().add_modifier(Modifier::CROSSED_OUT),
+                )),
+                Spans::from(Span::styled(&long_line, Style::default().bg(Color::Green))),
+                Spans::from(Span::styled(
+                    "This is a line\n",
+                    Style::default().fg(Color::Green).add_modifier(Modifier::ITALIC),
+                )),
+            ];
+
+            let paragraph = Paragraph::new(text.clone())
+                .block(Block::default().title("Left Block").borders(Borders::ALL))
+                .alignment(Alignment::Left).wrap(Wrap { trim: true });
+            f.render_widget(paragraph, chunks[0]);
+
+            let paragraph = Paragraph::new(text)
+                .block(Block::default().title("Right Block").borders(Borders::ALL))
+                .alignment(Alignment::Left).wrap(Wrap { trim: true });
+            f.render_widget(paragraph, chunks[1]);
+
+            let block = Block::default().title("Popup").borders(Borders::ALL);
+            let area = centered_rect(60, 20, size);
+            f.render_widget(Clear, area); //this clears out the background
+            f.render_widget(block, area);
+        })?;
+
+        if let Event::Input(input) = events.next()? {
+            if let Key::Char('q') = input {
+                break;
+            }
+        }
+    }
+
+    Ok(())
+}

examples/rustbox.rs

@@ -1,48 +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,68 @@
+mod demo;
+#[allow(dead_code)]
+mod util;
+
+use crate::demo::{ui, App};
+use argh::FromArgs;
+use rustbox::keyboard::Key;
+use std::{
+    error::Error,
+    time::{Duration, Instant},
+};
+use tui::{backend::RustboxBackend, Terminal};
+
+/// Rustbox demo
+#[derive(Debug, FromArgs)]
+struct Cli {
+    /// time in ms between two ticks.
+    #[argh(option, default = "250")]
+    tick_rate: u64,
+    /// whether unicode symbols are used to improve the overall look of the app
+    #[argh(option, default = "true")]
+    enhanced_graphics: bool,
+}
+
+fn main() -> Result<(), Box<dyn Error>> {
+    let cli: Cli = argh::from_env();
+
+    let backend = RustboxBackend::new()?;
+    let mut terminal = Terminal::new(backend)?;
+
+    let mut app = App::new("Rustbox demo", cli.enhanced_graphics);
+
+    let mut last_tick = Instant::now();
+    let tick_rate = Duration::from_millis(cli.tick_rate);
+    loop {
+        terminal.draw(|f| ui::draw(f, &mut app))?;
+        if let Ok(rustbox::Event::KeyEvent(key)) =
+            terminal.backend().rustbox().peek_event(tick_rate, false)
+        {
+            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,25 +1,21 @@
-extern crate termion;
-extern crate tui;
-
+#[allow(dead_code)]
 mod util;
-use util::*;
 
-use std::io;
-use std::sync::mpsc;
-use std::thread;
-use std::time;
-
-use termion::event;
-use termion::input::TermRead;
-
-use tui::backend::MouseBackend;
-use tui::layout::{Constraint, Direction, Layout, Rect};
-use tui::style::{Color, Style};
-use tui::widgets::{Block, Borders, Sparkline, Widget};
-use tui::Terminal;
+use crate::util::{
+    event::{Event, Events},
+    RandomSignal,
+};
+use std::{error::Error, io};
+use termion::{event::Key, input::MouseTerminal, raw::IntoRawMode, screen::AlternateScreen};
+use tui::{
+    backend::TermionBackend,
+    layout::{Constraint, Direction, Layout},
+    style::{Color, Style},
+    widgets::{Block, Borders, Sparkline},
+    Terminal,
+};
 
 struct App {
-    size: Rect,
     signal: RandomSignal,
     data1: Vec<u64>,
     data2: Vec<u64>,
@@ -33,7 +29,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,
@@ -41,7 +36,7 @@ impl App {
         }
     }
 
-    fn advance(&mut self) {
+    fn update(&mut self) {
         let value = self.signal.next().unwrap();
         self.data1.pop();
         self.data1.insert(0, value);
@@ -54,111 +49,76 @@ impl App {
     }
 }
 
-enum Event {
-    Input(event::Key),
-    Tick,
-}
-
-fn main() {
+fn main() -> Result<(), Box<dyn Error>> {
     // Terminal initialization
-    let backend = MouseBackend::new().unwrap();
-    let mut terminal = Terminal::new(backend).unwrap();
+    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)?;
 
-    // Channels
-    let (tx, rx) = mpsc::channel();
-    let input_tx = tx.clone();
-    let clock_tx = tx.clone();
+    // Setup event handlers
+    let events = Events::new();
 
-    // Input
-    thread::spawn(move || {
-        let stdin = io::stdin();
-        for c in stdin.keys() {
-            let evt = c.unwrap();
-            input_tx.send(Event::Input(evt)).unwrap();
-            if evt == event::Key::Char('q') {
-                break;
-            }
-        }
-    });
-
-    // Tick
-    thread::spawn(move || loop {
-        clock_tx.send(Event::Tick).unwrap();
-        thread::sleep(time::Duration::from_millis(500));
-    });
-
-    // App
+    // Create default app state
     let mut app = App::new();
 
-    // First draw call
-    terminal.clear().unwrap();
-    terminal.hide_cursor().unwrap();
-    app.size = terminal.size().unwrap();
-    draw(&mut terminal, &app).unwrap();
-
     loop {
-        let size = terminal.size().unwrap();
-        if size != app.size {
-            terminal.resize(size).unwrap();
-            app.size = size;
-        }
+        terminal.draw(|f| {
+            let chunks = Layout::default()
+                .direction(Direction::Vertical)
+                .margin(2)
+                .constraints(
+                    [
+                        Constraint::Length(3),
+                        Constraint::Length(3),
+                        Constraint::Length(7),
+                        Constraint::Min(0),
+                    ]
+                    .as_ref(),
+                )
+                .split(f.size());
+            let sparkline = Sparkline::default()
+                .block(
+                    Block::default()
+                        .title("Data1")
+                        .borders(Borders::LEFT | Borders::RIGHT),
+                )
+                .data(&app.data1)
+                .style(Style::default().fg(Color::Yellow));
+            f.render_widget(sparkline, chunks[0]);
+            let sparkline = Sparkline::default()
+                .block(
+                    Block::default()
+                        .title("Data2")
+                        .borders(Borders::LEFT | Borders::RIGHT),
+                )
+                .data(&app.data2)
+                .style(Style::default().bg(Color::Green));
+            f.render_widget(sparkline, chunks[1]);
+            // Multiline
+            let sparkline = Sparkline::default()
+                .block(
+                    Block::default()
+                        .title("Data3")
+                        .borders(Borders::LEFT | Borders::RIGHT),
+                )
+                .data(&app.data3)
+                .style(Style::default().fg(Color::Red));
+            f.render_widget(sparkline, chunks[2]);
+        })?;
 
-        let evt = rx.recv().unwrap();
-        match evt {
-            Event::Input(input) => if input == event::Key::Char('q') {
-                break;
-            },
+        match events.next()? {
+            Event::Input(input) => {
+                if input == Key::Char('q') {
+                    break;
+                }
+            }
             Event::Tick => {
-                app.advance();
+                app.update();
             }
         }
-        draw(&mut terminal, &app).unwrap();
     }
 
-    terminal.show_cursor().unwrap();
-}
-
-fn draw(t: &mut Terminal<MouseBackend>, app: &App) -> Result<(), io::Error> {
-    t.draw(|mut f| {
-        let chunks = Layout::default()
-            .direction(Direction::Vertical)
-            .margin(2)
-            .constraints(
-                [
-                    Constraint::Length(3),
-                    Constraint::Length(3),
-                    Constraint::Length(7),
-                    Constraint::Min(0),
-                ].as_ref(),
-            )
-            .split(app.size);
-        Sparkline::default()
-            .block(
-                Block::default()
-                    .title("Data1")
-                    .borders(Borders::LEFT | Borders::RIGHT),
-            )
-            .data(&app.data1)
-            .style(Style::default().fg(Color::Yellow))
-            .render(&mut f, chunks[0]);
-        Sparkline::default()
-            .block(
-                Block::default()
-                    .title("Data2")
-                    .borders(Borders::LEFT | Borders::RIGHT),
-            )
-            .data(&app.data2)
-            .style(Style::default().bg(Color::Green))
-            .render(&mut f, chunks[1]);
-        // Multiline
-        Sparkline::default()
-            .block(
-                Block::default()
-                    .title("Data3")
-                    .borders(Borders::LEFT | Borders::RIGHT),
-            )
-            .data(&app.data3)
-            .style(Style::default().fg(Color::Red))
-            .render(&mut f, chunks[2]);
-    })
+    Ok(())
 }

examples/table.rs

@@ -1,108 +1,134 @@
-extern crate termion;
-extern crate tui;
+#[allow(dead_code)]
+mod util;
 
-use std::io;
+use crate::util::event::{Event, Events};
+use std::{error::Error, io};
+use termion::{event::Key, input::MouseTerminal, raw::IntoRawMode, screen::AlternateScreen};
+use tui::{
+    backend::TermionBackend,
+    layout::{Constraint, Layout},
+    style::{Color, Modifier, Style},
+    widgets::{Block, Borders, Row, Table, TableState},
+    Terminal,
+};
 
-use termion::event;
-use termion::input::TermRead;
-
-use tui::backend::MouseBackend;
-use tui::layout::{Constraint, Layout, Rect};
-use tui::style::{Color, Modifier, Style};
-use tui::widgets::{Block, Borders, Row, Table, Widget};
-use tui::Terminal;
-
-struct App<'a> {
-    size: Rect,
+pub struct StatefulTable<'a> {
+    state: TableState,
     items: Vec<Vec<&'a str>>,
-    selected: usize,
 }
 
-impl<'a> App<'a> {
-    fn new() -> App<'a> {
-        App {
-            size: Rect::default(),
+impl<'a> StatefulTable<'a> {
+    fn new() -> StatefulTable<'a> {
+        StatefulTable {
+            state: TableState::default(),
             items: vec![
-                vec!["Row12", "Row12", "Row13"],
+                vec!["Row11", "Row12", "Row13"],
                 vec!["Row21", "Row22", "Row23"],
                 vec!["Row31", "Row32", "Row33"],
                 vec!["Row41", "Row42", "Row43"],
                 vec!["Row51", "Row52", "Row53"],
                 vec!["Row61", "Row62", "Row63"],
+                vec!["Row71", "Row72", "Row73"],
+                vec!["Row81", "Row82", "Row83"],
+                vec!["Row91", "Row92", "Row93"],
+                vec!["Row101", "Row102", "Row103"],
+                vec!["Row111", "Row112", "Row113"],
+                vec!["Row121", "Row122", "Row123"],
+                vec!["Row131", "Row132", "Row133"],
+                vec!["Row141", "Row142", "Row143"],
+                vec!["Row151", "Row152", "Row153"],
+                vec!["Row161", "Row162", "Row163"],
+                vec!["Row171", "Row172", "Row173"],
+                vec!["Row181", "Row182", "Row183"],
+                vec!["Row191", "Row192", "Row193"],
             ],
-            selected: 0,
         }
     }
-}
-
-fn main() {
-    // Terminal initialization
-    let backend = MouseBackend::new().unwrap();
-    let mut terminal = Terminal::new(backend).unwrap();
-
-    // App
-    let mut app = App::new();
-
-    // First draw call
-    terminal.clear().unwrap();
-    terminal.hide_cursor().unwrap();
-    app.size = terminal.size().unwrap();
-    draw(&mut terminal, &app).unwrap();
-
-    // Input
-    let stdin = io::stdin();
-    for c in stdin.keys() {
-        let size = terminal.size().unwrap();
-        if size != app.size {
-            terminal.resize(size).unwrap();
-            app.size = size;
-        }
-
-        let evt = c.unwrap();
-        match evt {
-            event::Key::Char('q') => {
-                break;
-            }
-            event::Key::Down => {
-                app.selected += 1;
-                if app.selected > app.items.len() - 1 {
-                    app.selected = 0;
+    pub fn next(&mut self) {
+        let i = match self.state.selected() {
+            Some(i) => {
+                if i >= self.items.len() - 1 {
+                    0
+                } else {
+                    i + 1
                 }
             }
-            event::Key::Up => if app.selected > 0 {
-                app.selected -= 1;
-            } else {
-                app.selected = app.items.len() - 1;
-            },
-            _ => {}
+            None => 0,
         };
-        draw(&mut terminal, &app).unwrap();
+        self.state.select(Some(i));
     }
 
-    terminal.show_cursor().unwrap();
-    terminal.clear().unwrap();
-}
-
-fn draw(t: &mut Terminal<MouseBackend>, app: &App) -> Result<(), io::Error> {
-    t.draw(|mut f| {
-        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)| {
-            if i == app.selected {
-                Row::StyledData(item.into_iter(), selected_style)
-            } else {
-                Row::StyledData(item.into_iter(), normal_style)
+    pub fn previous(&mut self) {
+        let i = match self.state.selected() {
+            Some(i) => {
+                if i == 0 {
+                    self.items.len() - 1
+                } else {
+                    i - 1
+                }
             }
-        });
-
-        let rects = Layout::default()
-            .constraints([Constraint::Percentage(100)].as_ref())
-            .margin(5)
-            .split(app.size);
-        Table::new(header.into_iter(), rows)
-            .block(Block::default().borders(Borders::ALL).title("Table"))
-            .widths(&[10, 10, 10])
-            .render(&mut f, rects[0]);
-    })
+            None => 0,
+        };
+        self.state.select(Some(i));
+    }
+}
+
+fn main() -> Result<(), Box<dyn Error>> {
+    // Terminal initialization
+    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)?;
+
+    let events = Events::new();
+
+    let mut table = StatefulTable::new();
+
+    // Input
+    loop {
+        terminal.draw(|f| {
+            let rects = Layout::default()
+                .constraints([Constraint::Percentage(100)].as_ref())
+                .margin(5)
+                .split(f.size());
+
+            let selected_style = Style::default()
+                .fg(Color::Yellow)
+                .add_modifier(Modifier::BOLD);
+            let normal_style = Style::default().fg(Color::White);
+            let header = ["Header1", "Header2", "Header3"];
+            let rows = table
+                .items
+                .iter()
+                .map(|i| Row::StyledData(i.iter(), normal_style));
+            let t = Table::new(header.iter(), rows)
+                .block(Block::default().borders(Borders::ALL).title("Table"))
+                .highlight_style(selected_style)
+                .highlight_symbol(">> ")
+                .widths(&[
+                    Constraint::Percentage(50),
+                    Constraint::Length(30),
+                    Constraint::Max(10),
+                ]);
+            f.render_stateful_widget(t, rects[0], &mut table.state);
+        })?;
+
+        if let Event::Input(key) = events.next()? {
+            match key {
+                Key::Char('q') => {
+                    break;
+                }
+                Key::Down => {
+                    table.next();
+                }
+                Key::Up => {
+                    table.previous();
+                }
+                _ => {}
+            }
+        };
+    }
+
+    Ok(())
 }

examples/tabs.rs

@@ -1,112 +1,94 @@
-extern crate termion;
-extern crate tui;
-
+#[allow(dead_code)]
 mod util;
-use util::*;
 
-use std::io;
-use termion::event;
-use termion::input::TermRead;
-
-use tui::backend::MouseBackend;
-use tui::layout::{Constraint, Direction, Layout, Rect};
-use tui::style::{Color, Style};
-use tui::widgets::{Block, Borders, Tabs, Widget};
-use tui::Terminal;
+use crate::util::{
+    event::{Event, Events},
+    TabsState,
+};
+use std::{error::Error, io};
+use termion::{event::Key, input::MouseTerminal, raw::IntoRawMode, screen::AlternateScreen};
+use tui::{
+    backend::TermionBackend,
+    layout::{Constraint, Direction, Layout},
+    style::{Color, Modifier, Style},
+    text::{Span, Spans},
+    widgets::{Block, Borders, Tabs},
+    Terminal,
+};
 
 struct App<'a> {
-    size: Rect,
-    tabs: MyTabs<'a>,
+    tabs: TabsState<'a>,
 }
 
-fn main() {
+fn main() -> Result<(), Box<dyn Error>> {
     // Terminal initialization
-    let backend = MouseBackend::new().unwrap();
-    let mut terminal = Terminal::new(backend).unwrap();
+    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)?;
+
+    let events = Events::new();
 
     // App
     let mut app = App {
-        size: Rect::default(),
-        tabs: MyTabs {
-            titles: vec!["Tab0", "Tab1", "Tab2", "Tab3"],
-            selection: 0,
-        },
+        tabs: TabsState::new(vec!["Tab0", "Tab1", "Tab2", "Tab3"]),
     };
 
-    // First draw call
-    terminal.clear().unwrap();
-    terminal.hide_cursor().unwrap();
-    app.size = terminal.size().unwrap();
-    draw(&mut terminal, &mut app).unwrap();
-
     // Main loop
-    let stdin = io::stdin();
-    for c in stdin.keys() {
-        let size = terminal.size().unwrap();
-        if size != app.size {
-            terminal.resize(size).unwrap();
-            app.size = size;
-        }
+    loop {
+        terminal.draw(|f| {
+            let size = f.size();
+            let chunks = Layout::default()
+                .direction(Direction::Vertical)
+                .margin(5)
+                .constraints([Constraint::Length(3), Constraint::Min(0)].as_ref())
+                .split(size);
 
-        let evt = c.unwrap();
-        match evt {
-            event::Key::Char('q') => {
-                break;
+            let block = Block::default().style(Style::default().bg(Color::White).fg(Color::Black));
+            f.render_widget(block, size);
+            let titles = app
+                .tabs
+                .titles
+                .iter()
+                .map(|t| {
+                    let (first, rest) = t.split_at(1);
+                    Spans::from(vec![
+                        Span::styled(first, Style::default().fg(Color::Yellow)),
+                        Span::styled(rest, Style::default().fg(Color::Green)),
+                    ])
+                })
+                .collect();
+            let tabs = Tabs::new(titles)
+                .block(Block::default().borders(Borders::ALL).title("Tabs"))
+                .select(app.tabs.index)
+                .style(Style::default().fg(Color::Cyan))
+                .highlight_style(
+                    Style::default()
+                        .add_modifier(Modifier::BOLD)
+                        .bg(Color::Black),
+                );
+            f.render_widget(tabs, chunks[0]);
+            let inner = match app.tabs.index {
+                0 => Block::default().title("Inner 0").borders(Borders::ALL),
+                1 => Block::default().title("Inner 1").borders(Borders::ALL),
+                2 => Block::default().title("Inner 2").borders(Borders::ALL),
+                3 => Block::default().title("Inner 3").borders(Borders::ALL),
+                _ => unreachable!(),
+            };
+            f.render_widget(inner, chunks[1]);
+        })?;
+
+        if let Event::Input(input) = events.next()? {
+            match input {
+                Key::Char('q') => {
+                    break;
+                }
+                Key::Right => app.tabs.next(),
+                Key::Left => app.tabs.previous(),
+                _ => {}
             }
-            event::Key::Right => app.tabs.next(),
-            event::Key::Left => app.tabs.previous(),
-            _ => {}
         }
-        draw(&mut terminal, &mut app).unwrap();
     }
-
-    terminal.show_cursor().unwrap();
-}
-
-fn draw(t: &mut Terminal<MouseBackend>, app: &App) -> Result<(), io::Error> {
-    t.draw(|mut f| {
-        let chunks = Layout::default()
-            .direction(Direction::Vertical)
-            .margin(5)
-            .constraints([Constraint::Length(3), Constraint::Min(0)].as_ref())
-            .split(app.size);
-
-        Block::default()
-            .style(Style::default().bg(Color::White))
-            .render(&mut f, app.size);
-        Tabs::default()
-            .block(Block::default().borders(Borders::ALL).title("Tabs"))
-            .titles(&app.tabs.titles)
-            .select(app.tabs.selection)
-            .style(Style::default().fg(Color::Cyan))
-            .highlight_style(Style::default().fg(Color::Yellow))
-            .render(&mut f, chunks[0]);
-        match app.tabs.selection {
-            0 => {
-                Block::default()
-                    .title("Inner 0")
-                    .borders(Borders::ALL)
-                    .render(&mut f, chunks[1]);
-            }
-            1 => {
-                Block::default()
-                    .title("Inner 1")
-                    .borders(Borders::ALL)
-                    .render(&mut f, chunks[1]);
-            }
-            2 => {
-                Block::default()
-                    .title("Inner 2")
-                    .borders(Borders::ALL)
-                    .render(&mut f, chunks[1]);
-            }
-            3 => {
-                Block::default()
-                    .title("Inner 3")
-                    .borders(Borders::ALL)
-                    .render(&mut f, chunks[1]);
-            }
-            _ => {}
-        }
-    })
+    Ok(())
 }

examples/termion_demo.rs

@@ -0,0 +1,72 @@
+mod demo;
+#[allow(dead_code)]
+mod util;
+
+use crate::{
+    demo::{ui, App},
+    util::event::{Config, Event, Events},
+};
+use argh::FromArgs;
+use std::{error::Error, io, time::Duration};
+use termion::{event::Key, input::MouseTerminal, raw::IntoRawMode, screen::AlternateScreen};
+use tui::{backend::TermionBackend, Terminal};
+
+/// Termion demo
+#[derive(Debug, FromArgs)]
+struct Cli {
+    /// time in ms between two ticks.
+    #[argh(option, default = "250")]
+    tick_rate: u64,
+    /// whether unicode symbols are used to improve the overall look of the app
+    #[argh(option, default = "true")]
+    enhanced_graphics: bool,
+}
+
+fn main() -> Result<(), Box<dyn Error>> {
+    let cli: Cli = argh::from_env();
+
+    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)?;
+
+    let mut app = App::new("Termion demo", cli.enhanced_graphics);
+    loop {
+        terminal.draw(|f| ui::draw(f, &mut 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

@@ -9,121 +9,173 @@
 ///   * Pressing Backspace erases a character
 ///   * Pressing Enter pushes the current input in the history of previous
 ///   messages
-extern crate termion;
-extern crate tui;
 
-use std::io;
-use std::sync::mpsc;
-use std::thread;
+#[allow(dead_code)]
+mod util;
 
-use termion::event;
-use termion::input::TermRead;
+use crate::util::event::{Event, Events};
+use std::{error::Error, io};
+use termion::{event::Key, input::MouseTerminal, raw::IntoRawMode, screen::AlternateScreen};
+use tui::{
+    backend::TermionBackend,
+    layout::{Constraint, Direction, Layout},
+    style::{Color, Modifier, Style},
+    text::{Span, Spans, Text},
+    widgets::{Block, Borders, List, ListItem, Paragraph},
+    Terminal,
+};
+use unicode_width::UnicodeWidthStr;
 
-use tui::backend::AlternateScreenBackend;
-use tui::layout::{Constraint, Direction, Layout, Rect};
-use tui::style::{Color, Style};
-use tui::widgets::{Block, Borders, List, Paragraph, Text, Widget};
-use tui::Terminal;
+enum InputMode {
+    Normal,
+    Editing,
+}
 
+/// App holds the state of the application
 struct App {
-    size: Rect,
+    /// Current value of the input box
     input: String,
+    /// Current input mode
+    input_mode: InputMode,
+    /// History of recorded messages
     messages: Vec<String>,
 }
 
-impl App {
-    fn new() -> App {
+impl Default for App {
+    fn default() -> App {
         App {
-            size: Rect::default(),
             input: String::new(),
+            input_mode: InputMode::Normal,
             messages: Vec::new(),
         }
     }
 }
 
-enum Event {
-    Input(event::Key),
-}
-
-fn main() {
+fn main() -> Result<(), Box<dyn Error>> {
     // Terminal initialization
-    let backend = AlternateScreenBackend::new().unwrap();
-    let mut terminal = Terminal::new(backend).unwrap();
+    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)?;
 
-    // Channels
-    let (tx, rx) = mpsc::channel();
-    let input_tx = tx.clone();
+    // Setup event handlers
+    let mut events = Events::new();
 
-    // Input
-    thread::spawn(move || {
-        let stdin = io::stdin();
-        for c in stdin.keys() {
-            let evt = c.unwrap();
-            input_tx.send(Event::Input(evt)).unwrap();
-            if evt == event::Key::Char('q') {
-                break;
-            }
-        }
-    });
-
-    // App
-    let mut app = App::new();
-
-    // First draw call
-    terminal.clear().unwrap();
-    terminal.hide_cursor().unwrap();
-    app.size = terminal.size().unwrap();
-    draw(&mut terminal, &app).unwrap();
+    // Create default app state
+    let mut app = App::default();
 
     loop {
-        let size = terminal.size().unwrap();
-        if app.size != size {
-            terminal.resize(size).unwrap();
-            app.size = size;
-        }
+        // Draw UI
+        terminal.draw(|f| {
+            let chunks = Layout::default()
+                .direction(Direction::Vertical)
+                .margin(2)
+                .constraints(
+                    [
+                        Constraint::Length(1),
+                        Constraint::Length(3),
+                        Constraint::Min(1),
+                    ]
+                    .as_ref(),
+                )
+                .split(f.size());
 
-        let evt = rx.recv().unwrap();
-        match evt {
-            Event::Input(input) => match input {
-                event::Key::Char('q') => {
-                    break;
-                }
-                event::Key::Char('\n') => {
-                    app.messages.push(app.input.drain(..).collect());
-                }
-                event::Key::Char(c) => {
-                    app.input.push(c);
-                }
-                event::Key::Backspace => {
-                    app.input.pop();
-                }
-                _ => {}
-            },
-        }
-        draw(&mut terminal, &app).unwrap();
-    }
+            let (msg, style) = match app.input_mode {
+                InputMode::Normal => (
+                    vec![
+                        Span::raw("Press "),
+                        Span::styled("q", Style::default().add_modifier(Modifier::BOLD)),
+                        Span::raw(" to exit, "),
+                        Span::styled("e", Style::default().add_modifier(Modifier::BOLD)),
+                        Span::raw(" to start editing."),
+                    ],
+                    Style::default().add_modifier(Modifier::RAPID_BLINK),
+                ),
+                InputMode::Editing => (
+                    vec![
+                        Span::raw("Press "),
+                        Span::styled("Esc", Style::default().add_modifier(Modifier::BOLD)),
+                        Span::raw(" to stop editing, "),
+                        Span::styled("Enter", Style::default().add_modifier(Modifier::BOLD)),
+                        Span::raw(" to record the message"),
+                    ],
+                    Style::default(),
+                ),
+            };
+            let mut text = Text::from(Spans::from(msg));
+            text.patch_style(style);
+            let help_message = Paragraph::new(text);
+            f.render_widget(help_message, chunks[0]);
 
-    terminal.show_cursor().unwrap();
-    terminal.clear().unwrap();
-}
+            let input = Paragraph::new(app.input.as_ref())
+                .style(match app.input_mode {
+                    InputMode::Normal => Style::default(),
+                    InputMode::Editing => Style::default().fg(Color::Yellow),
+                })
+                .block(Block::default().borders(Borders::ALL).title("Input"));
+            f.render_widget(input, chunks[1]);
+            match app.input_mode {
+                InputMode::Normal =>
+                    // Hide the cursor. `Frame` does this by default, so we don't need to do anything here
+                    {}
 
-fn draw(t: &mut Terminal<AlternateScreenBackend>, app: &App) -> Result<(), io::Error> {
-    t.draw(|mut f| {
-        let chunks = Layout::default()
-            .direction(Direction::Vertical)
-            .margin(2)
-            .constraints([Constraint::Length(3), Constraint::Min(1)].as_ref())
-            .split(app.size);
-        Paragraph::new([Text::raw(&app.input)].iter())
-            .style(Style::default().fg(Color::Yellow))
-            .block(Block::default().borders(Borders::ALL).title("Input"))
-            .render(&mut f, chunks[0]);
-        List::new(
-            app.messages
+                InputMode::Editing => {
+                    // Make the cursor visible and ask tui-rs to put it at the specified coordinates after rendering
+                    f.set_cursor(
+                        // Put cursor past the end of the input text
+                        chunks[1].x + app.input.width() as u16 + 1,
+                        // Move one line down, from the border to the input line
+                        chunks[1].y + 1,
+                    )
+                }
+            }
+
+            let messages: Vec<ListItem> = app
+                .messages
                 .iter()
                 .enumerate()
-                .map(|(i, m)| Text::raw(format!("{}: {}", i, m))),
-        ).block(Block::default().borders(Borders::ALL).title("Messages"))
-            .render(&mut f, chunks[1]);
-    })
+                .map(|(i, m)| {
+                    let content = vec![Spans::from(Span::raw(format!("{}: {}", i, m)))];
+                    ListItem::new(content)
+                })
+                .collect();
+            let messages =
+                List::new(messages).block(Block::default().borders(Borders::ALL).title("Messages"));
+            f.render_widget(messages, chunks[2]);
+        })?;
+
+        // Handle input
+        if let Event::Input(input) = events.next()? {
+            match app.input_mode {
+                InputMode::Normal => match input {
+                    Key::Char('e') => {
+                        app.input_mode = InputMode::Editing;
+                        events.disable_exit_key();
+                    }
+                    Key::Char('q') => {
+                        break;
+                    }
+                    _ => {}
+                },
+                InputMode::Editing => match input {
+                    Key::Char('\n') => {
+                        app.messages.push(app.input.drain(..).collect());
+                    }
+                    Key::Char(c) => {
+                        app.input.push(c);
+                    }
+                    Key::Backspace => {
+                        app.input.pop();
+                    }
+                    Key::Esc => {
+                        app.input_mode = InputMode::Normal;
+                        events.enable_exit_key();
+                    }
+                    _ => {}
+                },
+            }
+        }
+    }
+    Ok(())
 }

examples/util/event.rs

@@ -0,0 +1,95 @@
+use std::io;
+use std::sync::mpsc;
+use std::sync::{
+    atomic::{AtomicBool, Ordering},
+    Arc,
+};
+use std::thread;
+use std::time::Duration;
+
+use termion::event::Key;
+use termion::input::TermRead;
+
+pub enum Event<I> {
+    Input(I),
+    Tick,
+}
+
+/// 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>>,
+    input_handle: thread::JoinHandle<()>,
+    ignore_exit_key: Arc<AtomicBool>,
+    tick_handle: thread::JoinHandle<()>,
+}
+
+#[derive(Debug, Clone, Copy)]
+pub struct Config {
+    pub exit_key: Key,
+    pub tick_rate: Duration,
+}
+
+impl Default for Config {
+    fn default() -> Config {
+        Config {
+            exit_key: Key::Char('q'),
+            tick_rate: Duration::from_millis(250),
+        }
+    }
+}
+
+impl Events {
+    pub fn new() -> Events {
+        Events::with_config(Config::default())
+    }
+
+    pub fn with_config(config: Config) -> Events {
+        let (tx, rx) = mpsc::channel();
+        let ignore_exit_key = Arc::new(AtomicBool::new(false));
+        let input_handle = {
+            let tx = tx.clone();
+            let ignore_exit_key = ignore_exit_key.clone();
+            thread::spawn(move || {
+                let stdin = io::stdin();
+                for evt in stdin.keys() {
+                    if let Ok(key) = evt {
+                        if let Err(err) = tx.send(Event::Input(key)) {
+                            eprintln!("{}", err);
+                            return;
+                        }
+                        if !ignore_exit_key.load(Ordering::Relaxed) && key == config.exit_key {
+                            return;
+                        }
+                    }
+                }
+            })
+        };
+        let tick_handle = {
+            thread::spawn(move || loop {
+                if tx.send(Event::Tick).is_err() {
+                    break;
+                }
+                thread::sleep(config.tick_rate);
+            })
+        };
+        Events {
+            rx,
+            ignore_exit_key,
+            input_handle,
+            tick_handle,
+        }
+    }
+
+    pub fn next(&self) -> Result<Event<Key>, mpsc::RecvError> {
+        self.rx.recv()
+    }
+
+    pub fn disable_exit_key(&mut self) {
+        self.ignore_exit_key.store(true, Ordering::Relaxed);
+    }
+
+    pub fn enable_exit_key(&mut self) {
+        self.ignore_exit_key.store(false, Ordering::Relaxed);
+    }
+}

examples/util/mod.rs

@@ -1,19 +1,20 @@
-#![allow(dead_code)]
+#[cfg(feature = "termion")]
+pub mod event;
 
-extern crate rand;
-
-use self::rand::distributions::{IndependentSample, Range};
+use rand::distributions::{Distribution, Uniform};
+use rand::rngs::ThreadRng;
+use tui::widgets::ListState;
 
 #[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 +23,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))
     }
 }
 
@@ -54,21 +55,77 @@ impl Iterator for SinSignal {
     }
 }
 
-pub struct MyTabs<'a> {
+pub struct TabsState<'a> {
     pub titles: Vec<&'a str>,
-    pub selection: usize,
+    pub index: usize,
 }
 
-impl<'a> MyTabs<'a> {
+impl<'a> TabsState<'a> {
+    pub fn new(titles: Vec<&'a str>) -> TabsState {
+        TabsState { titles, index: 0 }
+    }
     pub fn next(&mut self) {
-        self.selection = (self.selection + 1) % self.titles.len();
+        self.index = (self.index + 1) % self.titles.len();
     }
 
     pub fn previous(&mut self) {
-        if self.selection > 0 {
-            self.selection -= 1;
+        if self.index > 0 {
+            self.index -= 1;
         } else {
-            self.selection = self.titles.len() - 1;
+            self.index = self.titles.len() - 1;
         }
     }
 }
+
+pub struct StatefulList<T> {
+    pub state: ListState,
+    pub items: Vec<T>,
+}
+
+impl<T> StatefulList<T> {
+    pub fn new() -> StatefulList<T> {
+        StatefulList {
+            state: ListState::default(),
+            items: Vec::new(),
+        }
+    }
+
+    pub fn with_items(items: Vec<T>) -> StatefulList<T> {
+        StatefulList {
+            state: ListState::default(),
+            items,
+        }
+    }
+
+    pub fn next(&mut self) {
+        let i = match self.state.selected() {
+            Some(i) => {
+                if i >= self.items.len() - 1 {
+                    0
+                } else {
+                    i + 1
+                }
+            }
+            None => 0,
+        };
+        self.state.select(Some(i));
+    }
+
+    pub fn previous(&mut self) {
+        let i = match self.state.selected() {
+            Some(i) => {
+                if i == 0 {
+                    self.items.len() - 1
+                } else {
+                    i - 1
+                }
+            }
+            None => 0,
+        };
+        self.state.select(Some(i));
+    }
+
+    pub fn unselect(&mut self) {
+        self.state.select(None);
+    }
+}

scripts/build-examples.sh

@@ -1,15 +0,0 @@
-#!/bin/bash
-
-# Build all examples in examples directory
-
-set -u -o pipefail
-
-for file in examples/*.rs; do
-  name=$(basename ${file//.rs/})
-  echo "[EXAMPLE] $name"
-  if [[ "$name" == "rustbox" ]]; then
-    cargo build --features rustbox --example "$name"
-  else
-    cargo build --example "$name"
-  fi
-done

scripts/run-examples.sh

@@ -1,14 +0,0 @@
-#!/bin/bash
-
-# Run all examples in examples directory
-
-set -u -o pipefail
-
-for file in examples/*.rs; do
-  name=$(basename ${file//.rs/})
-  if [[ "$name" == "rustbox" ]]; then
-    cargo run --features rustbox --example "$name"
-  else
-    cargo run --example "$name"
-  fi
-done

src/backend/crossterm.rs

@@ -1,128 +1,221 @@
-extern crate crossterm;
+use crate::{
+    backend::Backend,
+    buffer::Cell,
+    layout::Rect,
+    style::{Color, Modifier},
+};
+use crossterm::{
+    cursor::{Hide, MoveTo, Show},
+    execute, queue,
+    style::{
+        Attribute as CAttribute, Color as CColor, Print, SetAttribute, SetBackgroundColor,
+        SetForegroundColor,
+    },
+    terminal::{self, Clear, ClearType},
+};
+use std::io::{self, Write};
 
-use std::io;
-
-use backend::Backend;
-use buffer::Cell;
-use layout::Rect;
-use style::{Color, Modifier};
-
-pub struct CrosstermBackend {
-    screen: crossterm::Screen,
+pub struct CrosstermBackend<W: Write> {
+    buffer: W,
 }
 
-impl CrosstermBackend {
-    pub fn new() -> CrosstermBackend {
-        CrosstermBackend {
-            screen: crossterm::Screen::default(),
-        }
-    }
-
-    pub fn screen(&self) -> &crossterm::Screen {
-        &self.screen
+impl<W> CrosstermBackend<W>
+where
+    W: Write,
+{
+    pub fn new(buffer: W) -> CrosstermBackend<W> {
+        CrosstermBackend { buffer }
     }
 }
 
-impl Backend for CrosstermBackend {
-    fn clear(&mut self) -> io::Result<()> {
-        let terminal = crossterm::terminal::terminal(&self.screen);
-        terminal.clear(crossterm::terminal::ClearType::All);
-        Ok(())
-    }
-
-    fn hide_cursor(&mut self) -> io::Result<()> {
-        let cursor = crossterm::cursor(&self.screen);
-        cursor.hide();
-        Ok(())
-    }
-
-    fn show_cursor(&mut self) -> io::Result<()> {
-        let cursor = crossterm::cursor(&self.screen);
-        cursor.show();
-        Ok(())
-    }
-
-    fn size(&self) -> io::Result<Rect> {
-        let terminal = crossterm::terminal::terminal(&self.screen);
-        let (width, height) = terminal.terminal_size();
-        Ok(Rect {
-            x: 0,
-            y: 0,
-            width,
-            height,
-        })
+impl<W> Write for CrosstermBackend<W>
+where
+    W: Write,
+{
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        self.buffer.write(buf)
     }
 
     fn flush(&mut self) -> io::Result<()> {
-        Ok(())
+        self.buffer.flush()
     }
+}
 
+impl<W> Backend for CrosstermBackend<W>
+where
+    W: Write,
+{
     fn draw<'a, I>(&mut self, content: I) -> io::Result<()>
     where
         I: Iterator<Item = (u16, u16, &'a Cell)>,
     {
-        let cursor = crossterm::cursor(&self.screen);
-        let mut last_y = 0;
-        let mut last_x = 0;
+        let mut fg = Color::Reset;
+        let mut bg = Color::Reset;
+        let mut modifier = Modifier::empty();
+        let mut last_pos: Option<(u16, u16)> = None;
         for (x, y, cell) in content {
-            if y != last_y || x != last_x + 1 {
-                cursor.goto(x + 1, y + 1);
+            // Move the cursor if the previous location was not (x - 1, y)
+            if !matches!(last_pos, Some(p) if x == p.0 + 1 && y == p.1) {
+                map_error(queue!(self.buffer, MoveTo(x, y)))?;
+            }
+            last_pos = Some((x, y));
+            if cell.modifier != modifier {
+                let diff = ModifierDiff {
+                    from: modifier,
+                    to: cell.modifier,
+                };
+                diff.queue(&mut self.buffer)?;
+                modifier = cell.modifier;
+            }
+            if cell.fg != fg {
+                let color = CColor::from(cell.fg);
+                map_error(queue!(self.buffer, SetForegroundColor(color)))?;
+                fg = cell.fg;
+            }
+            if cell.bg != bg {
+                let color = CColor::from(cell.bg);
+                map_error(queue!(self.buffer, SetBackgroundColor(color)))?;
+                bg = cell.bg;
             }
-            last_x = x;
-            last_y = y;
 
-            let mut s = 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);
+            map_error(queue!(self.buffer, Print(&cell.symbol)))?;
         }
+
+        map_error(queue!(
+            self.buffer,
+            SetForegroundColor(CColor::Reset),
+            SetBackgroundColor(CColor::Reset),
+            SetAttribute(CAttribute::Reset)
+        ))
+    }
+
+    fn hide_cursor(&mut self) -> io::Result<()> {
+        map_error(execute!(self.buffer, Hide))
+    }
+
+    fn show_cursor(&mut self) -> io::Result<()> {
+        map_error(execute!(self.buffer, Show))
+    }
+
+    fn get_cursor(&mut self) -> io::Result<(u16, u16)> {
+        crossterm::cursor::position()
+            .map_err(|e| io::Error::new(io::ErrorKind::Other, e.to_string()))
+    }
+
+    fn set_cursor(&mut self, x: u16, y: u16) -> io::Result<()> {
+        map_error(execute!(self.buffer, MoveTo(x, y)))
+    }
+
+    fn clear(&mut self) -> io::Result<()> {
+        map_error(execute!(self.buffer, Clear(ClearType::All)))
+    }
+
+    fn size(&self) -> io::Result<Rect> {
+        let (width, height) =
+            terminal::size().map_err(|e| io::Error::new(io::ErrorKind::Other, e.to_string()))?;
+
+        Ok(Rect::new(0, 0, width, height))
+    }
+
+    fn flush(&mut self) -> io::Result<()> {
+        self.buffer.flush()
+    }
+}
+
+fn map_error(error: crossterm::Result<()>) -> io::Result<()> {
+    error.map_err(|e| io::Error::new(io::ErrorKind::Other, e.to_string()))
+}
+
+impl From<Color> for CColor {
+    fn from(color: Color) -> Self {
+        match color {
+            Color::Reset => CColor::Reset,
+            Color::Black => CColor::Black,
+            Color::Red => CColor::DarkRed,
+            Color::Green => CColor::DarkGreen,
+            Color::Yellow => CColor::DarkYellow,
+            Color::Blue => CColor::DarkBlue,
+            Color::Magenta => CColor::DarkMagenta,
+            Color::Cyan => CColor::DarkCyan,
+            Color::Gray => CColor::Grey,
+            Color::DarkGray => CColor::DarkGrey,
+            Color::LightRed => CColor::Red,
+            Color::LightGreen => CColor::Green,
+            Color::LightBlue => CColor::Blue,
+            Color::LightYellow => CColor::Yellow,
+            Color::LightMagenta => CColor::Magenta,
+            Color::LightCyan => CColor::Cyan,
+            Color::White => CColor::White,
+            Color::Indexed(i) => CColor::AnsiValue(i),
+            Color::Rgb(r, g, b) => CColor::Rgb { r, g, b },
+        }
+    }
+}
+
+#[derive(Debug)]
+struct ModifierDiff {
+    pub from: Modifier,
+    pub to: Modifier,
+}
+
+impl ModifierDiff {
+    fn queue<W>(&self, mut w: W) -> io::Result<()>
+    where
+        W: io::Write,
+    {
+        //use crossterm::Attribute;
+        let removed = self.from - self.to;
+        if removed.contains(Modifier::REVERSED) {
+            map_error(queue!(w, SetAttribute(CAttribute::NoReverse)))?;
+        }
+        if removed.contains(Modifier::BOLD) {
+            map_error(queue!(w, SetAttribute(CAttribute::NormalIntensity)))?;
+            if self.to.contains(Modifier::DIM) {
+                map_error(queue!(w, SetAttribute(CAttribute::Dim)))?;
+            }
+        }
+        if removed.contains(Modifier::ITALIC) {
+            map_error(queue!(w, SetAttribute(CAttribute::NoItalic)))?;
+        }
+        if removed.contains(Modifier::UNDERLINED) {
+            map_error(queue!(w, SetAttribute(CAttribute::NoUnderline)))?;
+        }
+        if removed.contains(Modifier::DIM) {
+            map_error(queue!(w, SetAttribute(CAttribute::NormalIntensity)))?;
+        }
+        if removed.contains(Modifier::CROSSED_OUT) {
+            map_error(queue!(w, SetAttribute(CAttribute::NotCrossedOut)))?;
+        }
+        if removed.contains(Modifier::SLOW_BLINK) || removed.contains(Modifier::RAPID_BLINK) {
+            map_error(queue!(w, SetAttribute(CAttribute::NoBlink)))?;
+        }
+
+        let added = self.to - self.from;
+        if added.contains(Modifier::REVERSED) {
+            map_error(queue!(w, SetAttribute(CAttribute::Reverse)))?;
+        }
+        if added.contains(Modifier::BOLD) {
+            map_error(queue!(w, SetAttribute(CAttribute::Bold)))?;
+        }
+        if added.contains(Modifier::ITALIC) {
+            map_error(queue!(w, SetAttribute(CAttribute::Italic)))?;
+        }
+        if added.contains(Modifier::UNDERLINED) {
+            map_error(queue!(w, SetAttribute(CAttribute::Underlined)))?;
+        }
+        if added.contains(Modifier::DIM) {
+            map_error(queue!(w, SetAttribute(CAttribute::Dim)))?;
+        }
+        if added.contains(Modifier::CROSSED_OUT) {
+            map_error(queue!(w, SetAttribute(CAttribute::CrossedOut)))?;
+        }
+        if added.contains(Modifier::SLOW_BLINK) {
+            map_error(queue!(w, SetAttribute(CAttribute::SlowBlink)))?;
+        }
+        if added.contains(Modifier::RAPID_BLINK) {
+            map_error(queue!(w, SetAttribute(CAttribute::RapidBlink)))?;
+        }
+
         Ok(())
     }
 }
-
-impl From<Color> for Option<crossterm::Color> {
-    fn from(color: Color) -> Option<crossterm::Color> {
-        match color {
-            Color::Reset => None,
-            Color::Black => Some(crossterm::Color::Black),
-            Color::Red => Some(crossterm::Color::DarkRed),
-            Color::Green => Some(crossterm::Color::DarkGreen),
-            Color::Yellow => Some(crossterm::Color::DarkYellow),
-            Color::Blue => Some(crossterm::Color::DarkBlue),
-            Color::Magenta => Some(crossterm::Color::DarkMagenta),
-            Color::Cyan => Some(crossterm::Color::DarkCyan),
-            Color::Gray => Some(crossterm::Color::Grey),
-            Color::DarkGray => Some(crossterm::Color::Grey),
-            Color::LightRed => Some(crossterm::Color::Red),
-            Color::LightGreen => Some(crossterm::Color::Green),
-            Color::LightBlue => Some(crossterm::Color::Blue),
-            Color::LightYellow => Some(crossterm::Color::Yellow),
-            Color::LightMagenta => Some(crossterm::Color::Magenta),
-            Color::LightCyan => Some(crossterm::Color::Cyan),
-            Color::White => Some(crossterm::Color::White),
-            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,
-        }
-    }
-}

src/backend/curses.rs

@@ -0,0 +1,280 @@
+use std::io;
+
+use crate::backend::Backend;
+use crate::buffer::Cell;
+use crate::layout::Rect;
+use crate::style::{Color, Modifier};
+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 fg = Color::Reset;
+        let mut bg = Color::Reset;
+        let mut 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 {
+            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.modifier != modifier {
+                apply_modifier_diff(&mut self.curses.win, modifier, cell.modifier);
+                modifier = cell.modifier;
+            };
+            if cell.fg != fg {
+                update_color = true;
+                if let Some(ccolor) = cell.fg.into() {
+                    fg = cell.fg;
+                    curses_style.fg = ccolor;
+                } else {
+                    fg = Color::White;
+                    curses_style.fg = easycurses::Color::White;
+                }
+            };
+            if cell.bg != bg {
+                update_color = true;
+                if let Some(ccolor) = cell.bg.into() {
+                    bg = cell.bg;
+                    curses_style.bg = ccolor;
+                } else {
+                    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 (y, x) = 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(y), i32::from(x));
+        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_QUARTERS => pancurses::ACS_BLOCK(),
+            block::FIVE_EIGHTHS => pancurses::ACS_BLOCK(),
+            block::HALF => pancurses::ACS_BLOCK(),
+            block::THREE_EIGHTHS => ' ' as chtype,
+            block::ONE_QUARTER => ' ' as chtype,
+            block::ONE_EIGHTH => ' ' as chtype,
+            bar::SEVEN_EIGHTHS => pancurses::ACS_BLOCK(),
+            bar::THREE_QUARTERS => pancurses::ACS_BLOCK(),
+            bar::FIVE_EIGHTHS => pancurses::ACS_BLOCK(),
+            bar::HALF => pancurses::ACS_BLOCK(),
+            bar::THREE_EIGHTHS => pancurses::ACS_S9(),
+            bar::ONE_QUARTER => 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_QUARTERS => block::FULL,
+            block::FIVE_EIGHTHS => block::HALF,
+            block::THREE_EIGHTHS => block::HALF,
+            block::ONE_QUARTER => block::HALF,
+            block::ONE_EIGHTH => " ",
+            bar::SEVEN_EIGHTHS => bar::FULL,
+            bar::THREE_QUARTERS => bar::FULL,
+            bar::FIVE_EIGHTHS => bar::HALF,
+            bar::THREE_EIGHTHS => bar::HALF,
+            bar::ONE_QUARTER => 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;
@@ -11,19 +11,29 @@ pub use self::rustbox::RustboxBackend;
 #[cfg(feature = "termion")]
 mod termion;
 #[cfg(feature = "termion")]
-pub use self::termion::{AlternateScreenBackend, MouseBackend, RawBackend, TermionBackend};
+pub use self::termion::TermionBackend;
 
 #[cfg(feature = "crossterm")]
 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,20 +1,19 @@
-extern crate rustbox;
-
+use crate::{
+    backend::Backend,
+    buffer::Cell,
+    layout::Rect,
+    style::{Color, Modifier},
+};
 use std::io;
 
-use super::Backend;
-use buffer::Cell;
-use layout::Rect;
-use style::{Color, Modifier};
-
 pub struct RustboxBackend {
     rustbox: rustbox::RustBox,
 }
 
 impl RustboxBackend {
     pub fn new() -> Result<RustboxBackend, rustbox::InitError> {
-        let rustbox = try!(rustbox::RustBox::init(Default::default()));
-        Ok(RustboxBackend { rustbox: rustbox })
+        let rustbox = rustbox::RustBox::init(Default::default())?;
+        Ok(RustboxBackend { rustbox })
     }
 
     pub fn with_rustbox(instance: rustbox::RustBox) -> RustboxBackend {
@@ -31,19 +30,16 @@ impl Backend for RustboxBackend {
     where
         I: Iterator<Item = (u16, u16, &'a Cell)>,
     {
-        let mut inst = 0;
         for (x, y, cell) in content {
-            inst += 1;
             self.rustbox.print(
                 x as usize,
                 y as usize,
-                cell.style.modifier.into(),
-                cell.style.fg.into(),
-                cell.style.bg.into(),
+                cell.modifier.into(),
+                cell.fg.into(),
+                cell.bg.into(),
                 &cell.symbol,
             );
         }
-        debug!("{} instructions outputed", inst);
         Ok(())
     }
     fn hide_cursor(&mut self) -> Result<(), io::Error> {
@@ -52,17 +48,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 +100,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 +108,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,14 +1,13 @@
-extern crate termion;
-
-use std::io;
-use std::io::Write;
-
-use self::termion::raw::IntoRawMode;
-
 use super::Backend;
-use buffer::Cell;
-use layout::Rect;
-use style::{Color, Modifier, Style};
+use crate::{
+    buffer::Cell,
+    layout::Rect,
+    style::{Color, Modifier},
+};
+use std::{
+    fmt,
+    io::{self, Write},
+};
 
 pub struct TermionBackend<W>
 where
@@ -17,40 +16,11 @@ where
     stdout: W,
 }
 
-pub type RawBackend = TermionBackend<termion::raw::RawTerminal<io::Stdout>>;
-pub type MouseBackend =
-    TermionBackend<termion::input::MouseTerminal<termion::raw::RawTerminal<io::Stdout>>>;
-pub type AlternateScreenBackend =
-    TermionBackend<termion::screen::AlternateScreen<termion::raw::RawTerminal<io::Stdout>>>;
-
-impl RawBackend {
-    pub fn new() -> Result<RawBackend, io::Error> {
-        let raw = io::stdout().into_raw_mode()?;
-        Ok(TermionBackend::with_stdout(raw))
-    }
-}
-
-impl MouseBackend {
-    pub fn new() -> Result<MouseBackend, io::Error> {
-        let raw = io::stdout().into_raw_mode()?;
-        let mouse = termion::input::MouseTerminal::from(raw);
-        Ok(TermionBackend::with_stdout(mouse))
-    }
-}
-
-impl AlternateScreenBackend {
-    pub fn new() -> Result<AlternateScreenBackend, io::Error> {
-        let raw = io::stdout().into_raw_mode()?;
-        let screen = termion::screen::AlternateScreen::from(raw);
-        Ok(TermionBackend::with_stdout(screen))
-    }
-}
-
 impl<W> TermionBackend<W>
 where
     W: Write,
 {
-    pub fn with_stdout(stdout: W) -> TermionBackend<W> {
+    pub fn new(stdout: W) -> TermionBackend<W> {
         TermionBackend { stdout }
     }
 }
@@ -91,64 +61,70 @@ 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 last_y = 0;
-        let mut last_x = 0;
-        let mut inst = 0;
+        let mut fg = Color::Reset;
+        let mut bg = Color::Reset;
+        let mut modifier = Modifier::empty();
+        let mut last_pos: Option<(u16, u16)> = None;
         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)));
-                inst += 1;
+            // Move the cursor if the previous location was not (x - 1, y)
+            if !matches!(last_pos, Some(p) if x == p.0 + 1 && y == p.1) {
+                write!(string, "{}", termion::cursor::Goto(x + 1, y + 1)).unwrap();
             }
-            last_x = x;
-            last_y = y;
-            if cell.style.modifier != style.modifier {
-                string.push_str(&cell.style.modifier.termion_modifier());
-                style.modifier = cell.style.modifier;
-                if style.modifier == Modifier::Reset {
-                    style.bg = Color::Reset;
-                    style.fg = Color::Reset;
-                }
-                inst += 1;
+            last_pos = Some((x, y));
+            if cell.modifier != modifier {
+                write!(
+                    string,
+                    "{}",
+                    ModifierDiff {
+                        from: modifier,
+                        to: cell.modifier
+                    }
+                )
+                .unwrap();
+                modifier = cell.modifier;
             }
-            if cell.style.fg != style.fg {
-                string.push_str(&cell.style.fg.termion_fg());
-                style.fg = cell.style.fg;
-                inst += 1;
+            if cell.fg != fg {
+                write!(string, "{}", Fg(cell.fg)).unwrap();
+                fg = cell.fg;
             }
-            if cell.style.bg != style.bg {
-                string.push_str(&cell.style.bg.termion_bg());
-                style.bg = cell.style.bg;
-                inst += 1;
+            if cell.bg != bg {
+                write!(string, "{}", Bg(cell.bg)).unwrap();
+                bg = cell.bg;
             }
             string.push_str(&cell.symbol);
-            inst += 1;
         }
-        debug!("{} instructions outputed.", inst);
         write!(
             self.stdout,
             "{}{}{}{}",
             string,
-            Color::Reset.termion_fg(),
-            Color::Reset.termion_bg(),
-            Modifier::Reset.termion_modifier()
+            Fg(Color::Reset),
+            Bg(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 = termion::terminal_size()?;
+        Ok(Rect::new(0, 0, terminal.0, terminal.1))
     }
 
     fn flush(&mut self) -> io::Result<()> {
@@ -156,102 +132,129 @@ where
     }
 }
 
-macro_rules! termion_fg {
-    ($color:ident) => {
-        format!("{}", termion::color::Fg(termion::color::$color))
-    };
+struct Fg(Color);
+
+struct Bg(Color);
+
+struct ModifierDiff {
+    from: Modifier,
+    to: 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 as TermionColor;
+        match self.0 {
+            Color::Reset => termion::color::Reset.write_fg(f),
+            Color::Black => termion::color::Black.write_fg(f),
+            Color::Red => termion::color::Red.write_fg(f),
+            Color::Green => termion::color::Green.write_fg(f),
+            Color::Yellow => termion::color::Yellow.write_fg(f),
+            Color::Blue => termion::color::Blue.write_fg(f),
+            Color::Magenta => termion::color::Magenta.write_fg(f),
+            Color::Cyan => termion::color::Cyan.write_fg(f),
+            Color::Gray => termion::color::White.write_fg(f),
+            Color::DarkGray => termion::color::LightBlack.write_fg(f),
+            Color::LightRed => termion::color::LightRed.write_fg(f),
+            Color::LightGreen => termion::color::LightGreen.write_fg(f),
+            Color::LightBlue => termion::color::LightBlue.write_fg(f),
+            Color::LightYellow => termion::color::LightYellow.write_fg(f),
+            Color::LightMagenta => termion::color::LightMagenta.write_fg(f),
+            Color::LightCyan => termion::color::LightCyan.write_fg(f),
+            Color::White => termion::color::LightWhite.write_fg(f),
+            Color::Indexed(i) => termion::color::AnsiValue(i).write_fg(f),
+            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 as TermionColor;
+        match self.0 {
+            Color::Reset => termion::color::Reset.write_bg(f),
+            Color::Black => termion::color::Black.write_bg(f),
+            Color::Red => termion::color::Red.write_bg(f),
+            Color::Green => termion::color::Green.write_bg(f),
+            Color::Yellow => termion::color::Yellow.write_bg(f),
+            Color::Blue => termion::color::Blue.write_bg(f),
+            Color::Magenta => termion::color::Magenta.write_bg(f),
+            Color::Cyan => termion::color::Cyan.write_bg(f),
+            Color::Gray => termion::color::White.write_bg(f),
+            Color::DarkGray => termion::color::LightBlack.write_bg(f),
+            Color::LightRed => termion::color::LightRed.write_bg(f),
+            Color::LightGreen => termion::color::LightGreen.write_bg(f),
+            Color::LightBlue => termion::color::LightBlue.write_bg(f),
+            Color::LightYellow => termion::color::LightYellow.write_bg(f),
+            Color::LightMagenta => termion::color::LightMagenta.write_bg(f),
+            Color::LightCyan => termion::color::LightCyan.write_bg(f),
+            Color::White => termion::color::LightWhite.write_bg(f),
+            Color::Indexed(i) => termion::color::AnsiValue(i).write_bg(f),
+            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(Modifier::REVERSED) {
+            write!(f, "{}", termion::style::NoInvert)?;
         }
+        if remove.contains(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(Modifier::DIM) {
+                write!(f, "{}", termion::style::Faint)?;
+            }
+        }
+        if remove.contains(Modifier::ITALIC) {
+            write!(f, "{}", termion::style::NoItalic)?;
+        }
+        if remove.contains(Modifier::UNDERLINED) {
+            write!(f, "{}", termion::style::NoUnderline)?;
+        }
+        if remove.contains(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(Modifier::BOLD) {
+                write!(f, "{}", termion::style::Bold)?;
+            }
+        }
+        if remove.contains(Modifier::CROSSED_OUT) {
+            write!(f, "{}", termion::style::NoCrossedOut)?;
+        }
+        if remove.contains(Modifier::SLOW_BLINK) || remove.contains(Modifier::RAPID_BLINK) {
+            write!(f, "{}", termion::style::NoBlink)?;
+        }
+
+        let add = self.to - self.from;
+        if add.contains(Modifier::REVERSED) {
+            write!(f, "{}", termion::style::Invert)?;
+        }
+        if add.contains(Modifier::BOLD) {
+            write!(f, "{}", termion::style::Bold)?;
+        }
+        if add.contains(Modifier::ITALIC) {
+            write!(f, "{}", termion::style::Italic)?;
+        }
+        if add.contains(Modifier::UNDERLINED) {
+            write!(f, "{}", termion::style::Underline)?;
+        }
+        if add.contains(Modifier::DIM) {
+            write!(f, "{}", termion::style::Faint)?;
+        }
+        if add.contains(Modifier::CROSSED_OUT) {
+            write!(f, "{}", termion::style::CrossedOut)?;
+        }
+        if add.contains(Modifier::SLOW_BLINK) || add.contains(Modifier::RAPID_BLINK) {
+            write!(f, "{}", termion::style::Blink)?;
+        }
+
+        Ok(())
     }
 }

src/backend/test.rs

@@ -0,0 +1,144 @@
+use crate::{
+    backend::Backend,
+    buffer::{Buffer, Cell},
+    layout::Rect,
+};
+use std::{fmt::Write, io};
+use unicode_width::UnicodeWidthStr;
+
+/// A backend used for the integration tests.
+#[derive(Debug)]
+pub struct TestBackend {
+    width: u16,
+    buffer: Buffer,
+    height: u16,
+    cursor: bool,
+    pos: (u16, u16),
+}
+
+/// Returns a string representation of the given buffer for debugging purpose.
+fn buffer_view(buffer: &Buffer) -> String {
+    let mut view = String::with_capacity(buffer.content.len() + buffer.area.height as usize * 3);
+    for cells in buffer.content.chunks(buffer.area.width as usize) {
+        let mut overwritten = vec![];
+        let mut skip: usize = 0;
+        view.push('"');
+        for (x, c) in cells.iter().enumerate() {
+            if skip == 0 {
+                view.push_str(&c.symbol);
+            } else {
+                overwritten.push((x, &c.symbol))
+            }
+            skip = std::cmp::max(skip, c.symbol.width()).saturating_sub(1);
+        }
+        view.push('"');
+        if !overwritten.is_empty() {
+            write!(
+                &mut view,
+                " Hidden by multi-width symbols: {:?}",
+                overwritten
+            )
+            .unwrap();
+        }
+        view.push('\n');
+    }
+    view
+}
+
+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
+    }
+
+    pub fn assert_buffer(&self, expected: &Buffer) {
+        assert_eq!(expected.area, self.buffer.area);
+        let diff = expected.diff(&self.buffer);
+        if diff.is_empty() {
+            return;
+        }
+
+        let mut debug_info = String::from("Buffers are not equal");
+        debug_info.push('\n');
+        debug_info.push_str("Expected:");
+        debug_info.push('\n');
+        let expected_view = buffer_view(expected);
+        debug_info.push_str(&expected_view);
+        debug_info.push('\n');
+        debug_info.push_str("Got:");
+        debug_info.push('\n');
+        let view = buffer_view(&self.buffer);
+        debug_info.push_str(&view);
+        debug_info.push('\n');
+
+        debug_info.push_str("Diff:");
+        debug_info.push('\n');
+        let nice_diff = diff
+            .iter()
+            .enumerate()
+            .map(|(i, (x, y, cell))| {
+                let expected_cell = expected.get(*x, *y);
+                format!(
+                    "{}: at ({}, {}) expected {:?} got {:?}",
+                    i, x, y, expected_cell, cell
+                )
+            })
+            .collect::<Vec<String>>()
+            .join("\n");
+        debug_info.push_str(&nice_diff);
+        panic!(debug_info);
+    }
+}
+
+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 = c.clone();
+        }
+        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,16 +1,19 @@
+use crate::{
+    layout::Rect,
+    style::{Color, Modifier, Style},
+    text::{Span, Spans},
+};
 use std::cmp::min;
-use std::usize;
-
 use unicode_segmentation::UnicodeSegmentation;
-
-use layout::Rect;
-use style::{Color, Modifier, Style};
+use unicode_width::UnicodeWidthStr;
 
 /// A buffer cell
 #[derive(Debug, Clone, PartialEq)]
 pub struct Cell {
     pub symbol: String,
-    pub style: Style,
+    pub fg: Color,
+    pub bg: Color,
+    pub modifier: Modifier,
 }
 
 impl Cell {
@@ -27,29 +30,40 @@ impl Cell {
     }
 
     pub fn set_fg(&mut self, color: Color) -> &mut Cell {
-        self.style.fg = color;
+        self.fg = color;
         self
     }
 
     pub fn set_bg(&mut self, color: Color) -> &mut Cell {
-        self.style.bg = color;
-        self
-    }
-
-    pub fn set_modifier(&mut self, modifier: Modifier) -> &mut Cell {
-        self.style.modifier = modifier;
+        self.bg = color;
         self
     }
 
     pub fn set_style(&mut self, style: Style) -> &mut Cell {
-        self.style = style;
+        if let Some(c) = style.fg {
+            self.fg = c;
+        }
+        if let Some(c) = style.bg {
+            self.bg = c;
+        }
+        self.modifier.insert(style.add_modifier);
+        self.modifier.remove(style.sub_modifier);
         self
     }
 
+    pub fn style(&self) -> Style {
+        Style::default()
+            .fg(self.fg)
+            .bg(self.bg)
+            .add_modifier(self.modifier)
+    }
+
     pub fn reset(&mut self) {
         self.symbol.clear();
         self.symbol.push(' ');
-        self.style.reset();
+        self.fg = Color::Reset;
+        self.bg = Color::Reset;
+        self.modifier = Modifier::empty();
     }
 }
 
@@ -57,7 +71,9 @@ impl Default for Cell {
     fn default() -> Cell {
         Cell {
             symbol: " ".into(),
-            style: Default::default(),
+            fg: Color::Reset,
+            bg: Color::Reset,
+            modifier: Modifier::empty(),
         }
     }
 }
@@ -72,28 +88,24 @@ impl Default for Cell {
 /// # Examples:
 ///
 /// ```
-/// # extern crate tui;
 /// use tui::buffer::{Buffer, Cell};
 /// use tui::layout::Rect;
 /// use tui::style::{Color, Style, Modifier};
 ///
-/// # fn main() {
 /// let mut buf = Buffer::empty(Rect{x: 0, y: 0, width: 10, height: 5});
 /// buf.get_mut(0, 2).set_symbol("x");
 /// assert_eq!(buf.get(0, 2).symbol, "x");
 /// buf.set_string(3, 0, "string", Style::default().fg(Color::Red).bg(Color::White));
 /// assert_eq!(buf.get(5, 0), &Cell{
 ///     symbol: String::from("r"),
-///     style: Style {
-///         fg: Color::Red,
-///         bg: Color::White,
-///         modifier: Modifier::Reset
-///     }});
+///     fg: Color::Red,
+///     bg: Color::White,
+///     modifier: Modifier::empty()
+/// });
 /// buf.get_mut(5, 0).set_char('x');
 /// assert_eq!(buf.get(5, 0).symbol, "x");
-/// # }
 /// ```
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct Buffer {
     /// The area represented by this buffer
     pub area: Rect,
@@ -128,6 +140,29 @@ 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()
+            .map(|i| i.as_ref().width() as u16)
+            .max()
+            .unwrap_or_default();
+        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 +277,86 @@ 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,
+    ) -> (u16, u16)
     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();
+            if width == 0 {
+                continue;
+            }
+            // `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;
+        }
+        (x_offset as u16, y)
+    }
+
+    pub fn set_spans<'a>(&mut self, x: u16, y: u16, spans: &Spans<'a>, width: u16) -> (u16, u16) {
+        let mut remaining_width = width;
+        let mut x = x;
+        for span in &spans.0 {
+            if remaining_width == 0 {
+                break;
+            }
+            let pos = self.set_stringn(
+                x,
+                y,
+                span.content.as_ref(),
+                remaining_width as usize,
+                span.style,
+            );
+            let w = pos.0.saturating_sub(x);
+            x = pos.0;
+            remaining_width = remaining_width.saturating_sub(w);
+        }
+        (x, y)
+    }
+
+    pub fn set_span<'a>(&mut self, x: u16, y: u16, span: &Span<'a>, width: u16) -> (u16, u16) {
+        self.set_stringn(x, y, span.content.as_ref(), width as usize, span.style)
+    }
+
+    #[deprecated(
+        since = "0.10.0",
+        note = "You should use styling capabilities of `Buffer::set_style`"
+    )]
+    pub fn set_background(&mut self, area: Rect, color: Color) {
+        for y in area.top()..area.bottom() {
+            for x in area.left()..area.right() {
+                self.get_mut(x, y).set_bg(color);
+            }
+        }
+    }
+
+    pub fn set_style(&mut self, area: Rect, style: Style) {
+        for y in area.top()..area.bottom() {
+            for x in area.left()..area.right() {
+                self.get_mut(x, y).set_style(style);
+            }
         }
     }
 
@@ -283,38 +386,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 +507,239 @@ 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_zero_width() {
+        let area = Rect::new(0, 0, 1, 1);
+        let mut buffer = Buffer::empty(area);
+
+        // Leading grapheme with zero width
+        let s = "\u{1}a";
+        buffer.set_stringn(0, 0, s, 1, Style::default());
+        assert_eq!(buffer, Buffer::with_lines(vec!["a"]));
+
+        // Trailing grapheme with zero with
+        let s = "a\u{1}";
+        buffer.set_stringn(0, 0, s, 1, Style::default());
+        assert_eq!(buffer, Buffer::with_lines(vec!["a"]));
+    }
+
+    #[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,11 +24,33 @@ pub enum Direction {
 pub enum Constraint {
     // TODO: enforce range 0 - 100
     Percentage(u16),
+    Ratio(u32, u32),
     Length(u16),
     Max(u16),
     Min(u16),
 }
 
+impl Constraint {
+    pub fn apply(&self, length: u16) -> u16 {
+        match *self {
+            Constraint::Percentage(p) => length * p / 100,
+            Constraint::Ratio(num, den) => {
+                let r = num * u32::from(length) / den;
+                r as u16
+            }
+            Constraint::Length(l) => length.min(l),
+            Constraint::Max(m) => length.min(m),
+            Constraint::Min(m) => length.max(m),
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct Margin {
+    pub vertical: u16,
+    pub horizontal: u16,
+}
+
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub enum Alignment {
     Left,
@@ -36,11 +58,10 @@ pub enum Alignment {
     Right,
 }
 
-// TODO: enforce constraints size once const generics has landed
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Layout {
     direction: Direction,
-    margin: u16,
+    margin: Margin,
     constraints: Vec<Constraint>,
 }
 
@@ -52,7 +73,10 @@ impl Default for Layout {
     fn default() -> Layout {
         Layout {
             direction: Direction::Vertical,
-            margin: 0,
+            margin: Margin {
+                horizontal: 0,
+                vertical: 0,
+            },
             constraints: Vec::new(),
         }
     }
@@ -68,7 +92,20 @@ impl Layout {
     }
 
     pub fn margin(mut self, margin: u16) -> Layout {
-        self.margin = margin;
+        self.margin = Margin {
+            horizontal: margin,
+            vertical: margin,
+        };
+        self
+    }
+
+    pub fn horizontal_margin(mut self, horizontal: u16) -> Layout {
+        self.margin.horizontal = horizontal;
+        self
+    }
+
+    pub fn vertical_margin(mut self, vertical: u16) -> Layout {
+        self.margin.vertical = vertical;
         self
     }
 
@@ -82,25 +119,67 @@ impl Layout {
     ///
     /// # Examples
     /// ```
-    /// # extern crate tui;
     /// # use tui::layout::{Rect, Constraint, Direction, Layout};
+    /// 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
+    ///         }
+    ///     ]
+    /// );
     ///
-    /// # 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::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
+    ///         }
+    ///     ]
+    /// );
     /// ```
-    pub fn split(self, area: Rect) -> Vec<Rect> {
+    pub fn split(&self, area: Rect) -> Vec<Rect> {
         // TODO: Maybe use a fixed size cache ?
         LAYOUT_CACHE.with(|c| {
             c.borrow_mut()
                 .entry((area, self.clone()))
-                .or_insert_with(|| split(area, &self))
+                .or_insert_with(|| split(area, self))
                 .clone()
         })
     }
@@ -120,7 +199,7 @@ fn split(area: Rect, layout: &Layout) -> Vec<Rect> {
         .map(|_| Rect::default())
         .collect::<Vec<Rect>>();
 
-    let dest_area = area.inner(layout.margin);
+    let dest_area = area.inner(&layout.margin);
     for (i, e) in elements.iter().enumerate() {
         vars.insert(e.x, (i, 0));
         vars.insert(e.y, (i, 1));
@@ -130,6 +209,8 @@ fn split(area: Rect, layout: &Layout) -> Vec<Rect> {
     let mut ccs: Vec<CassowaryConstraint> =
         Vec::with_capacity(elements.len() * 4 + layout.constraints.len() * 6);
     for elt in &elements {
+        ccs.push(elt.width | GE(REQUIRED) | 0f64);
+        ccs.push(elt.height | GE(REQUIRED) | 0f64);
         ccs.push(elt.left() | GE(REQUIRED) | f64::from(dest_area.left()));
         ccs.push(elt.top() | GE(REQUIRED) | f64::from(dest_area.top()));
         ccs.push(elt.right() | LE(REQUIRED) | f64::from(dest_area.right()));
@@ -160,6 +241,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 +263,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 +370,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,
         }
     }
 
@@ -308,15 +412,15 @@ impl Rect {
         self.y + self.height
     }
 
-    pub fn inner(self, margin: u16) -> Rect {
-        if self.width < 2 * margin || self.height < 2 * margin {
+    pub fn inner(self, margin: &Margin) -> Rect {
+        if self.width < 2 * margin.horizontal || self.height < 2 * margin.vertical {
             Rect::default()
         } else {
             Rect {
-                x: self.x + margin,
-                y: self.y + margin,
-                width: self.width - 2 * margin,
-                height: self.height - 2 * margin,
+                x: self.x + margin.horizontal,
+                y: self.y + margin.vertical,
+                width: self.width - 2 * margin.horizontal,
+                height: self.height - 2 * margin.vertical,
             }
         }
     }
@@ -354,3 +458,77 @@ impl Rect {
             && self.y + self.height > other.y
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_vertical_split_by_height() {
+        let target = Rect {
+            x: 2,
+            y: 2,
+            width: 10,
+            height: 10,
+        };
+
+        let chunks = Layout::default()
+            .direction(Direction::Vertical)
+            .constraints(
+                [
+                    Constraint::Percentage(10),
+                    Constraint::Max(5),
+                    Constraint::Min(1),
+                ]
+                .as_ref(),
+            )
+            .split(target);
+
+        assert_eq!(target.height, chunks.iter().map(|r| r.height).sum::<u16>());
+        chunks.windows(2).for_each(|w| assert!(w[0].y <= w[1].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

@@ -1,94 +1,99 @@
 //! [tui](https://github.com/fdehau/tui-rs) is a library used to build rich
 //! terminal users interfaces and dashboards.
 //!
-//! ![](https://raw.githubusercontent.com/fdehau/tui-rs/master/docs/demo.gif)
+//! ![](https://raw.githubusercontent.com/fdehau/tui-rs/master/assets/demo.gif)
 //!
 //! # Get started
 //!
-//! ## 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.
-//!
-//! ```rust,no_run
-//! extern crate tui;
-//!
-//! use tui::Terminal;
-//! use tui::backend::RawBackend;
-//!
-//! fn main() {
-//!     let backend = RawBackend::new().unwrap();
-//!     let mut terminal = Terminal::new(backend).unwrap();
-//! }
-//! ```
-//!
-//! If for some reason, you might want to use the `rustbox` backend instead, you
-//! need the to replace your `tui` dependency specification by:
+//! ## Adding `tui` as a dependency
 //!
 //! ```toml
-//! [dependencies.tui]
-//! version = "0.2.0"
-//! default-features = false
-//! features = ['rustbox']
+//! [dependencies]
+//! tui = "0.12"
+//! termion = "1.5"
 //! ```
 //!
-//! and then create the terminal in a similar way:
+//! The crate is using the `termion` backend by default but if for example you want your
+//! application to work on Windows, you might want to use the `crossterm` backend instead. This can
+//! be done by changing your dependencies specification to the following:
 //!
-//! ```rust,ignore
-//! extern crate tui;
+//! ```toml
+//! [dependencies]
+//! crossterm = "0.18"
+//! tui = { version = "0.12", default-features = false, features = ['crossterm'] }
+//! ```
 //!
+//! 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.
+//!
+//! ```rust,no_run
+//! use std::io;
 //! use tui::Terminal;
-//! use tui::backend::RustboxBackend;
+//! use tui::backend::TermionBackend;
+//! use termion::raw::IntoRawMode;
 //!
-//! fn main() {
-//!     let backend = RustboxBackend::new().unwrap();
-//!     let mut terminal = Terminal::new(backend).unwrap();
+//! fn main() -> Result<(), io::Error> {
+//!     let stdout = io::stdout().into_raw_mode()?;
+//!     let backend = TermionBackend::new(stdout);
+//!     let mut terminal = Terminal::new(backend)?;
+//!     Ok(())
 //! }
 //! ```
 //!
+//! If you had previously chosen `crossterm` as a backend, the terminal can be created in a similar
+//! way:
+//!
+//! ```rust,ignore
+//! use std::io;
+//! use tui::Terminal;
+//! use tui::backend::CrosstermBackend;
+//!
+//! fn main() -> Result<(), io::Error> {
+//!     let stdout = io::stdout();
+//!     let backend = CrosstermBackend::new(stdout);
+//!     let mut terminal = Terminal::new(backend)?;
+//!     Ok(())
+//! }
+//! ```
+//!
+//! 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 meet most of your use cases. You are also free to
+//! implement your own.
 //!
-//! 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 rendered using the [`Frame::render_widget`] which take
+//! your widget instance an area to draw to.
 //!
 //! The following example renders a block of the size of the terminal:
 //!
 //! ```rust,no_run
-//! extern crate tui;
-//!
 //! use std::io;
-//!
+//! use termion::raw::IntoRawMode;
 //! use tui::Terminal;
-//! use tui::backend::RawBackend;
+//! use tui::backend::TermionBackend;
 //! use tui::widgets::{Widget, Block, Borders};
 //! use tui::layout::{Layout, Constraint, Direction};
 //!
-//! fn main() {
-//!     let mut terminal = init().expect("Failed initialization");
-//!     draw(&mut terminal).expect("Failed to draw");
-//! }
-//!
-//! fn init() -> Result<Terminal<RawBackend>, io::Error> {
-//!     let backend = RawBackend::new()?;
-//!     Terminal::new(backend)
-//! }
-//!
-//! fn draw(t: &mut Terminal<RawBackend>) -> Result<(), io::Error> {
-//!
-//!     let size = t.size()?;
-//!     t.draw(|mut f| {
-//!         Block::default()
+//! fn main() -> Result<(), io::Error> {
+//!     let stdout = io::stdout().into_raw_mode()?;
+//!     let backend = TermionBackend::new(stdout);
+//!     let mut terminal = Terminal::new(backend)?;
+//!     terminal.draw(|f| {
+//!         let size = f.size();
+//!         let block = Block::default()
 //!             .title("Block")
-//!             .borders(Borders::ALL)
-//!             .render(&mut f, size);
+//!             .borders(Borders::ALL);
+//!         f.render_widget(block, size);
 //!     })
 //! }
 //! ```
@@ -100,29 +105,18 @@
 //! full customization. And `Layout` is no exception:
 //!
 //! ```rust,no_run
-//! extern crate tui;
-//!
 //! use std::io;
-//!
+//! use termion::raw::IntoRawMode;
 //! use tui::Terminal;
-//! use tui::backend::RawBackend;
+//! use tui::backend::TermionBackend;
 //! use tui::widgets::{Widget, Block, Borders};
 //! use tui::layout::{Layout, Constraint, Direction};
 //!
-//! fn main() {
-//!     let mut terminal = init().expect("Failed initialization");
-//!     draw(&mut terminal).expect("Failed to draw");
-//! }
-//!
-//! fn init() -> Result<Terminal<RawBackend>, io::Error> {
-//!     let backend = RawBackend::new()?;
-//!     Terminal::new(backend)
-//! }
-//!
-//! fn draw(t: &mut Terminal<RawBackend>) -> Result<(), io::Error> {
-//!
-//!     let size = t.size()?;
-//!     t.draw(|mut f| {
+//! fn main() -> Result<(), io::Error> {
+//!     let stdout = io::stdout().into_raw_mode()?;
+//!     let backend = TermionBackend::new(stdout);
+//!     let mut terminal = Terminal::new(backend)?;
+//!     terminal.draw(|f| {
 //!         let chunks = Layout::default()
 //!             .direction(Direction::Vertical)
 //!             .margin(1)
@@ -133,33 +127,23 @@
 //!                     Constraint::Percentage(10)
 //!                 ].as_ref()
 //!             )
-//!             .split(size);
-//!         Block::default()
+//!             .split(f.size());
+//!         let block = Block::default()
 //!              .title("Block")
-//!              .borders(Borders::ALL)
-//!              .render(&mut f, chunks[0]);
-//!         Block::default()
+//!              .borders(Borders::ALL);
+//!         f.render_widget(block, chunks[0]);
+//!         let block = Block::default()
 //!              .title("Block 2")
-//!              .borders(Borders::ALL)
-//!              .render(&mut f, chunks[2]);
+//!              .borders(Borders::ALL);
+//!         f.render_widget(block, chunks[1]);
 //!     })
 //! }
 //! ```
 //!
-//! 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;
@@ -167,6 +151,7 @@ pub mod layout;
 pub mod style;
 pub mod symbols;
 pub mod terminal;
+pub mod text;
 pub mod widgets;
 
-pub use self::terminal::{Frame, Terminal};
+pub use self::terminal::{Frame, Terminal, TerminalOptions, Viewport};

src/style.rs

@@ -1,4 +1,9 @@
+//! `style` contains the primitives used to control how your user interface will look.
+
+use bitflags::bitflags;
+
 #[derive(Debug, Clone, Copy, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub enum Color {
     Reset,
     Black,
@@ -18,62 +23,197 @@ 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,
+bitflags! {
+    /// Modifier changes the way a piece of text is displayed.
+    ///
+    /// They are bitflags so they can easily be composed.
+    ///
+    /// ## Examples
+    ///
+    /// ```rust
+    /// # use tui::style::Modifier;
+    ///
+    /// let m = Modifier::BOLD | Modifier::ITALIC;
+    /// ```
+    #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+    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;
+    }
 }
 
+/// Style let you control the main characteristics of the displayed elements.
+///
+/// ## Examples
+///
+/// ```rust
+/// # use tui::style::{Color, Modifier, Style};
+/// Style::default()
+///     .fg(Color::Black)
+///     .bg(Color::Green)
+///     .add_modifier(Modifier::ITALIC | Modifier::BOLD);
+/// ```
 #[derive(Debug, Clone, Copy, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Style {
-    pub fg: Color,
-    pub bg: Color,
-    pub modifier: Modifier,
+    pub fg: Option<Color>,
+    pub bg: Option<Color>,
+    pub add_modifier: Modifier,
+    pub sub_modifier: Modifier,
 }
 
 impl Default for Style {
     fn default() -> Style {
         Style {
-            fg: Color::Reset,
-            bg: Color::Reset,
-            modifier: Modifier::Reset,
+            fg: None,
+            bg: None,
+            add_modifier: Modifier::empty(),
+            sub_modifier: Modifier::empty(),
         }
     }
 }
 
 impl Style {
-    pub fn reset(&mut self) {
-        self.fg = Color::Reset;
-        self.bg = Color::Reset;
-        self.modifier = Modifier::Reset;
+    /// Changes the foreground color.
+    ///
+    /// ## Examples
+    ///
+    /// ```rust
+    /// # use tui::style::{Color, Style};
+    /// let style = Style::default().fg(Color::Blue);
+    /// let diff = Style::default().fg(Color::Red);
+    /// assert_eq!(style.patch(diff), Style::default().fg(Color::Red));
+    /// ```
+    pub fn fg(mut self, color: Color) -> Style {
+        self.fg = Some(color);
+        self
     }
 
-    pub fn fg(mut self, color: Color) -> Style {
-        self.fg = color;
-        self
-    }
+    /// Changes the background color.
+    ///
+    /// ## Examples
+    ///
+    /// ```rust
+    /// # use tui::style::{Color, Style};
+    /// let style = Style::default().bg(Color::Blue);
+    /// let diff = Style::default().bg(Color::Red);
+    /// assert_eq!(style.patch(diff), Style::default().bg(Color::Red));
+    /// ```
     pub fn bg(mut self, color: Color) -> Style {
-        self.bg = color;
+        self.bg = Some(color);
         self
     }
-    pub fn modifier(mut self, modifier: Modifier) -> Style {
-        self.modifier = modifier;
+
+    /// Changes the text emphasis.
+    ///
+    /// When applied, it adds the given modifier to the `Style` modifiers.
+    ///
+    /// ## Examples
+    ///
+    /// ```rust
+    /// # use tui::style::{Color, Modifier, Style};
+    /// let style = Style::default().add_modifier(Modifier::BOLD);
+    /// let diff = Style::default().add_modifier(Modifier::ITALIC);
+    /// let patched = style.patch(diff);
+    /// assert_eq!(patched.add_modifier, Modifier::BOLD | Modifier::ITALIC);
+    /// assert_eq!(patched.sub_modifier, Modifier::empty());
+    /// ```
+    pub fn add_modifier(mut self, modifier: Modifier) -> Style {
+        self.sub_modifier.remove(modifier);
+        self.add_modifier.insert(modifier);
+        self
+    }
+
+    /// Changes the text emphasis.
+    ///
+    /// When applied, it removes the given modifier from the `Style` modifiers.
+    ///
+    /// ## Examples
+    ///
+    /// ```rust
+    /// # use tui::style::{Color, Modifier, Style};
+    /// let style = Style::default().add_modifier(Modifier::BOLD | Modifier::ITALIC);
+    /// let diff = Style::default().remove_modifier(Modifier::ITALIC);
+    /// let patched = style.patch(diff);
+    /// assert_eq!(patched.add_modifier, Modifier::BOLD);
+    /// assert_eq!(patched.sub_modifier, Modifier::ITALIC);
+    /// ```
+    pub fn remove_modifier(mut self, modifier: Modifier) -> Style {
+        self.add_modifier.remove(modifier);
+        self.sub_modifier.insert(modifier);
+        self
+    }
+
+    /// Results in a combined style that is equivalent to applying the two individual styles to
+    /// a style one after the other.
+    ///
+    /// ## Examples
+    /// ```
+    /// # use tui::style::{Color, Modifier, Style};
+    /// let style_1 = Style::default().fg(Color::Yellow);
+    /// let style_2 = Style::default().bg(Color::Red);
+    /// let combined = style_1.patch(style_2);
+    /// assert_eq!(
+    ///     Style::default().patch(style_1).patch(style_2),
+    ///     Style::default().patch(combined));
+    /// ```
+    pub fn patch(mut self, other: Style) -> Style {
+        self.fg = other.fg.or(self.fg);
+        self.bg = other.bg.or(self.bg);
+
+        self.add_modifier.remove(other.sub_modifier);
+        self.add_modifier.insert(other.add_modifier);
+        self.sub_modifier.remove(other.add_modifier);
+        self.sub_modifier.insert(other.sub_modifier);
+
         self
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn styles() -> Vec<Style> {
+        vec![
+            Style::default(),
+            Style::default().fg(Color::Yellow),
+            Style::default().bg(Color::Yellow),
+            Style::default().add_modifier(Modifier::BOLD),
+            Style::default().remove_modifier(Modifier::BOLD),
+            Style::default().add_modifier(Modifier::ITALIC),
+            Style::default().remove_modifier(Modifier::ITALIC),
+            Style::default().add_modifier(Modifier::ITALIC | Modifier::BOLD),
+            Style::default().remove_modifier(Modifier::ITALIC | Modifier::BOLD),
+        ]
+    }
+
+    #[test]
+    fn combined_patch_gives_same_result_as_individual_patch() {
+        let styles = styles();
+        for &a in &styles {
+            for &b in &styles {
+                for &c in &styles {
+                    for &d in &styles {
+                        let combined = a.patch(b.patch(c.patch(d)));
+
+                        assert_eq!(
+                            Style::default().patch(a).patch(b).patch(c).patch(d),
+                            Style::default().patch(combined)
+                        );
+                    }
+                }
+            }
+        }
+    }
+}

src/symbols.rs

@@ -1,36 +1,233 @@
 pub mod block {
     pub const FULL: &str = "█";
     pub const SEVEN_EIGHTHS: &str = "▉";
-    pub const THREE_QUATERS: &str = "▊";
+    pub const THREE_QUARTERS: &str = "▊";
     pub const FIVE_EIGHTHS: &str = "▋";
     pub const HALF: &str = "▌";
     pub const THREE_EIGHTHS: &str = "▍";
-    pub const ONE_QUATER: &str = "▎";
+    pub const ONE_QUARTER: &str = "▎";
     pub const ONE_EIGHTH: &str = "▏";
+
+    #[derive(Debug, Clone)]
+    pub struct Set {
+        pub full: &'static str,
+        pub seven_eighths: &'static str,
+        pub three_quarters: &'static str,
+        pub five_eighths: &'static str,
+        pub half: &'static str,
+        pub three_eighths: &'static str,
+        pub one_quarter: &'static str,
+        pub one_eighth: &'static str,
+        pub empty: &'static str,
+    }
+
+    pub const THREE_LEVELS: Set = Set {
+        full: FULL,
+        seven_eighths: FULL,
+        three_quarters: HALF,
+        five_eighths: HALF,
+        half: HALF,
+        three_eighths: HALF,
+        one_quarter: HALF,
+        one_eighth: " ",
+        empty: " ",
+    };
+
+    pub const NINE_LEVELS: Set = Set {
+        full: FULL,
+        seven_eighths: SEVEN_EIGHTHS,
+        three_quarters: THREE_QUARTERS,
+        five_eighths: FIVE_EIGHTHS,
+        half: HALF,
+        three_eighths: THREE_EIGHTHS,
+        one_quarter: ONE_QUARTER,
+        one_eighth: ONE_EIGHTH,
+        empty: " ",
+    };
 }
 
 pub mod bar {
     pub const FULL: &str = "█";
     pub const SEVEN_EIGHTHS: &str = "▇";
-    pub const THREE_QUATERS: &str = "▆";
+    pub const THREE_QUARTERS: &str = "▆";
     pub const FIVE_EIGHTHS: &str = "▅";
     pub const HALF: &str = "▄";
     pub const THREE_EIGHTHS: &str = "▃";
-    pub const ONE_QUATER: &str = "▂";
+    pub const ONE_QUARTER: &str = "▂";
     pub const ONE_EIGHTH: &str = "▁";
+
+    #[derive(Debug, Clone)]
+    pub struct Set {
+        pub full: &'static str,
+        pub seven_eighths: &'static str,
+        pub three_quarters: &'static str,
+        pub five_eighths: &'static str,
+        pub half: &'static str,
+        pub three_eighths: &'static str,
+        pub one_quarter: &'static str,
+        pub one_eighth: &'static str,
+        pub empty: &'static str,
+    }
+
+    pub const THREE_LEVELS: Set = Set {
+        full: FULL,
+        seven_eighths: FULL,
+        three_quarters: HALF,
+        five_eighths: HALF,
+        half: HALF,
+        three_eighths: HALF,
+        one_quarter: HALF,
+        one_eighth: " ",
+        empty: " ",
+    };
+
+    pub const NINE_LEVELS: Set = Set {
+        full: FULL,
+        seven_eighths: SEVEN_EIGHTHS,
+        three_quarters: THREE_QUARTERS,
+        five_eighths: FIVE_EIGHTHS,
+        half: HALF,
+        three_eighths: THREE_EIGHTHS,
+        one_quarter: ONE_QUARTER,
+        one_eighth: ONE_EIGHTH,
+        empty: " ",
+    };
 }
 
 pub mod line {
-    pub const TOP_RIGHT: &str = "┐";
     pub const VERTICAL: &str = "│";
+    pub const DOUBLE_VERTICAL: &str = "║";
+    pub const THICK_VERTICAL: &str = "┃";
+
     pub const HORIZONTAL: &str = "─";
+    pub const DOUBLE_HORIZONTAL: &str = "═";
+    pub const THICK_HORIZONTAL: &str = "━";
+
+    pub const TOP_RIGHT: &str = "┐";
+    pub const ROUNDED_TOP_RIGHT: &str = "╮";
+    pub const DOUBLE_TOP_RIGHT: &str = "╗";
+    pub const THICK_TOP_RIGHT: &str = "┓";
+
     pub const TOP_LEFT: &str = "┌";
+    pub const ROUNDED_TOP_LEFT: &str = "╭";
+    pub const DOUBLE_TOP_LEFT: &str = "╔";
+    pub const THICK_TOP_LEFT: &str = "┏";
+
     pub const BOTTOM_RIGHT: &str = "┘";
+    pub const ROUNDED_BOTTOM_RIGHT: &str = "╯";
+    pub const DOUBLE_BOTTOM_RIGHT: &str = "╝";
+    pub const THICK_BOTTOM_RIGHT: &str = "┛";
+
     pub const BOTTOM_LEFT: &str = "└";
+    pub const ROUNDED_BOTTOM_LEFT: &str = "╰";
+    pub const DOUBLE_BOTTOM_LEFT: &str = "╚";
+    pub const THICK_BOTTOM_LEFT: &str = "┗";
+
     pub const VERTICAL_LEFT: &str = "┤";
+    pub const DOUBLE_VERTICAL_LEFT: &str = "╣";
+    pub const THICK_VERTICAL_LEFT: &str = "┫";
+
     pub const VERTICAL_RIGHT: &str = "├";
+    pub const DOUBLE_VERTICAL_RIGHT: &str = "╠";
+    pub const THICK_VERTICAL_RIGHT: &str = "┣";
+
     pub const HORIZONTAL_DOWN: &str = "┬";
+    pub const DOUBLE_HORIZONTAL_DOWN: &str = "╦";
+    pub const THICK_HORIZONTAL_DOWN: &str = "┳";
+
     pub const HORIZONTAL_UP: &str = "┴";
+    pub const DOUBLE_HORIZONTAL_UP: &str = "╩";
+    pub const THICK_HORIZONTAL_UP: &str = "┻";
+
+    pub const CROSS: &str = "┼";
+    pub const DOUBLE_CROSS: &str = "╬";
+    pub const THICK_CROSS: &str = "╋";
+
+    #[derive(Debug, Clone)]
+    pub struct Set {
+        pub vertical: &'static str,
+        pub horizontal: &'static str,
+        pub top_right: &'static str,
+        pub top_left: &'static str,
+        pub bottom_right: &'static str,
+        pub bottom_left: &'static str,
+        pub vertical_left: &'static str,
+        pub vertical_right: &'static str,
+        pub horizontal_down: &'static str,
+        pub horizontal_up: &'static str,
+        pub cross: &'static str,
+    }
+
+    pub const NORMAL: Set = Set {
+        vertical: VERTICAL,
+        horizontal: HORIZONTAL,
+        top_right: TOP_RIGHT,
+        top_left: TOP_LEFT,
+        bottom_right: BOTTOM_RIGHT,
+        bottom_left: BOTTOM_LEFT,
+        vertical_left: VERTICAL_LEFT,
+        vertical_right: VERTICAL_RIGHT,
+        horizontal_down: HORIZONTAL_DOWN,
+        horizontal_up: HORIZONTAL_UP,
+        cross: CROSS,
+    };
+
+    pub const ROUNDED: Set = Set {
+        top_right: ROUNDED_TOP_RIGHT,
+        top_left: ROUNDED_TOP_LEFT,
+        bottom_right: ROUNDED_BOTTOM_RIGHT,
+        bottom_left: ROUNDED_BOTTOM_LEFT,
+        ..NORMAL
+    };
+
+    pub const DOUBLE: Set = Set {
+        vertical: DOUBLE_VERTICAL,
+        horizontal: DOUBLE_HORIZONTAL,
+        top_right: DOUBLE_TOP_RIGHT,
+        top_left: DOUBLE_TOP_LEFT,
+        bottom_right: DOUBLE_BOTTOM_RIGHT,
+        bottom_left: DOUBLE_BOTTOM_LEFT,
+        vertical_left: DOUBLE_VERTICAL_LEFT,
+        vertical_right: DOUBLE_VERTICAL_RIGHT,
+        horizontal_down: DOUBLE_HORIZONTAL_DOWN,
+        horizontal_up: DOUBLE_HORIZONTAL_UP,
+        cross: DOUBLE_CROSS,
+    };
+
+    pub const THICK: Set = Set {
+        vertical: THICK_VERTICAL,
+        horizontal: THICK_HORIZONTAL,
+        top_right: THICK_TOP_RIGHT,
+        top_left: THICK_TOP_LEFT,
+        bottom_right: THICK_BOTTOM_RIGHT,
+        bottom_left: THICK_BOTTOM_LEFT,
+        vertical_left: THICK_VERTICAL_LEFT,
+        vertical_right: THICK_VERTICAL_RIGHT,
+        horizontal_down: THICK_HORIZONTAL_DOWN,
+        horizontal_up: THICK_HORIZONTAL_UP,
+        cross: THICK_CROSS,
+    };
 }
 
 pub const DOT: &str = "•";
+
+pub mod braille {
+    pub const BLANK: u16 = 0x2800;
+    pub const DOTS: [[u16; 2]; 4] = [
+        [0x0001, 0x0008],
+        [0x0002, 0x0010],
+        [0x0004, 0x0020],
+        [0x0040, 0x0080],
+    ];
+}
+
+/// Marker to use when plotting data points
+#[derive(Debug, Clone, Copy)]
+pub enum Marker {
+    /// One point per cell in shape of dot
+    Dot,
+    /// One point per cell in shape of a block
+    Block,
+    /// Up to 8 points per cell
+    Braille,
+}

src/terminal.rs

@@ -1,9 +1,41 @@
+use crate::{
+    backend::Backend,
+    buffer::Buffer,
+    layout::Rect,
+    widgets::{StatefulWidget, Widget},
+};
 use std::io;
 
-use backend::Backend;
-use buffer::Buffer;
-use layout::Rect;
-use widgets::Widget;
+#[derive(Debug, Clone, PartialEq)]
+/// UNSTABLE
+enum ResizeBehavior {
+    Fixed,
+    Auto,
+}
+
+#[derive(Debug, Clone, PartialEq)]
+/// UNSTABLE
+pub struct Viewport {
+    area: Rect,
+    resize_behavior: ResizeBehavior,
+}
+
+impl Viewport {
+    /// UNSTABLE
+    pub fn fixed(area: Rect) -> Viewport {
+        Viewport {
+            area,
+            resize_behavior: ResizeBehavior::Fixed,
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq)]
+/// Options to pass to [`Terminal::with_options`]
+pub struct TerminalOptions {
+    /// Viewport used to draw to the terminal
+    pub viewport: Viewport,
+}
 
 /// Interface to the terminal backed by Termion
 #[derive(Debug)]
@@ -17,25 +49,116 @@ where
     buffers: [Buffer; 2],
     /// Index of the current buffer in the previous array
     current: usize,
+    /// Whether the cursor is currently hidden
+    hidden_cursor: bool,
+    /// Viewport
+    viewport: Viewport,
 }
 
+/// Represents a consistent terminal interface for rendering.
 pub struct Frame<'a, B: 'a>
 where
     B: Backend,
 {
     terminal: &'a mut Terminal<B>,
+
+    /// Where should the cursor be after drawing this frame?
+    ///
+    /// If `None`, the cursor is hidden and its position is controlled by the backend. If `Some((x,
+    /// y))`, the cursor is shown and placed at `(x, y)` after the call to `Terminal::draw()`.
+    cursor_position: Option<(u16, u16)>,
 }
 
 impl<'a, B> Frame<'a, B>
 where
     B: Backend,
 {
-    /// Calls the draw method of a given widget on the current buffer
-    pub fn render<W>(&mut self, widget: &mut W, area: Rect)
+    /// Terminal size, guaranteed not to change when rendering.
+    pub fn size(&self) -> Rect {
+        self.terminal.viewport.area
+    }
+
+    /// Render a [`Widget`] to the current buffer using [`Widget::render`].
+    ///
+    /// # Examples
+    ///
+    /// ```rust,no_run
+    /// # use std::io;
+    /// # use tui::Terminal;
+    /// # use tui::backend::TermionBackend;
+    /// # use tui::layout::Rect;
+    /// # use tui::widgets::Block;
+    /// # let stdout = io::stdout();
+    /// # let backend = TermionBackend::new(stdout);
+    /// # let mut terminal = Terminal::new(backend).unwrap();
+    /// let block = Block::default();
+    /// let area = Rect::new(0, 0, 5, 5);
+    /// let mut frame = terminal.get_frame();
+    /// frame.render_widget(block, area);
+    /// ```
+    pub fn render_widget<W>(&mut self, widget: W, area: Rect)
     where
         W: Widget,
     {
-        widget.draw(area, self.terminal.current_buffer_mut());
+        widget.render(area, self.terminal.current_buffer_mut());
+    }
+
+    /// Render a [`StatefulWidget`] to the current buffer using [`StatefulWidget::render`].
+    ///
+    /// The last argument should be an instance of the [`StatefulWidget::State`] associated to the
+    /// given [`StatefulWidget`].
+    ///
+    /// # Examples
+    ///
+    /// ```rust,no_run
+    /// # use std::io;
+    /// # use tui::Terminal;
+    /// # use tui::backend::TermionBackend;
+    /// # use tui::layout::Rect;
+    /// # use tui::widgets::{List, ListItem, ListState};
+    /// # let stdout = io::stdout();
+    /// # let backend = TermionBackend::new(stdout);
+    /// # let mut terminal = Terminal::new(backend).unwrap();
+    /// let mut state = ListState::default();
+    /// state.select(Some(1));
+    /// let items = vec![
+    ///     ListItem::new("Item 1"),
+    ///     ListItem::new("Item 2"),
+    /// ];
+    /// let list = List::new(items);
+    /// let area = Rect::new(0, 0, 5, 5);
+    /// let mut frame = terminal.get_frame();
+    /// frame.render_stateful_widget(list, area, &mut state);
+    /// ```
+    pub fn render_stateful_widget<W>(&mut self, widget: W, area: Rect, state: &mut W::State)
+    where
+        W: StatefulWidget,
+    {
+        widget.render(area, self.terminal.current_buffer_mut(), state);
+    }
+
+    /// After drawing this frame, make the cursor visible and put it at the specified (x, y)
+    /// coordinates. If this method is not called, the cursor will be hidden.
+    ///
+    /// Note that this will interfere with calls to `Terminal::hide_cursor()`,
+    /// `Terminal::show_cursor()`, and `Terminal::set_cursor()`. Pick one of the APIs and stick
+    /// with it.
+    pub fn set_cursor(&mut self, x: u16, y: u16) {
+        self.cursor_position = Some((x, y));
+    }
+}
+
+impl<B> Drop for Terminal<B>
+where
+    B: Backend,
+{
+    fn drop(&mut self) {
+        // Attempt to restore the cursor state
+        if self.hidden_cursor {
+            if let Err(err) = self.show_cursor() {
+                eprintln!("Failed to show the cursor: {}", err);
+            }
+        }
     }
 }
 
@@ -43,19 +166,41 @@ impl<B> Terminal<B>
 where
     B: Backend,
 {
-    /// Wrapper around Termion initialization. Each buffer is initialized with a blank string and
+    /// Wrapper around Terminal initialization. Each buffer is initialized with a blank string and
     /// default colors for the foreground and the background
-    pub fn new(backend: B) -> Result<Terminal<B>, io::Error> {
+    pub fn new(backend: B) -> io::Result<Terminal<B>> {
         let size = backend.size()?;
+        Terminal::with_options(
+            backend,
+            TerminalOptions {
+                viewport: Viewport {
+                    area: size,
+                    resize_behavior: ResizeBehavior::Auto,
+                },
+            },
+        )
+    }
+
+    /// UNSTABLE
+    pub fn with_options(backend: B, options: TerminalOptions) -> io::Result<Terminal<B>> {
         Ok(Terminal {
             backend,
-            buffers: [Buffer::empty(size), Buffer::empty(size)],
+            buffers: [
+                Buffer::empty(options.viewport.area),
+                Buffer::empty(options.viewport.area),
+            ],
             current: 0,
+            hidden_cursor: false,
+            viewport: options.viewport,
         })
     }
 
+    /// 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 }
+        Frame {
+            terminal: self,
+            cursor_position: None,
+        }
     }
 
     pub fn current_buffer_mut(&mut self) -> &mut Buffer {
@@ -70,47 +215,64 @@ 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.
-    pub fn flush(&mut self) -> Result<(), io::Error> {
-        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)
+    /// 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 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.
-    pub fn resize(&mut self, area: Rect) -> Result<(), io::Error> {
+    /// 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.backend.clear()
+        self.viewport.area = area;
+        self.clear()
     }
 
-    /// Flushes the current internal state and prepares the interface for the next draw call
-    pub fn draw<F>(&mut self, f: F) -> Result<(), io::Error>
+    /// Queries the backend for size and resizes if it doesn't match the previous size.
+    pub fn autoresize(&mut self) -> io::Result<()> {
+        if self.viewport.resize_behavior == ResizeBehavior::Auto {
+            let size = self.size()?;
+            if size != self.viewport.area {
+                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>),
+        F: FnOnce(&mut Frame<B>),
     {
-        f(self.get_frame());
+        // Autoresize - otherwise we get glitches if shrinking or potential desync between widgets
+        // and the terminal (if growing), which may OOB.
+        self.autoresize()?;
+
+        let mut frame = self.get_frame();
+        f(&mut frame);
+        // We can't change the cursor position right away because we have to flush the frame to
+        // stdout first. But we also can't keep the frame around, since it holds a &mut to
+        // Terminal. Thus, we're taking the important data out of the Frame and dropping it.
+        let cursor_position = frame.cursor_position;
 
         // Draw to stdout
         self.flush()?;
 
+        match cursor_position {
+            None => self.hide_cursor()?,
+            Some((x, y)) => {
+                self.show_cursor()?;
+                self.set_cursor(x, y)?;
+            }
+        }
+
         // Swap buffers
         self.buffers[1 - self.current].reset();
         self.current = 1 - self.current;
@@ -120,16 +282,36 @@ where
         Ok(())
     }
 
-    pub fn hide_cursor(&mut self) -> Result<(), io::Error> {
-        self.backend.hide_cursor()
+    pub fn hide_cursor(&mut self) -> io::Result<()> {
+        self.backend.hide_cursor()?;
+        self.hidden_cursor = true;
+        Ok(())
     }
-    pub fn show_cursor(&mut self) -> Result<(), io::Error> {
-        self.backend.show_cursor()
+
+    pub fn show_cursor(&mut self) -> io::Result<()> {
+        self.backend.show_cursor()?;
+        self.hidden_cursor = false;
+        Ok(())
     }
-    pub fn clear(&mut self) -> Result<(), io::Error> {
-        self.backend.clear()
+
+    pub fn get_cursor(&mut self) -> io::Result<(u16, u16)> {
+        self.backend.get_cursor()
     }
-    pub fn size(&self) -> Result<Rect, io::Error> {
+
+    pub fn set_cursor(&mut self, x: u16, y: u16) -> io::Result<()> {
+        self.backend.set_cursor(x, y)
+    }
+
+    /// Clear the terminal and force a full redraw on the next draw call.
+    pub fn clear(&mut self) -> io::Result<()> {
+        self.backend.clear()?;
+        // Reset the back buffer to make sure the next update will redraw everything.
+        self.buffers[1 - self.current].reset();
+        Ok(())
+    }
+
+    /// Queries the real size of the backend.
+    pub fn size(&self) -> io::Result<Rect> {
         self.backend.size()
     }
 }

src/text.rs

@@ -0,0 +1,618 @@
+//! Primitives for styled text.
+//!
+//! A terminal UI is at its root a lot of strings. In order to make it accessible and stylish,
+//! those strings may be associated to a set of styles. `tui` has three ways to represent them:
+//! - A single line string where all graphemes have the same style is represented by a [`Span`].
+//! - A single line string where each grapheme may have its own style is represented by [`Spans`].
+//! - A multiple line string where each grapheme may have its own style is represented by a
+//! [`Text`].
+//!
+//! These types form a hierarchy: [`Spans`] is a collection of [`Span`] and each line of [`Text`]
+//! is a [`Spans`].
+//!
+//! Keep it mind that a lot of widgets will use those types to advertise what kind of string is
+//! supported for their properties. Moreover, `tui` provides convenient `From` implementations so
+//! that you can start by using simple `String` or `&str` and then promote them to the previous
+//! primitives when you need additional styling capabilities.
+//!
+//! For example, for the [`crate::widgets::Block`] widget, all the following calls are valid to set
+//! its `title` property (which is a [`Spans`] under the hood):
+//!
+//! ```rust
+//! # use tui::widgets::Block;
+//! # use tui::text::{Span, Spans};
+//! # use tui::style::{Color, Style};
+//! // A simple string with no styling.
+//! // Converted to Spans(vec![
+//! //   Span { content: Cow::Borrowed("My title"), style: Style { .. } }
+//! // ])
+//! let block = Block::default().title("My title");
+//!
+//! // A simple string with a unique style.
+//! // Converted to Spans(vec![
+//! //   Span { content: Cow::Borrowed("My title"), style: Style { fg: Some(Color::Yellow), .. }
+//! // ])
+//! let block = Block::default().title(
+//!     Span::styled("My title", Style::default().fg(Color::Yellow))
+//! );
+//!
+//! // A string with multiple styles.
+//! // Converted to Spans(vec![
+//! //   Span { content: Cow::Borrowed("My"), style: Style { fg: Some(Color::Yellow), .. } },
+//! //   Span { content: Cow::Borrowed(" title"), .. }
+//! // ])
+//! let block = Block::default().title(vec![
+//!     Span::styled("My", Style::default().fg(Color::Yellow)),
+//!     Span::raw(" title"),
+//! ]);
+//! ```
+use crate::style::Style;
+use std::borrow::Cow;
+use unicode_segmentation::UnicodeSegmentation;
+use unicode_width::UnicodeWidthStr;
+
+const NBSP: &str = "\u{00a0}";
+
+/// A grapheme associated to a style.
+#[derive(Debug, Clone, PartialEq)]
+pub struct StyledGrapheme<'a> {
+    pub symbol: &'a str,
+    pub style: Style,
+}
+
+/// A string where all graphemes have the same style.
+#[derive(Debug, Clone, PartialEq)]
+pub struct Span<'a> {
+    pub content: Cow<'a, str>,
+    pub style: Style,
+}
+
+impl<'a> Span<'a> {
+    /// Create a span with no style.
+    ///
+    /// ## Examples
+    ///
+    /// ```rust
+    /// # use tui::text::Span;
+    /// Span::raw("My text");
+    /// Span::raw(String::from("My text"));
+    /// ```
+    pub fn raw<T>(content: T) -> Span<'a>
+    where
+        T: Into<Cow<'a, str>>,
+    {
+        Span {
+            content: content.into(),
+            style: Style::default(),
+        }
+    }
+
+    /// Create a span with a style.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// # use tui::text::Span;
+    /// # use tui::style::{Color, Modifier, Style};
+    /// let style = Style::default().fg(Color::Yellow).add_modifier(Modifier::ITALIC);
+    /// Span::styled("My text", style);
+    /// Span::styled(String::from("My text"), style);
+    /// ```
+    pub fn styled<T>(content: T, style: Style) -> Span<'a>
+    where
+        T: Into<Cow<'a, str>>,
+    {
+        Span {
+            content: content.into(),
+            style,
+        }
+    }
+
+    /// Returns the width of the content held by this span.
+    pub fn width(&self) -> usize {
+        self.content.width()
+    }
+
+    /// Returns an iterator over the graphemes held by this span.
+    ///
+    /// `base_style` is the [`Style`] that will be patched with each grapheme [`Style`] to get
+    /// the resulting [`Style`].
+    ///
+    /// ## Examples
+    ///
+    /// ```rust
+    /// # use tui::text::{Span, StyledGrapheme};
+    /// # use tui::style::{Color, Modifier, Style};
+    /// # use std::iter::Iterator;
+    /// let style = Style::default().fg(Color::Yellow);
+    /// let span = Span::styled("Text", style);
+    /// let style = Style::default().fg(Color::Green).bg(Color::Black);
+    /// let styled_graphemes = span.styled_graphemes(style);
+    /// assert_eq!(
+    ///     vec![
+    ///         StyledGrapheme {
+    ///             symbol: "T",
+    ///             style: Style {
+    ///                 fg: Some(Color::Yellow),
+    ///                 bg: Some(Color::Black),
+    ///                 add_modifier: Modifier::empty(),
+    ///                 sub_modifier: Modifier::empty(),
+    ///             },
+    ///         },
+    ///         StyledGrapheme {
+    ///             symbol: "e",
+    ///             style: Style {
+    ///                 fg: Some(Color::Yellow),
+    ///                 bg: Some(Color::Black),
+    ///                 add_modifier: Modifier::empty(),
+    ///                 sub_modifier: Modifier::empty(),
+    ///             },
+    ///         },
+    ///         StyledGrapheme {
+    ///             symbol: "x",
+    ///             style: Style {
+    ///                 fg: Some(Color::Yellow),
+    ///                 bg: Some(Color::Black),
+    ///                 add_modifier: Modifier::empty(),
+    ///                 sub_modifier: Modifier::empty(),
+    ///             },
+    ///         },
+    ///         StyledGrapheme {
+    ///             symbol: "t",
+    ///             style: Style {
+    ///                 fg: Some(Color::Yellow),
+    ///                 bg: Some(Color::Black),
+    ///                 add_modifier: Modifier::empty(),
+    ///                 sub_modifier: Modifier::empty(),
+    ///             },
+    ///         },
+    ///     ],
+    ///     styled_graphemes.collect::<Vec<StyledGrapheme>>()
+    /// );
+    /// ```
+    pub fn styled_graphemes(
+        &'a self,
+        base_style: Style,
+    ) -> impl Iterator<Item = StyledGrapheme<'a>> {
+        UnicodeSegmentation::graphemes(self.content.as_ref(), true)
+            .map(move |g| StyledGrapheme {
+                symbol: g,
+                style: base_style.patch(self.style),
+            })
+            .filter(|s| s.symbol != "\n")
+    }
+
+    fn split_at_in_place(&mut self, mid: usize) -> Span<'a> {
+        let content = match self.content {
+            Cow::Owned(ref mut s) => {
+                let s2 = s[mid..].to_string();
+                s.truncate(mid);
+                Cow::Owned(s2)
+            }
+            Cow::Borrowed(s) => {
+                let (s1, s2) = s.split_at(mid);
+                self.content = Cow::Borrowed(s1);
+                Cow::Borrowed(s2)
+            }
+        };
+        Span {
+            content,
+            style: self.style,
+        }
+    }
+
+    fn trim_start(&mut self) {
+        self.content = Cow::Owned(String::from(self.content.trim_start()));
+    }
+}
+
+impl<'a> From<String> for Span<'a> {
+    fn from(s: String) -> Span<'a> {
+        Span::raw(s)
+    }
+}
+
+impl<'a> From<&'a str> for Span<'a> {
+    fn from(s: &'a str) -> Span<'a> {
+        Span::raw(s)
+    }
+}
+
+/// A string composed of clusters of graphemes, each with their own style.
+#[derive(Debug, Clone, PartialEq)]
+pub struct Spans<'a>(pub Vec<Span<'a>>);
+
+impl<'a> Default for Spans<'a> {
+    fn default() -> Spans<'a> {
+        Spans(Vec::new())
+    }
+}
+
+impl<'a> Spans<'a> {
+    /// Returns the width of the underlying string.
+    ///
+    /// ## Examples
+    ///
+    /// ```rust
+    /// # use tui::text::{Span, Spans};
+    /// # use tui::style::{Color, Style};
+    /// let spans = Spans::from(vec![
+    ///     Span::styled("My", Style::default().fg(Color::Yellow)),
+    ///     Span::raw(" text"),
+    /// ]);
+    /// assert_eq!(7, spans.width());
+    /// ```
+    pub fn width(&self) -> usize {
+        self.0.iter().map(Span::width).sum()
+    }
+}
+
+impl<'a> From<String> for Spans<'a> {
+    fn from(s: String) -> Spans<'a> {
+        Spans(vec![Span::from(s)])
+    }
+}
+
+impl<'a> From<&'a str> for Spans<'a> {
+    fn from(s: &'a str) -> Spans<'a> {
+        Spans(vec![Span::from(s)])
+    }
+}
+
+impl<'a> From<Vec<Span<'a>>> for Spans<'a> {
+    fn from(spans: Vec<Span<'a>>) -> Spans<'a> {
+        Spans(spans)
+    }
+}
+
+impl<'a> From<Span<'a>> for Spans<'a> {
+    fn from(span: Span<'a>) -> Spans<'a> {
+        Spans(vec![span])
+    }
+}
+
+impl<'a> From<Spans<'a>> for String {
+    fn from(line: Spans<'a>) -> String {
+        line.0.iter().fold(String::new(), |mut acc, s| {
+            acc.push_str(s.content.as_ref());
+            acc
+        })
+    }
+}
+
+impl<'a> IntoIterator for Spans<'a> {
+    type Item = Span<'a>;
+    type IntoIter = std::vec::IntoIter<Self::Item>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.0.into_iter()
+    }
+}
+
+/// A string split over multiple lines where each line is composed of several clusters, each with
+/// their own style.
+///
+/// A [`Text`], like a [`Span`], can be constructed using one of the many `From` implementations
+/// or via the [`Text::raw`] and [`Text::styled`] methods. Helpfully, [`Text`] also implements
+/// [`core::iter::Extend`] which enables the concatenation of several [`Text`] blocks.
+///
+/// ```rust
+/// # use tui::text::Text;
+/// # use tui::style::{Color, Modifier, Style};
+/// let style = Style::default().fg(Color::Yellow).add_modifier(Modifier::ITALIC);
+///
+/// // An initial two lines of `Text` built from a `&str`
+/// let mut text = Text::from("The first line\nThe second line");
+/// assert_eq!(2, text.height());
+///
+/// // Adding two more unstyled lines
+/// text.extend(Text::raw("These are two\nmore lines!"));
+/// assert_eq!(4, text.height());
+///
+/// // Adding a final two styled lines
+/// text.extend(Text::styled("Some more lines\nnow with more style!", style));
+/// assert_eq!(6, text.height());
+/// ```
+#[derive(Debug, Clone, PartialEq)]
+pub struct Text<'a> {
+    pub lines: Vec<Spans<'a>>,
+}
+
+impl<'a> Default for Text<'a> {
+    fn default() -> Text<'a> {
+        Text { lines: Vec::new() }
+    }
+}
+
+impl<'a> Text<'a> {
+    /// Create some text (potentially multiple lines) with no style.
+    ///
+    /// ## Examples
+    ///
+    /// ```rust
+    /// # use tui::text::Text;
+    /// Text::raw("The first line\nThe second line");
+    /// Text::raw(String::from("The first line\nThe second line"));
+    /// ```
+    pub fn raw<T>(content: T) -> Text<'a>
+    where
+        T: Into<Cow<'a, str>>,
+    {
+        Text {
+            lines: match content.into() {
+                Cow::Borrowed(s) => s.lines().map(Spans::from).collect(),
+                Cow::Owned(s) => s.lines().map(|l| Spans::from(l.to_owned())).collect(),
+            },
+        }
+    }
+
+    /// Create some text (potentially multiple lines) with a style.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// # use tui::text::Text;
+    /// # use tui::style::{Color, Modifier, Style};
+    /// let style = Style::default().fg(Color::Yellow).add_modifier(Modifier::ITALIC);
+    /// Text::styled("The first line\nThe second line", style);
+    /// Text::styled(String::from("The first line\nThe second line"), style);
+    /// ```
+    pub fn styled<T>(content: T, style: Style) -> Text<'a>
+    where
+        T: Into<Cow<'a, str>>,
+    {
+        let mut text = Text::raw(content);
+        text.patch_style(style);
+        text
+    }
+
+    /// Returns the max width of all the lines.
+    ///
+    /// ## Examples
+    ///
+    /// ```rust
+    /// use tui::text::Text;
+    /// let text = Text::from("The first line\nThe second line");
+    /// assert_eq!(15, text.width());
+    /// ```
+    pub fn width(&self) -> usize {
+        self.lines
+            .iter()
+            .map(Spans::width)
+            .max()
+            .unwrap_or_default()
+    }
+
+    /// Returns the height.
+    ///
+    /// ## Examples
+    ///
+    /// ```rust
+    /// use tui::text::Text;
+    /// let text = Text::from("The first line\nThe second line");
+    /// assert_eq!(2, text.height());
+    /// ```
+    pub fn height(&self) -> usize {
+        self.lines.len()
+    }
+
+    /// Apply a new style to existing text.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// # use tui::text::Text;
+    /// # use tui::style::{Color, Modifier, Style};
+    /// let style = Style::default().fg(Color::Yellow).add_modifier(Modifier::ITALIC);
+    /// let mut raw_text = Text::raw("The first line\nThe second line");
+    /// let styled_text = Text::styled(String::from("The first line\nThe second line"), style);
+    /// assert_ne!(raw_text, styled_text);
+    ///
+    /// raw_text.patch_style(style);
+    /// assert_eq!(raw_text, styled_text);
+    /// ```
+    pub fn patch_style(&mut self, style: Style) {
+        for line in &mut self.lines {
+            for span in &mut line.0 {
+                span.style = span.style.patch(style);
+            }
+        }
+    }
+}
+
+impl<'a> From<String> for Text<'a> {
+    fn from(s: String) -> Text<'a> {
+        Text::raw(s)
+    }
+}
+
+impl<'a> From<&'a str> for Text<'a> {
+    fn from(s: &'a str) -> Text<'a> {
+        Text::raw(s)
+    }
+}
+
+impl<'a> From<Span<'a>> for Text<'a> {
+    fn from(span: Span<'a>) -> Text<'a> {
+        Text {
+            lines: vec![Spans::from(span)],
+        }
+    }
+}
+
+impl<'a> From<Spans<'a>> for Text<'a> {
+    fn from(spans: Spans<'a>) -> Text<'a> {
+        Text { lines: vec![spans] }
+    }
+}
+
+impl<'a> From<Vec<Spans<'a>>> for Text<'a> {
+    fn from(lines: Vec<Spans<'a>>) -> Text<'a> {
+        Text { lines }
+    }
+}
+
+impl<'a> IntoIterator for Text<'a> {
+    type Item = Spans<'a>;
+    type IntoIter = std::vec::IntoIter<Self::Item>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.lines.into_iter()
+    }
+}
+
+impl<'a> Extend<Spans<'a>> for Text<'a> {
+    fn extend<T: IntoIterator<Item = Spans<'a>>>(&mut self, iter: T) {
+        self.lines.extend(iter);
+    }
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct WrappedText<'a> {
+    text: Text<'a>,
+    trim: bool,
+    width: u16,
+    column: u16,
+    last_word_end: u16,
+    was_whitespace: bool,
+}
+
+impl<'a> WrappedText<'a> {
+    pub fn new(width: u16) -> Self {
+        Self {
+            text: Text::default(),
+            width,
+            trim: true,
+            column: 0,
+            last_word_end: 0,
+            was_whitespace: false,
+        }
+    }
+
+    pub fn trim(mut self, trim: bool) -> Self {
+        self.trim = trim;
+        self
+    }
+
+    fn push_span(&mut self, span: Span<'a>) {
+        if self.text.lines.is_empty() {
+            self.text.lines.push(Spans::default());
+        }
+        let last_line = self.text.lines.len() - 1;
+        self.text.lines[last_line].0.push(span);
+    }
+
+    fn push_spans<T>(&mut self, spans: T)
+    where
+        T: IntoIterator<Item = Span<'a>>,
+    {
+        let mut iter = spans.into_iter();
+        let mut pending_span = iter.next();
+        while let Some(mut span) = pending_span.take() {
+            let span_position = self.column;
+            let mut breakpoint = None;
+            // Skip leading whitespaces when trim is enabled
+            if self.column == 0 && self.trim {
+                span.trim_start();
+            }
+            for grapheme in UnicodeSegmentation::graphemes(span.content.as_ref(), true) {
+                let grapheme_width = grapheme.width() as u16;
+                // Ignore grapheme that are larger than the allowed width
+                if grapheme_width > self.width {
+                    continue;
+                }
+                let is_whitespace = grapheme.chars().all(&char::is_whitespace);
+                if is_whitespace && !self.was_whitespace && grapheme != NBSP {
+                    self.last_word_end = self.column;
+                }
+                let next_column = self.column.saturating_add(grapheme_width);
+                if next_column > self.width {
+                    let width = self.last_word_end.saturating_sub(span_position) as usize;
+                    breakpoint = Some(width);
+                    break;
+                }
+                self.column = next_column;
+                self.was_whitespace = is_whitespace;
+            }
+            if let Some(b) = breakpoint {
+                pending_span = if b > 0 {
+                    let new_span = span.split_at_in_place(b);
+                    self.push_span(span);
+                    Some(new_span)
+                } else {
+                    Some(span)
+                };
+                self.start_new_line();
+            } else {
+                self.push_span(span);
+                pending_span = iter.next();
+            }
+        }
+    }
+
+    fn start_new_line(&mut self) {
+        self.column = 0;
+        self.last_word_end = 0;
+        self.text.lines.push(Spans::default());
+    }
+}
+
+impl<'a> Extend<Spans<'a>> for WrappedText<'a> {
+    fn extend<T: IntoIterator<Item = Spans<'a>>>(&mut self, iter: T) {
+        for spans in iter {
+            self.start_new_line();
+            self.push_spans(spans);
+        }
+    }
+}
+
+impl<'a> From<WrappedText<'a>> for Text<'a> {
+    fn from(text: WrappedText<'a>) -> Text<'a> {
+        text.text
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::style::{Color, Modifier, Style};
+
+    #[test]
+    fn text_can_be_wrapped() {
+        let mut t = WrappedText::new(10);
+        t.extend(Text::from(Spans::from(vec![
+            Span::raw("This is "),
+            Span::styled("a test.", Style::default().fg(Color::Red)),
+        ])));
+        t.extend(Text::from("It should wrap."));
+        let t = Text::from(t);
+        let expected = Text::from(vec![
+            Spans::from(vec![
+                Span::raw("This is "),
+                Span::styled("a", Style::default().fg(Color::Red)),
+            ]),
+            Spans::from(Span::styled("test.", Style::default().fg(Color::Red))),
+            Spans::from("It should"),
+            Spans::from("wrap."),
+        ]);
+        assert_eq!(expected, t);
+    }
+
+    #[test]
+    fn text_with_trailing_nbsp_can_be_wrapped() {
+        let mut t = WrappedText::new(10);
+        t.extend(Text::from(Spans::from(vec![
+            Span::raw("Line1"),
+            Span::styled(NBSP, Style::default().add_modifier(Modifier::UNDERLINED)),
+            Span::raw("Line2"),
+        ])));
+        let expected = Text::from(vec![
+            Spans::from(vec![
+                Span::raw("Line1"),
+                Span::styled(NBSP, Style::default().add_modifier(Modifier::UNDERLINED)),
+            ]),
+            Spans::from(vec![Span::raw("Line2")]),
+        ]);
+        assert_eq!(expected, Text::from(t));
+    }
+}

src/widgets/barchart.rs

@@ -1,33 +1,31 @@
-use std::cmp::{max, min};
-
+use crate::{
+    buffer::Buffer,
+    layout::Rect,
+    style::Style,
+    symbols,
+    widgets::{Block, Widget},
+};
+use std::cmp::min;
 use unicode_width::UnicodeWidthStr;
 
-use buffer::Buffer;
-use layout::Rect;
-use style::Style;
-use symbols::bar;
-use 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() {
 /// BarChart::default()
 ///     .block(Block::default().title("BarChart").borders(Borders::ALL))
 ///     .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))
+///     .bar_style(Style::default().fg(Color::Yellow).bg(Color::Red))
+///     .value_style(Style::default().fg(Color::Red).add_modifier(Modifier::BOLD))
 ///     .label_style(Style::default().fg(Color::White))
 ///     .data(&[("B0", 0), ("B1", 2), ("B2", 4), ("B3", 3)])
 ///     .max(4);
-/// # }
 /// ```
+#[derive(Debug, Clone)]
 pub struct BarChart<'a> {
     /// Block to wrap the widget in
     block: Option<Block<'a>>,
@@ -35,6 +33,10 @@ pub struct BarChart<'a> {
     bar_width: u16,
     /// The gap between each bar
     bar_gap: u16,
+    /// Set of symbols used to display the data
+    bar_set: symbols::bar::Set,
+    /// Style of the bars
+    bar_style: Style,
     /// Style of the values printed at the bottom of each bar
     value_style: Style,
     /// Style of the labels printed under each bar
@@ -57,8 +59,10 @@ impl<'a> Default for BarChart<'a> {
             max: None,
             data: &[],
             values: Vec::new(),
+            bar_style: Style::default(),
             bar_width: 1,
             bar_gap: 1,
+            bar_set: symbols::bar::NINE_LEVELS,
             value_style: Default::default(),
             label_style: Default::default(),
             style: Default::default(),
@@ -80,27 +84,42 @@ impl<'a> BarChart<'a> {
         self.block = Some(block);
         self
     }
+
     pub fn max(mut self, max: u64) -> BarChart<'a> {
         self.max = Some(max);
         self
     }
 
+    pub fn bar_style(mut self, style: Style) -> BarChart<'a> {
+        self.bar_style = style;
+        self
+    }
+
     pub fn bar_width(mut self, width: u16) -> BarChart<'a> {
         self.bar_width = width;
         self
     }
+
     pub fn bar_gap(mut self, gap: u16) -> BarChart<'a> {
         self.bar_gap = gap;
         self
     }
+
+    pub fn bar_set(mut self, bar_set: symbols::bar::Set) -> BarChart<'a> {
+        self.bar_set = bar_set;
+        self
+    }
+
     pub fn value_style(mut self, style: Style) -> BarChart<'a> {
         self.value_style = style;
         self
     }
+
     pub fn label_style(mut self, style: Style) -> BarChart<'a> {
         self.label_style = style;
         self
     }
+
     pub fn style(mut self, style: Style) -> BarChart<'a> {
         self.style = style;
         self
@@ -108,11 +127,14 @@ impl<'a> BarChart<'a> {
 }
 
 impl<'a> Widget for BarChart<'a> {
-    fn draw(&mut self, area: Rect, buf: &mut Buffer) {
-        let chart_area = match self.block {
-            Some(ref mut b) => {
-                b.draw(area, buf);
-                b.inner(area)
+    fn render(mut self, area: Rect, buf: &mut Buffer) {
+        buf.set_style(area, self.style);
+
+        let chart_area = match self.block.take() {
+            Some(b) => {
+                let inner_area = b.inner(area);
+                b.render(area, buf);
+                inner_area
             }
             None => area,
         };
@@ -121,11 +143,9 @@ impl<'a> Widget for BarChart<'a> {
             return;
         }
 
-        self.background(&chart_area, buf, self.style.bg);
-
         let max = self
             .max
-            .unwrap_or_else(|| self.data.iter().fold(0, |acc, &(_, v)| max(v, acc)));
+            .unwrap_or_else(|| self.data.iter().map(|t| t.1).max().unwrap_or_default());
         let max_index = min(
             (chart_area.width / (self.bar_width + self.bar_gap)) as usize,
             self.data.len(),
@@ -134,28 +154,34 @@ impl<'a> Widget for BarChart<'a> {
             .data
             .iter()
             .take(max_index)
-            .map(|&(l, v)| (l, v * u64::from(chart_area.height) * 8 / max))
+            .map(|&(l, v)| {
+                (
+                    l,
+                    v * u64::from(chart_area.height - 1) * 8 / std::cmp::max(max, 1),
+                )
+            })
             .collect::<Vec<(&str, u64)>>();
         for j in (0..chart_area.height - 1).rev() {
             for (i, d) in data.iter_mut().enumerate() {
                 let symbol = match d.1 {
-                    0 => " ",
-                    1 => bar::ONE_EIGHTH,
-                    2 => bar::ONE_QUATER,
-                    3 => bar::THREE_EIGHTHS,
-                    4 => bar::HALF,
-                    5 => bar::FIVE_EIGHTHS,
-                    6 => bar::THREE_QUATERS,
-                    7 => bar::SEVEN_EIGHTHS,
-                    _ => bar::FULL,
+                    0 => self.bar_set.empty,
+                    1 => self.bar_set.one_eighth,
+                    2 => self.bar_set.one_quarter,
+                    3 => self.bar_set.three_eighths,
+                    4 => self.bar_set.half,
+                    5 => self.bar_set.five_eighths,
+                    6 => self.bar_set.three_quarters,
+                    7 => self.bar_set.seven_eighths,
+                    _ => self.bar_set.full,
                 };
 
                 for x in 0..self.bar_width {
                     buf.get_mut(
                         chart_area.left() + i as u16 * (self.bar_width + self.bar_gap) + x,
                         chart_area.top() + j,
-                    ).set_symbol(symbol)
-                        .set_style(self.style);
+                    )
+                    .set_symbol(symbol)
+                    .set_style(self.bar_style);
                 }
 
                 if d.1 > 8 {

src/widgets/block.rs

@@ -1,8 +1,30 @@
-use buffer::Buffer;
-use layout::Rect;
-use style::Style;
-use symbols::line;
-use widgets::{Borders, Widget};
+use crate::{
+    buffer::Buffer,
+    layout::Rect,
+    style::Style,
+    symbols::line,
+    text::{Span, Spans},
+    widgets::{Borders, Widget},
+};
+
+#[derive(Debug, Clone, Copy)]
+pub enum BorderType {
+    Plain,
+    Rounded,
+    Double,
+    Thick,
+}
+
+impl BorderType {
+    pub fn line_symbols(border_type: BorderType) -> line::Set {
+        match border_type {
+            BorderType::Plain => line::NORMAL,
+            BorderType::Rounded => line::ROUNDED,
+            BorderType::Double => line::DOUBLE,
+            BorderType::Thick => line::THICK,
+        }
+    }
+}
 
 /// 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,28 +32,26 @@ use widgets::{Borders, Widget};
 /// # Examples
 ///
 /// ```
-/// # extern crate tui;
-/// # use tui::widgets::{Block, Borders};
+/// # use tui::widgets::{Block, BorderType, Borders};
 /// # use tui::style::{Style, Color};
-/// # fn main() {
 /// Block::default()
 ///     .title("Block")
-///     .title_style(Style::default().fg(Color::Red))
 ///     .borders(Borders::LEFT | Borders::RIGHT)
 ///     .border_style(Style::default().fg(Color::White))
+///     .border_type(BorderType::Rounded)
 ///     .style(Style::default().bg(Color::Black));
-/// # }
 /// ```
-#[derive(Clone, Copy)]
+#[derive(Debug, Clone)]
 pub struct Block<'a> {
     /// Optional title place on the upper left of the block
-    title: Option<&'a str>,
-    /// Title style
-    title_style: Style,
+    title: Option<Spans<'a>>,
     /// Visible borders
     borders: Borders,
     /// Border style
     border_style: Style,
+    /// Type of the border. The default is plain lines but one can choose to have rounded corners
+    /// or doubled lines instead.
+    border_type: BorderType,
     /// Widget style
     style: Style,
 }
@@ -40,22 +60,32 @@ impl<'a> Default for Block<'a> {
     fn default() -> Block<'a> {
         Block {
             title: None,
-            title_style: Default::default(),
             borders: Borders::NONE,
             border_style: Default::default(),
+            border_type: BorderType::Plain,
             style: Default::default(),
         }
     }
 }
 
 impl<'a> Block<'a> {
-    pub fn title(mut self, title: &'a str) -> Block<'a> {
-        self.title = Some(title);
+    pub fn title<T>(mut self, title: T) -> Block<'a>
+    where
+        T: Into<Spans<'a>>,
+    {
+        self.title = Some(title.into());
         self
     }
 
+    #[deprecated(
+        since = "0.10.0",
+        note = "You should use styling capabilities of `text::Spans` given as argument of the `title` method to apply styling to the title."
+    )]
     pub fn title_style(mut self, style: Style) -> Block<'a> {
-        self.title_style = style;
+        if let Some(t) = self.title {
+            let title = String::from(t);
+            self.title = Some(Spans::from(Span::styled(title, style)));
+        }
         self
     }
 
@@ -74,6 +104,11 @@ impl<'a> Block<'a> {
         self
     }
 
+    pub fn border_type(mut self, border_type: BorderType) -> Block<'a> {
+        self.border_type = border_type;
+        self
+    }
+
     /// Compute the inner area of a block based on its border visibility rules.
     pub fn inner(&self, area: Rect) -> Rect {
         if area.width < 2 || area.height < 2 {
@@ -99,25 +134,26 @@ impl<'a> Block<'a> {
 }
 
 impl<'a> Widget for Block<'a> {
-    fn draw(&mut self, area: Rect, buf: &mut Buffer) {
+    fn render(self, area: Rect, buf: &mut Buffer) {
+        buf.set_style(area, self.style);
+
         if area.width < 2 || area.height < 2 {
             return;
         }
 
-        self.background(&area, buf, self.style.bg);
-
+        let symbols = BorderType::line_symbols(self.border_type);
         // Sides
         if self.borders.intersects(Borders::LEFT) {
             for y in area.top()..area.bottom() {
                 buf.get_mut(area.left(), y)
-                    .set_symbol(line::VERTICAL)
+                    .set_symbol(symbols.vertical)
                     .set_style(self.border_style);
             }
         }
         if self.borders.intersects(Borders::TOP) {
             for x in area.left()..area.right() {
                 buf.get_mut(x, area.top())
-                    .set_symbol(line::HORIZONTAL)
+                    .set_symbol(symbols.horizontal)
                     .set_style(self.border_style);
             }
         }
@@ -125,7 +161,7 @@ impl<'a> Widget for Block<'a> {
             let x = area.right() - 1;
             for y in area.top()..area.bottom() {
                 buf.get_mut(x, y)
-                    .set_symbol(line::VERTICAL)
+                    .set_symbol(symbols.vertical)
                     .set_style(self.border_style);
             }
         }
@@ -133,7 +169,7 @@ impl<'a> Widget for Block<'a> {
             let y = area.bottom() - 1;
             for x in area.left()..area.right() {
                 buf.get_mut(x, y)
-                    .set_symbol(line::HORIZONTAL)
+                    .set_symbol(symbols.horizontal)
                     .set_style(self.border_style);
             }
         }
@@ -141,46 +177,38 @@ impl<'a> Widget for Block<'a> {
         // Corners
         if self.borders.contains(Borders::LEFT | Borders::TOP) {
             buf.get_mut(area.left(), area.top())
-                .set_symbol(line::TOP_LEFT)
+                .set_symbol(symbols.top_left)
                 .set_style(self.border_style);
         }
         if self.borders.contains(Borders::RIGHT | Borders::TOP) {
             buf.get_mut(area.right() - 1, area.top())
-                .set_symbol(line::TOP_RIGHT)
+                .set_symbol(symbols.top_right)
                 .set_style(self.border_style);
         }
         if self.borders.contains(Borders::LEFT | Borders::BOTTOM) {
             buf.get_mut(area.left(), area.bottom() - 1)
-                .set_symbol(line::BOTTOM_LEFT)
+                .set_symbol(symbols.bottom_left)
                 .set_style(self.border_style);
         }
         if self.borders.contains(Borders::RIGHT | Borders::BOTTOM) {
             buf.get_mut(area.right() - 1, area.bottom() - 1)
-                .set_symbol(line::BOTTOM_RIGHT)
+                .set_symbol(symbols.bottom_right)
                 .set_style(self.border_style);
         }
 
-        if area.width > 2 {
-            if let Some(title) = self.title {
-                let lx = if self.borders.intersects(Borders::LEFT) {
-                    1
-                } else {
-                    0
-                };
-                let rx = if self.borders.intersects(Borders::RIGHT) {
-                    1
-                } else {
-                    0
-                };
-                let width = area.width - lx - rx;
-                buf.set_stringn(
-                    area.left() + lx,
-                    area.top(),
-                    title,
-                    width as usize,
-                    self.title_style,
-                );
-            }
+        if let Some(title) = self.title {
+            let lx = if self.borders.intersects(Borders::LEFT) {
+                1
+            } else {
+                0
+            };
+            let rx = if self.borders.intersects(Borders::RIGHT) {
+                1
+            } else {
+                0
+            };
+            let width = area.width - lx - rx;
+            buf.set_spans(area.left() + lx, area.top(), &title, width);
         }
     }
 }

src/widgets/canvas/line.rs

@@ -1,7 +1,10 @@
-use super::Shape;
-use style::Color;
+use crate::{
+    style::Color,
+    widgets::canvas::{Painter, Shape},
+};
 
 /// Shape to draw a line from (x1, y1) to (x2, y2) with the given color
+#[derive(Debug, Clone)]
 pub struct Line {
     pub x1: f64,
     pub y1: f64,
@@ -10,60 +13,83 @@ pub struct Line {
     pub color: Color,
 }
 
-pub struct LineIterator {
-    x: f64,
-    y: f64,
-    dx: f64,
-    dy: f64,
-    dir_x: f64,
-    dir_y: f64,
-    current: f64,
-    end: f64,
-}
-
-impl Iterator for LineIterator {
-    type Item = (f64, f64);
-    fn next(&mut self) -> Option<Self::Item> {
-        if self.current < self.end {
-            let pos = (
-                self.x + (self.current * self.dx) / self.end * self.dir_x,
-                self.y + (self.current * self.dy) / self.end * self.dir_y,
-            );
-            self.current += 1.0;
-            Some(pos)
+impl Shape for Line {
+    fn draw(&self, painter: &mut Painter) {
+        let (x1, y1) = match painter.get_point(self.x1, self.y1) {
+            Some(c) => c,
+            None => return,
+        };
+        let (x2, y2) = match painter.get_point(self.x2, self.y2) {
+            Some(c) => c,
+            None => return,
+        };
+        let (dx, x_range) = if x2 >= x1 {
+            (x2 - x1, x1..=x2)
         } else {
-            None
+            (x1 - x2, x2..=x1)
+        };
+        let (dy, y_range) = if y2 >= y1 {
+            (y2 - y1, y1..=y2)
+        } else {
+            (y1 - y2, y2..=y1)
+        };
+
+        if dx == 0 {
+            for y in y_range {
+                painter.paint(x1, y, self.color);
+            }
+        } else if dy == 0 {
+            for x in x_range {
+                painter.paint(x, y1, self.color);
+            }
+        } else if dy < dx {
+            if x1 > x2 {
+                draw_line_low(painter, x2, y2, x1, y1, self.color);
+            } else {
+                draw_line_low(painter, x1, y1, x2, y2, self.color);
+            }
+        } else if y1 > y2 {
+            draw_line_high(painter, x2, y2, x1, y1, self.color);
+        } else {
+            draw_line_high(painter, x1, y1, x2, y2, self.color);
         }
     }
 }
 
-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);
-        let dir_x = if self.x1 <= self.x2 { 1.0 } else { -1.0 };
-        let dir_y = if self.y1 <= self.y2 { 1.0 } else { -1.0 };
-        let end = dx.max(dy);
-        LineIterator {
-            x: self.x1,
-            y: self.y1,
-            dx,
-            dy,
-            dir_x,
-            dir_y,
-            current: 0.0,
-            end,
+fn draw_line_low(painter: &mut Painter, x1: usize, y1: usize, x2: usize, y2: usize, color: Color) {
+    let dx = (x2 - x1) as isize;
+    let dy = (y2 as isize - y1 as isize).abs();
+    let mut d = 2 * dy - dx;
+    let mut y = y1;
+    for x in x1..=x2 {
+        painter.paint(x, y, color);
+        if d > 0 {
+            y = if y1 > y2 {
+                y.saturating_sub(1)
+            } else {
+                y.saturating_add(1)
+            };
+            d -= 2 * dx;
         }
+        d += 2 * dy;
     }
 }
 
-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())
+fn draw_line_high(painter: &mut Painter, x1: usize, y1: usize, x2: usize, y2: usize, color: Color) {
+    let dx = (x2 as isize - x1 as isize).abs();
+    let dy = (y2 - y1) as isize;
+    let mut d = 2 * dx - dy;
+    let mut x = x1;
+    for y in y1..=y2 {
+        painter.paint(x, y, color);
+        if d > 0 {
+            x = if x1 > x2 {
+                x.saturating_sub(1)
+            } else {
+                x.saturating_add(1)
+            };
+            d -= 2 * dy;
+        }
+        d += 2 * dx;
     }
 }

src/widgets/canvas/map.rs

@@ -1,9 +1,12 @@
-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,
+    widgets::canvas::{
+        world::{WORLD_HIGH_RESOLUTION, WORLD_LOW_RESOLUTION},
+        Painter, Shape,
+    },
+};
 
-#[derive(Clone, Copy)]
+#[derive(Debug, Clone, Copy)]
 pub enum MapResolution {
     Low,
     High,
@@ -19,6 +22,7 @@ impl MapResolution {
 }
 
 /// Shape to draw a world map with the given resolution and color
+#[derive(Debug, Clone)]
 pub struct Map {
     pub resolution: MapResolution,
     pub color: Color,
@@ -33,19 +37,12 @@ impl Default for Map {
     }
 }
 
-impl<'a> Shape<'a> for Map {
-    fn color(&self) -> Color {
-        self.color
-    }
-    fn points(&'a self) -> Box<Iterator<Item = (f64, f64)> + 'a> {
-        Box::new(self.into_iter())
-    }
-}
-
-impl<'a> IntoIterator for &'a Map {
-    type Item = (f64, f64);
-    type IntoIter = PointsIterator<'a>;
-    fn into_iter(self) -> Self::IntoIter {
-        PointsIterator::from(self.resolution.data())
+impl Shape for Map {
+    fn draw(&self, painter: &mut Painter) {
+        for (x, y) in self.resolution.data() {
+            if let Some((x, y)) = painter.get_point(*x, *y) {
+                painter.paint(x, y, self.color);
+            }
+        }
     }
 }

src/widgets/canvas/mod.rs

@@ -1,35 +1,30 @@
 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};
-
-pub const DOTS: [[u16; 2]; 4] = [
-    [0x0001, 0x0008],
-    [0x0002, 0x0010],
-    [0x0004, 0x0020],
-    [0x0040, 0x0080],
-];
-pub const BRAILLE_OFFSET: u16 = 0x2800;
-pub const BRAILLE_BLANK: char = '⠀';
+use crate::{
+    buffer::Buffer,
+    layout::Rect,
+    style::{Color, Style},
+    symbols,
+    widgets::{Block, Widget},
+};
+use std::fmt::Debug;
 
 /// Interface for all shapes that may be drawn on a Canvas widget.
-pub trait Shape<'a> {
-    /// Returns the color of the shape
-    fn color(&self) -> Color;
-    /// Returns an iterator over all points of the shape
-    fn points(&'a self) -> Box<Iterator<Item = (f64, f64)> + 'a>;
+pub trait Shape {
+    fn draw(&self, painter: &mut Painter);
 }
 
 /// Label to draw some text on the canvas
+#[derive(Debug, Clone)]
 pub struct Label<'a> {
     pub x: f64,
     pub y: f64,
@@ -37,23 +32,56 @@ pub struct Label<'a> {
     pub color: Color,
 }
 
+#[derive(Debug, Clone)]
 struct Layer {
     string: String,
     colors: Vec<Color>,
 }
 
-struct Grid {
+trait Grid: Debug {
+    fn width(&self) -> u16;
+    fn height(&self) -> u16;
+    fn resolution(&self) -> (f64, f64);
+    fn paint(&mut self, x: usize, y: usize, color: Color);
+    fn save(&self) -> Layer;
+    fn reset(&mut self);
+}
+
+#[derive(Debug, Clone)]
+struct BrailleGrid {
+    width: u16,
+    height: u16,
     cells: Vec<u16>,
     colors: Vec<Color>,
 }
 
-impl Grid {
-    fn new(width: usize, height: usize) -> Grid {
-        Grid {
-            cells: vec![BRAILLE_OFFSET; width * height],
-            colors: vec![Color::Reset; width * height],
+impl BrailleGrid {
+    fn new(width: u16, height: u16) -> BrailleGrid {
+        let length = usize::from(width * height);
+        BrailleGrid {
+            width,
+            height,
+            cells: vec![symbols::braille::BLANK; length],
+            colors: vec![Color::Reset; length],
         }
     }
+}
+
+impl Grid for BrailleGrid {
+    fn width(&self) -> u16 {
+        self.width
+    }
+
+    fn height(&self) -> u16 {
+        self.height
+    }
+
+    fn resolution(&self) -> (f64, f64) {
+        (
+            f64::from(self.width) * 2.0 - 1.0,
+            f64::from(self.height) * 4.0 - 1.0,
+        )
+    }
 
     fn save(&self) -> Layer {
         Layer {
@@ -64,47 +92,197 @@ impl Grid {
 
     fn reset(&mut self) {
         for c in &mut self.cells {
-            *c = BRAILLE_OFFSET;
+            *c = symbols::braille::BLANK;
         }
         for c in &mut self.colors {
             *c = Color::Reset;
         }
     }
+
+    fn paint(&mut self, x: usize, y: usize, color: Color) {
+        let index = y / 4 * self.width as usize + x / 2;
+        if let Some(c) = self.cells.get_mut(index) {
+            *c |= symbols::braille::DOTS[y % 4][x % 2];
+        }
+        if let Some(c) = self.colors.get_mut(index) {
+            *c = color;
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+struct CharGrid {
+    width: u16,
+    height: u16,
+    cells: Vec<char>,
+    colors: Vec<Color>,
+    cell_char: char,
+}
+
+impl CharGrid {
+    fn new(width: u16, height: u16, cell_char: char) -> CharGrid {
+        let length = usize::from(width * height);
+        CharGrid {
+            width,
+            height,
+            cells: vec![' '; length],
+            colors: vec![Color::Reset; length],
+            cell_char,
+        }
+    }
+}
+
+impl Grid for CharGrid {
+    fn width(&self) -> u16 {
+        self.width
+    }
+
+    fn height(&self) -> u16 {
+        self.height
+    }
+
+    fn resolution(&self) -> (f64, f64) {
+        (f64::from(self.width) - 1.0, f64::from(self.height) - 1.0)
+    }
+
+    fn save(&self) -> Layer {
+        Layer {
+            string: self.cells.iter().collect(),
+            colors: self.colors.clone(),
+        }
+    }
+
+    fn reset(&mut self) {
+        for c in &mut self.cells {
+            *c = ' ';
+        }
+        for c in &mut self.colors {
+            *c = Color::Reset;
+        }
+    }
+
+    fn paint(&mut self, x: usize, y: usize, color: Color) {
+        let index = y * self.width as usize + x;
+        if let Some(c) = self.cells.get_mut(index) {
+            *c = self.cell_char;
+        }
+        if let Some(c) = self.colors.get_mut(index) {
+            *c = color;
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct Painter<'a, 'b> {
+    context: &'a mut Context<'b>,
+    resolution: (f64, f64),
+}
+
+impl<'a, 'b> Painter<'a, 'b> {
+    /// Convert the (x, y) coordinates to location of a point on the grid
+    ///
+    /// # Examples:
+    /// ```
+    /// use tui::{symbols, widgets::canvas::{Painter, Context}};
+    ///
+    /// let mut ctx = Context::new(2, 2, [1.0, 2.0], [0.0, 2.0], symbols::Marker::Braille);
+    /// let mut painter = Painter::from(&mut ctx);
+    /// let point = painter.get_point(1.0, 0.0);
+    /// assert_eq!(point, Some((0, 7)));
+    /// let point = painter.get_point(1.5, 1.0);
+    /// assert_eq!(point, Some((1, 3)));
+    /// let point = painter.get_point(0.0, 0.0);
+    /// assert_eq!(point, None);
+    /// let point = painter.get_point(2.0, 2.0);
+    /// assert_eq!(point, Some((3, 0)));
+    /// let point = painter.get_point(1.0, 2.0);
+    /// assert_eq!(point, Some((0, 0)));
+    /// ```
+    pub fn get_point(&self, x: f64, y: f64) -> Option<(usize, usize)> {
+        let left = self.context.x_bounds[0];
+        let right = self.context.x_bounds[1];
+        let top = self.context.y_bounds[1];
+        let bottom = self.context.y_bounds[0];
+        if x < left || x > right || y < bottom || y > top {
+            return None;
+        }
+        let width = (self.context.x_bounds[1] - self.context.x_bounds[0]).abs();
+        let height = (self.context.y_bounds[1] - self.context.y_bounds[0]).abs();
+        if width == 0.0 || height == 0.0 {
+            return None;
+        }
+        let x = ((x - left) * self.resolution.0 / width) as usize;
+        let y = ((top - y) * self.resolution.1 / height) as usize;
+        Some((x, y))
+    }
+
+    /// Paint a point of the grid
+    ///
+    /// # Examples:
+    /// ```
+    /// use tui::{style::Color, symbols, widgets::canvas::{Painter, Context}};
+    ///
+    /// let mut ctx = Context::new(1, 1, [0.0, 2.0], [0.0, 2.0], symbols::Marker::Braille);
+    /// let mut painter = Painter::from(&mut ctx);
+    /// let cell = painter.paint(1, 3, Color::Red);
+    /// ```
+    pub fn paint(&mut self, x: usize, y: usize, color: Color) {
+        self.context.grid.paint(x, y, color);
+    }
+}
+
+impl<'a, 'b> From<&'a mut Context<'b>> for Painter<'a, 'b> {
+    fn from(context: &'a mut Context<'b>) -> Painter<'a, 'b> {
+        let resolution = context.grid.resolution();
+        Painter {
+            context,
+            resolution,
+        }
+    }
 }
 
 /// Holds the state of the Canvas when painting to it.
+#[derive(Debug)]
 pub struct Context<'a> {
-    width: u16,
-    height: u16,
     x_bounds: [f64; 2],
     y_bounds: [f64; 2],
-    grid: Grid,
+    grid: Box<dyn Grid>,
     dirty: bool,
     layers: Vec<Layer>,
     labels: Vec<Label<'a>>,
 }
 
 impl<'a> Context<'a> {
+    pub fn new(
+        width: u16,
+        height: u16,
+        x_bounds: [f64; 2],
+        y_bounds: [f64; 2],
+        marker: symbols::Marker,
+    ) -> Context<'a> {
+        let grid: Box<dyn Grid> = match marker {
+            symbols::Marker::Dot => Box::new(CharGrid::new(width, height, '•')),
+            symbols::Marker::Block => Box::new(CharGrid::new(width, height, '▄')),
+            symbols::Marker::Braille => Box::new(BrailleGrid::new(width, height)),
+        };
+        Context {
+            x_bounds,
+            y_bounds,
+            grid,
+            dirty: false,
+            layers: Vec::new(),
+            labels: Vec::new(),
+        }
+    }
+
     /// Draw any object that may implement the Shape trait
-    pub fn draw<'b, S>(&mut self, shape: &'b S)
+    pub fn draw<S>(&mut self, shape: &S)
     where
-        S: Shape<'b>,
+        S: Shape,
     {
         self.dirty = true;
-        let left = self.x_bounds[0];
-        let right = self.x_bounds[1];
-        let bottom = self.y_bounds[0];
-        let top = self.y_bounds[1];
-        for (x, y) in shape
-            .points()
-            .filter(|&(x, y)| !(x < left || x > right || y < bottom || y > top))
-        {
-            let dy = ((top - y) * f64::from(self.height - 1) * 4.0 / (top - bottom)) as usize;
-            let dx = ((x - left) * f64::from(self.width - 1) * 2.0 / (right - left)) as usize;
-            let index = dy / 4 * self.width as usize + dx / 2;
-            self.grid.cells[index] |= DOTS[dy % 4][dx % 2];
-            self.grid.colors[index] = shape.color();
-        }
+        let mut painter = Painter::from(self);
+        shape.draw(&mut painter);
     }
 
     /// Go one layer above in the canvas.
@@ -132,37 +310,35 @@ 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()
 ///     .block(Block::default().title("Canvas").borders(Borders::ALL))
 ///     .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 {
+///             x: 10.0,
+///             y: 20.0,
+///             width: 10.0,
+///             height: 10.0,
 ///             color: Color::Red
 ///         });
 ///     });
-/// # }
 /// ```
 pub struct Canvas<'a, F>
 where
@@ -173,6 +349,7 @@ where
     y_bounds: [f64; 2],
     painter: Option<F>,
     background_color: Color,
+    marker: symbols::Marker,
 }
 
 impl<'a, F> Default for Canvas<'a, F>
@@ -186,6 +363,7 @@ where
             y_bounds: [0.0, 0.0],
             painter: None,
             background_color: Color::Reset,
+            marker: symbols::Marker::Braille,
         }
     }
 }
@@ -198,10 +376,12 @@ where
         self.block = Some(block);
         self
     }
+
     pub fn x_bounds(mut self, bounds: [f64; 2]) -> Canvas<'a, F> {
         self.x_bounds = bounds;
         self
     }
+
     pub fn y_bounds(mut self, bounds: [f64; 2]) -> Canvas<'a, F> {
         self.y_bounds = bounds;
         self
@@ -217,77 +397,106 @@ where
         self.background_color = color;
         self
     }
+
+    /// Change the type of points used to draw the shapes. By default the braille patterns are used
+    /// as they provide a more fine grained result but you might want to use the simple dot or
+    /// block instead if the targeted terminal does not support those symbols.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use tui::widgets::canvas::Canvas;
+    /// # use tui::symbols;
+    /// Canvas::default().marker(symbols::Marker::Braille).paint(|ctx| {});
+    ///
+    /// Canvas::default().marker(symbols::Marker::Dot).paint(|ctx| {});
+    ///
+    /// Canvas::default().marker(symbols::Marker::Block).paint(|ctx| {});
+    /// ```
+    pub fn marker(mut self, marker: symbols::Marker) -> Canvas<'a, F> {
+        self.marker = marker;
+        self
+    }
 }
 
 impl<'a, F> Widget for Canvas<'a, F>
 where
     F: Fn(&mut Context),
 {
-    fn draw(&mut self, area: Rect, buf: &mut Buffer) {
-        let canvas_area = match self.block {
-            Some(ref mut b) => {
-                b.draw(area, buf);
-                b.inner(area)
+    fn render(mut self, area: Rect, buf: &mut Buffer) {
+        let canvas_area = match self.block.take() {
+            Some(b) => {
+                let inner_area = b.inner(area);
+                b.render(area, buf);
+                inner_area
             }
             None => area,
         };
 
         let width = canvas_area.width as usize;
-        let height = canvas_area.height as usize;
 
-        if let Some(ref painter) = self.painter {
-            // Create a blank context that match the size of the terminal
-            let mut ctx = Context {
-                x_bounds: self.x_bounds,
-                y_bounds: self.y_bounds,
-                width: canvas_area.width,
-                height: canvas_area.height,
-                grid: Grid::new(width, height),
-                dirty: false,
-                layers: Vec::new(),
-                labels: Vec::new(),
-            };
-            // Paint to this context
-            painter(&mut ctx);
-            ctx.finish();
+        let painter = match self.painter {
+            Some(ref p) => p,
+            None => return,
+        };
 
-            // Retreive painted points for each layer
-            for layer in ctx.layers {
-                for (i, (ch, color)) in layer
-                    .string
-                    .chars()
-                    .zip(layer.colors.into_iter())
-                    .enumerate()
-                {
-                    if ch != BRAILLE_BLANK {
-                        let (x, y) = (i % width, i / width);
-                        buf.get_mut(x as u16 + canvas_area.left(), y as u16 + canvas_area.top())
-                            .set_char(ch)
-                            .set_fg(color)
-                            .set_bg(self.background_color);
-                    }
+        // Create a blank context that match the size of the canvas
+        let mut ctx = Context::new(
+            canvas_area.width,
+            canvas_area.height,
+            self.x_bounds,
+            self.y_bounds,
+            self.marker,
+        );
+        // Paint to this context
+        painter(&mut ctx);
+        ctx.finish();
+
+        // Retreive painted points for each layer
+        for layer in ctx.layers {
+            for (i, (ch, color)) in layer
+                .string
+                .chars()
+                .zip(layer.colors.into_iter())
+                .enumerate()
+            {
+                if ch != ' ' && ch != '\u{2800}' {
+                    let (x, y) = (i % width, i / width);
+                    buf.get_mut(x as u16 + canvas_area.left(), y as u16 + canvas_area.top())
+                        .set_char(ch)
+                        .set_fg(color)
+                        .set_bg(self.background_color);
                 }
             }
+        }
 
-            // Finally draw the labels
-            let style = Style::default().bg(self.background_color);
-            for label in ctx.labels.iter().filter(|l| {
-                !(l.x < self.x_bounds[0]
-                    || l.x > self.x_bounds[1]
-                    || l.y < self.y_bounds[0]
-                    || l.y > self.y_bounds[1])
-            }) {
-                let dy = ((self.y_bounds[1] - label.y) * f64::from(canvas_area.height - 1)
-                    / (self.y_bounds[1] - self.y_bounds[0])) as u16;
-                let dx = ((label.x - self.x_bounds[0]) * f64::from(canvas_area.width - 1)
-                    / (self.x_bounds[1] - self.x_bounds[0])) as u16;
-                buf.set_string(
-                    dx + canvas_area.left(),
-                    dy + canvas_area.top(),
-                    label.text,
-                    style.fg(label.color),
-                );
-            }
+        // Finally draw the labels
+        let style = Style::default().bg(self.background_color);
+        let left = self.x_bounds[0];
+        let right = self.x_bounds[1];
+        let top = self.y_bounds[1];
+        let bottom = self.y_bounds[0];
+        let width = (self.x_bounds[1] - self.x_bounds[0]).abs();
+        let height = (self.y_bounds[1] - self.y_bounds[0]).abs();
+        let resolution = {
+            let width = f64::from(canvas_area.width - 1);
+            let height = f64::from(canvas_area.height - 1);
+            (width, height)
+        };
+        for label in ctx
+            .labels
+            .iter()
+            .filter(|l| l.x >= left && l.x <= right && l.y <= top && l.y >= bottom)
+        {
+            let x = ((label.x - left) * resolution.0 / width) as u16 + canvas_area.left();
+            let y = ((top - label.y) * resolution.1 / height) as u16 + canvas_area.top();
+            buf.set_stringn(
+                x,
+                y,
+                label.text,
+                (canvas_area.right() - x) as usize,
+                style.fg(label.color),
+            );
         }
     }
 }

src/widgets/canvas/points.rs

@@ -1,20 +1,22 @@
-use std::slice;
-
-use super::Shape;
-use style::Color;
+use crate::{
+    style::Color,
+    widgets::canvas::{Painter, Shape},
+};
 
 /// A shape to draw a group of points with the given color
+#[derive(Debug, Clone)]
 pub struct Points<'a> {
     pub coords: &'a [(f64, f64)],
     pub color: Color,
 }
 
-impl<'a> Shape<'a> for Points<'a> {
-    fn color(&self) -> Color {
-        self.color
-    }
-    fn points(&'a self) -> Box<Iterator<Item = (f64, f64)> + 'a> {
-        Box::new(self.into_iter())
+impl<'a> Shape for Points<'a> {
+    fn draw(&self, painter: &mut Painter) {
+        for (x, y) in self.coords {
+            if let Some((x, y)) = painter.get_point(*x, *y) {
+                painter.paint(x, y, self.color);
+            }
+        }
     }
 }
 
@@ -26,33 +28,3 @@ impl<'a> Default for Points<'a> {
         }
     }
 }
-
-impl<'a> IntoIterator for &'a Points<'a> {
-    type Item = (f64, f64);
-    type IntoIter = PointsIterator<'a>;
-    fn into_iter(self) -> Self::IntoIter {
-        PointsIterator {
-            iter: self.coords.iter(),
-        }
-    }
-}
-
-pub struct PointsIterator<'a> {
-    iter: slice::Iter<'a, (f64, f64)>,
-}
-
-impl<'a> From<&'a [(f64, f64)]> for PointsIterator<'a> {
-    fn from(data: &'a [(f64, f64)]) -> PointsIterator<'a> {
-        PointsIterator { iter: data.iter() }
-    }
-}
-
-impl<'a> Iterator for PointsIterator<'a> {
-    type Item = (f64, f64);
-    fn next(&mut self) -> Option<Self::Item> {
-        match self.iter.next() {
-            Some(p) => Some(*p),
-            None => None,
-        }
-    }
-}

src/widgets/canvas/rectangle.rs

@@ -0,0 +1,52 @@
+use crate::{
+    style::Color,
+    widgets::canvas::{Line, Painter, Shape},
+};
+
+/// Shape to draw a rectangle from a `Rect` with the given color
+#[derive(Debug, Clone)]
+pub struct Rectangle {
+    pub x: f64,
+    pub y: f64,
+    pub width: f64,
+    pub height: f64,
+    pub color: Color,
+}
+
+impl Shape for Rectangle {
+    fn draw(&self, painter: &mut Painter) {
+        let lines: [Line; 4] = [
+            Line {
+                x1: self.x,
+                y1: self.y,
+                x2: self.x,
+                y2: self.y + self.height,
+                color: self.color,
+            },
+            Line {
+                x1: self.x,
+                y1: self.y + self.height,
+                x2: self.x + self.width,
+                y2: self.y + self.height,
+                color: self.color,
+            },
+            Line {
+                x1: self.x + self.width,
+                y1: self.y,
+                x2: self.x + self.width,
+                y2: self.y + self.height,
+                color: self.color,
+            },
+            Line {
+                x1: self.x,
+                y1: self.y,
+                x2: self.x + self.width,
+                y2: self.y,
+                color: self.color,
+            },
+        ];
+        for line in &lines {
+            line.draw(painter);
+        }
+    }
+}

src/widgets/chart.rs

@@ -1,100 +1,98 @@
-use std::cmp::max;
-
+use crate::{
+    buffer::Buffer,
+    layout::{Constraint, Rect},
+    style::{Color, Style},
+    symbols,
+    text::{Span, Spans},
+    widgets::{
+        canvas::{Canvas, Line, Points},
+        Block, Borders, Widget,
+    },
+};
+use std::{borrow::Cow, 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};
-
 /// An X or Y axis for the chart widget
-pub struct Axis<'a, L>
-where
-    L: AsRef<str> + 'a,
-{
+#[derive(Debug, Clone)]
+pub struct Axis<'a> {
     /// Title displayed next to axis end
-    title: Option<&'a str>,
-    /// Style of the title
-    title_style: Style,
+    title: Option<Spans<'a>>,
     /// Bounds for the axis (all data points outside these limits will not be represented)
     bounds: [f64; 2],
     /// A list of labels to put to the left or below the axis
-    labels: Option<&'a [L]>,
-    /// The labels' style
-    labels_style: Style,
+    labels: Option<Vec<Span<'a>>>,
     /// The style used to draw the axis itself
     style: Style,
 }
 
-impl<'a, L> Default for Axis<'a, L>
-where
-    L: AsRef<str>,
-{
-    fn default() -> Axis<'a, L> {
+impl<'a> Default for Axis<'a> {
+    fn default() -> Axis<'a> {
         Axis {
             title: None,
-            title_style: Default::default(),
             bounds: [0.0, 0.0],
             labels: None,
-            labels_style: Default::default(),
             style: Default::default(),
         }
     }
 }
 
-impl<'a, L> Axis<'a, L>
-where
-    L: AsRef<str>,
-{
-    pub fn title(mut self, title: &'a str) -> Axis<'a, L> {
-        self.title = Some(title);
+impl<'a> Axis<'a> {
+    pub fn title<T>(mut self, title: T) -> Axis<'a>
+    where
+        T: Into<Spans<'a>>,
+    {
+        self.title = Some(title.into());
         self
     }
 
-    pub fn title_style(mut self, style: Style) -> Axis<'a, L> {
-        self.title_style = style;
+    #[deprecated(
+        since = "0.10.0",
+        note = "You should use styling capabilities of `text::Spans` given as argument of the `title` method to apply styling to the title."
+    )]
+    pub fn title_style(mut self, style: Style) -> Axis<'a> {
+        if let Some(t) = self.title {
+            let title = String::from(t);
+            self.title = Some(Spans::from(Span::styled(title, style)));
+        }
         self
     }
 
-    pub fn bounds(mut self, bounds: [f64; 2]) -> Axis<'a, L> {
+    pub fn bounds(mut self, bounds: [f64; 2]) -> Axis<'a> {
         self.bounds = bounds;
         self
     }
 
-    pub fn labels(mut self, labels: &'a [L]) -> Axis<'a, L> {
+    pub fn labels(mut self, labels: Vec<Span<'a>>) -> Axis<'a> {
         self.labels = Some(labels);
         self
     }
 
-    pub fn labels_style(mut self, style: Style) -> Axis<'a, L> {
-        self.labels_style = style;
-        self
-    }
-
-    pub fn style(mut self, style: Style) -> Axis<'a, L> {
+    pub fn style(mut self, style: Style) -> Axis<'a> {
         self.style = style;
         self
     }
 }
 
-/// Marker to use when plotting data points
-pub enum Marker {
-    /// One point per cell
-    Dot,
-    /// Up to 8 points per cell
-    Braille,
+/// Used to determine which style of graphing to use
+#[derive(Debug, Clone, Copy)]
+pub enum GraphType {
+    /// Draw each point
+    Scatter,
+    /// Draw each point and lines between each point using the same marker
+    Line,
 }
 
 /// A group of data points
+#[derive(Debug, Clone)]
 pub struct Dataset<'a> {
     /// Name of the dataset (used in the legend if shown)
-    name: &'a str,
+    name: Cow<'a, str>,
     /// A reference to the actual data
     data: &'a [(f64, f64)],
     /// Symbol used for each points of this dataset
-    marker: Marker,
+    marker: symbols::Marker,
+    /// Determines graph type used for drawing points
+    graph_type: GraphType,
     /// Style used to plot this dataset
     style: Style,
 }
@@ -102,17 +100,21 @@ pub struct Dataset<'a> {
 impl<'a> Default for Dataset<'a> {
     fn default() -> Dataset<'a> {
         Dataset {
-            name: "",
+            name: Cow::from(""),
             data: &[],
-            marker: Marker::Dot,
+            marker: symbols::Marker::Dot,
+            graph_type: GraphType::Scatter,
             style: Style::default(),
         }
     }
 }
 
 impl<'a> Dataset<'a> {
-    pub fn name(mut self, name: &'a str) -> Dataset<'a> {
-        self.name = name;
+    pub fn name<S>(mut self, name: S) -> Dataset<'a>
+    where
+        S: Into<Cow<'a, str>>,
+    {
+        self.name = name.into();
         self
     }
 
@@ -121,11 +123,16 @@ impl<'a> Dataset<'a> {
         self
     }
 
-    pub fn marker(mut self, marker: Marker) -> Dataset<'a> {
+    pub fn marker(mut self, marker: symbols::Marker) -> Dataset<'a> {
         self.marker = marker;
         self
     }
 
+    pub fn graph_type(mut self, graph_type: GraphType) -> Dataset<'a> {
+        self.graph_type = graph_type;
+        self
+    }
+
     pub fn style(mut self, style: Style) -> Dataset<'a> {
         self.style = style;
         self
@@ -134,15 +141,23 @@ impl<'a> Dataset<'a> {
 
 /// A container that holds all the infos about where to display each elements of the chart (axis,
 /// labels, legend, ...).
-#[derive(Debug)]
+#[derive(Debug, Clone, PartialEq)]
 struct ChartLayout {
+    /// Location of the title of the x axis
     title_x: Option<(u16, u16)>,
+    /// Location of the title of the y axis
     title_y: Option<(u16, u16)>,
+    /// Location of the first label of the x axis
     label_x: Option<u16>,
+    /// Location of the first label of the y axis
     label_y: Option<u16>,
+    /// Y coordinate of the horizontal axis
     axis_x: Option<u16>,
+    /// X coordinate of the vertical axis
     axis_y: Option<u16>,
+    /// Area of the legend
     legend_area: Option<Rect>,
+    /// Area of the graph
     graph_area: Rect,
 }
 
@@ -166,96 +181,103 @@ impl Default for ChartLayout {
 /// # Examples
 ///
 /// ```
-/// # extern crate tui;
-/// # use tui::widgets::{Block, Borders, Chart, Axis, Dataset, Marker};
+/// # use tui::symbols;
+/// # use tui::widgets::{Block, Borders, Chart, Axis, Dataset, GraphType};
 /// # use tui::style::{Style, Color};
-/// # fn main() {
-/// Chart::default()
+/// # use tui::text::Span;
+/// let datasets = vec![
+///     Dataset::default()
+///         .name("data1")
+///         .marker(symbols::Marker::Dot)
+///         .graph_type(GraphType::Scatter)
+///         .style(Style::default().fg(Color::Cyan))
+///         .data(&[(0.0, 5.0), (1.0, 6.0), (1.5, 6.434)]),
+///     Dataset::default()
+///         .name("data2")
+///         .marker(symbols::Marker::Braille)
+///         .graph_type(GraphType::Line)
+///         .style(Style::default().fg(Color::Magenta))
+///         .data(&[(4.0, 5.0), (5.0, 8.0), (7.66, 13.5)]),
+/// ];
+/// Chart::new(datasets)
 ///     .block(Block::default().title("Chart"))
 ///     .x_axis(Axis::default()
-///         .title("X Axis")
-///         .title_style(Style::default().fg(Color::Red))
-///         .style(Style::default().fg(Color::Gray))
+///         .title(Span::styled("X Axis", Style::default().fg(Color::Red)))
+///         .style(Style::default().fg(Color::White))
 ///         .bounds([0.0, 10.0])
-///         .labels(&["0.0", "5.0", "10.0"]))
+///         .labels(["0.0", "5.0", "10.0"].iter().cloned().map(Span::from).collect()))
 ///     .y_axis(Axis::default()
-///         .title("Y Axis")
-///         .title_style(Style::default().fg(Color::Red))
-///         .style(Style::default().fg(Color::Gray))
+///         .title(Span::styled("Y Axis", Style::default().fg(Color::Red)))
+///         .style(Style::default().fg(Color::White))
 ///         .bounds([0.0, 10.0])
-///         .labels(&["0.0", "5.0", "10.0"]))
-///     .datasets(&[Dataset::default()
-///                     .name("data1")
-///                     .marker(Marker::Dot)
-///                     .style(Style::default().fg(Color::Cyan))
-///                     .data(&[(0.0, 5.0), (1.0, 6.0), (1.5, 6.434)]),
-///                 Dataset::default()
-///                     .name("data2")
-///                     .marker(Marker::Braille)
-///                     .style(Style::default().fg(Color::Magenta))
-///                     .data(&[(4.0, 5.0), (5.0, 8.0), (7.66, 13.5)])]);
-/// # }
+///         .labels(["0.0", "5.0", "10.0"].iter().cloned().map(Span::from).collect()));
 /// ```
-pub struct Chart<'a, LX, LY>
-where
-    LX: AsRef<str> + 'a,
-    LY: AsRef<str> + 'a,
-{
+#[derive(Debug, Clone)]
+pub struct Chart<'a> {
     /// A block to display around the widget eventually
     block: Option<Block<'a>>,
     /// The horizontal axis
-    x_axis: Axis<'a, LX>,
+    x_axis: Axis<'a>,
     /// The vertical axis
-    y_axis: Axis<'a, LY>,
+    y_axis: Axis<'a>,
     /// A reference to the datasets
-    datasets: &'a [Dataset<'a>],
+    datasets: Vec<Dataset<'a>>,
     /// The widget base style
     style: Style,
+    /// Constraints used to determine whether the legend should be shown or not
+    hidden_legend_constraints: (Constraint, Constraint),
 }
 
-impl<'a, LX, LY> Default for Chart<'a, LX, LY>
-where
-    LX: AsRef<str>,
-    LY: AsRef<str>,
-{
-    fn default() -> Chart<'a, LX, LY> {
+impl<'a> Chart<'a> {
+    pub fn new(datasets: Vec<Dataset<'a>>) -> Chart<'a> {
         Chart {
             block: None,
             x_axis: Axis::default(),
             y_axis: Axis::default(),
             style: Default::default(),
-            datasets: &[],
+            datasets,
+            hidden_legend_constraints: (Constraint::Ratio(1, 4), Constraint::Ratio(1, 4)),
         }
     }
-}
 
-impl<'a, LX, LY> Chart<'a, LX, LY>
-where
-    LX: AsRef<str>,
-    LY: AsRef<str>,
-{
-    pub fn block(mut self, block: Block<'a>) -> Chart<'a, LX, LY> {
+    pub fn block(mut self, block: Block<'a>) -> Chart<'a> {
         self.block = Some(block);
         self
     }
 
-    pub fn style(mut self, style: Style) -> Chart<'a, LX, LY> {
+    pub fn style(mut self, style: Style) -> Chart<'a> {
         self.style = style;
         self
     }
 
-    pub fn x_axis(mut self, axis: Axis<'a, LX>) -> Chart<'a, LX, LY> {
+    pub fn x_axis(mut self, axis: Axis<'a>) -> Chart<'a> {
         self.x_axis = axis;
         self
     }
 
-    pub fn y_axis(mut self, axis: Axis<'a, LY>) -> Chart<'a, LX, LY> {
+    pub fn y_axis(mut self, axis: Axis<'a>) -> Chart<'a> {
         self.y_axis = axis;
         self
     }
 
-    pub fn datasets(mut self, datasets: &'a [Dataset<'a>]) -> Chart<'a, LX, LY> {
-        self.datasets = datasets;
+    /// Set the constraints used to determine whether the legend should be shown or not.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use tui::widgets::Chart;
+    /// # use tui::layout::Constraint;
+    /// let constraints = (
+    ///     Constraint::Ratio(1, 3),
+    ///     Constraint::Ratio(1, 4)
+    /// );
+    /// // Hide the legend when either its width is greater than 33% of the total widget width
+    /// // or if its height is greater than 25% of the total widget height.
+    /// let _chart: Chart = Chart::new(vec![])
+    ///     .hidden_legend_constraints(constraints);
+    /// ```
+    pub fn hidden_legend_constraints(mut self, constraints: (Constraint, Constraint)) -> Chart<'a> {
+        self.hidden_legend_constraints = constraints;
         self
     }
 
@@ -274,14 +296,11 @@ where
             y -= 1;
         }
 
-        if let Some(y_labels) = self.y_axis.labels {
-            let mut max_width = y_labels
-                .iter()
-                .fold(0, |acc, l| max(l.as_ref().width(), acc))
-                as u16;
-            if let Some(x_labels) = self.x_axis.labels {
+        if let Some(ref y_labels) = self.y_axis.labels {
+            let mut max_width = y_labels.iter().map(Span::width).max().unwrap_or_default() as u16;
+            if let Some(ref x_labels) = self.x_axis.labels {
                 if !x_labels.is_empty() {
-                    max_width = max(max_width, x_labels[0].as_ref().width() as u16);
+                    max_width = max(max_width, x_labels[0].content.width() as u16);
                 }
             }
             if x + max_width < area.right() {
@@ -304,26 +323,34 @@ where
             layout.graph_area = Rect::new(x, area.top(), area.right() - x, y - area.top() + 1);
         }
 
-        if let Some(title) = self.x_axis.title {
+        if let Some(ref title) = self.x_axis.title {
             let w = title.width() as u16;
             if w < layout.graph_area.width && layout.graph_area.height > 2 {
                 layout.title_x = Some((x + layout.graph_area.width - w, y));
             }
         }
 
-        if let Some(title) = self.y_axis.title {
+        if let Some(ref title) = self.y_axis.title {
             let w = title.width() as u16;
             if w + 1 < layout.graph_area.width && layout.graph_area.height > 2 {
-                layout.title_y = Some((x + 1, area.top()));
+                layout.title_y = Some((x, area.top()));
             }
         }
 
         if let Some(inner_width) = self.datasets.iter().map(|d| d.name.width() as u16).max() {
             let legend_width = inner_width + 2;
             let legend_height = self.datasets.len() as u16 + 2;
-            if legend_width < layout.graph_area.width / 3
-                && legend_height < layout.graph_area.height / 3
-                && inner_width > 0
+            let max_legend_width = self
+                .hidden_legend_constraints
+                .0
+                .apply(layout.graph_area.width);
+            let max_legend_height = self
+                .hidden_legend_constraints
+                .1
+                .apply(layout.graph_area.height);
+            if inner_width > 0
+                && legend_width < max_legend_width
+                && legend_height < max_legend_height
             {
                 layout.legend_area = Some(Rect::new(
                     layout.graph_area.right() - legend_width,
@@ -337,16 +364,19 @@ where
     }
 }
 
-impl<'a, LX, LY> Widget for Chart<'a, LX, LY>
-where
-    LX: AsRef<str>,
-    LY: AsRef<str>,
-{
-    fn draw(&mut self, area: Rect, buf: &mut Buffer) {
-        let chart_area = match self.block {
-            Some(ref mut b) => {
-                b.draw(area, buf);
-                b.inner(area)
+impl<'a> Widget for Chart<'a> {
+    fn render(mut self, area: Rect, buf: &mut Buffer) {
+        buf.set_style(area, self.style);
+        // Sample the style of the entire widget. This sample will be used to reset the style of
+        // the cells that are part of the components put on top of the grah area (i.e legend and
+        // axis names).
+        let original_style = buf.get(area.left(), area.top()).style();
+
+        let chart_area = match self.block.take() {
+            Some(b) => {
+                let inner_area = b.inner(area);
+                b.render(area, buf);
+                inner_area
             }
             None => area,
         };
@@ -357,30 +387,18 @@ where
             return;
         }
 
-        self.background(&chart_area, buf, self.style.bg);
-
-        if let Some((x, y)) = layout.title_x {
-            let title = self.x_axis.title.unwrap();
-            buf.set_string(x, y, title, self.x_axis.style);
-        }
-
-        if let Some((x, y)) = layout.title_y {
-            let title = self.y_axis.title.unwrap();
-            buf.set_string(x, y, title, self.y_axis.style);
-        }
-
         if let Some(y) = layout.label_x {
             let labels = self.x_axis.labels.unwrap();
-            let total_width = labels.iter().fold(0, |acc, l| l.as_ref().width() + acc) as u16;
+            let total_width = labels.iter().map(Span::width).sum::<usize>() as u16;
             let labels_len = labels.len() as u16;
             if total_width < graph_area.width && labels_len > 1 {
                 for (i, label) in labels.iter().enumerate() {
-                    buf.set_string(
+                    buf.set_span(
                         graph_area.left() + i as u16 * (graph_area.width - 1) / (labels_len - 1)
-                            - label.as_ref().width() as u16,
+                            - label.content.width() as u16,
                         y,
-                        label.as_ref(),
-                        self.x_axis.labels_style,
+                        label,
+                        label.width() as u16,
                     );
                 }
             }
@@ -392,12 +410,7 @@ where
             for (i, label) in labels.iter().enumerate() {
                 let dy = i as u16 * (graph_area.height - 1) / (labels_len - 1);
                 if dy < graph_area.bottom() {
-                    buf.set_string(
-                        x,
-                        graph_area.bottom() - 1 - dy,
-                        label.as_ref(),
-                        self.y_axis.labels_style,
-                    );
+                    buf.set_span(x, graph_area.bottom() - 1 - dy, label, label.width() as u16);
                 }
             }
         }
@@ -426,54 +439,117 @@ 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;
-
-                    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)
-                        .x_bounds(self.x_axis.bounds)
-                        .y_bounds(self.y_axis.bounds)
-                        .paint(|ctx| {
-                            ctx.draw(&Points {
-                                coords: dataset.data,
-                                color: dataset.style.fg,
-                            });
-                        })
-                        .draw(graph_area, buf);
-                }
-            }
+        for dataset in &self.datasets {
+            Canvas::default()
+                .background_color(self.style.bg.unwrap_or(Color::Reset))
+                .x_bounds(self.x_axis.bounds)
+                .y_bounds(self.y_axis.bounds)
+                .marker(dataset.marker)
+                .paint(|ctx| {
+                    ctx.draw(&Points {
+                        coords: dataset.data,
+                        color: dataset.style.fg.unwrap_or(Color::Reset),
+                    });
+                    if let GraphType::Line = dataset.graph_type {
+                        for data in dataset.data.windows(2) {
+                            ctx.draw(&Line {
+                                x1: data[0].0,
+                                y1: data[0].1,
+                                x2: data[1].0,
+                                y2: data[1].1,
+                                color: dataset.style.fg.unwrap_or(Color::Reset),
+                            })
+                        }
+                    }
+                })
+                .render(graph_area, buf);
         }
 
         if let Some(legend_area) = layout.legend_area {
+            buf.set_style(legend_area, original_style);
             Block::default()
                 .borders(Borders::ALL)
-                .draw(legend_area, buf);
+                .render(legend_area, buf);
             for (i, dataset) in self.datasets.iter().enumerate() {
                 buf.set_string(
                     legend_area.x + 1,
                     legend_area.y + 1 + i as u16,
-                    dataset.name,
+                    &dataset.name,
                     dataset.style,
                 );
             }
         }
+
+        if let Some((x, y)) = layout.title_x {
+            let title = self.x_axis.title.unwrap();
+            let width = graph_area.right().saturating_sub(x);
+            buf.set_style(
+                Rect {
+                    x,
+                    y,
+                    width,
+                    height: 1,
+                },
+                original_style,
+            );
+            buf.set_spans(x, y, &title, width);
+        }
+
+        if let Some((x, y)) = layout.title_y {
+            let title = self.y_axis.title.unwrap();
+            let width = graph_area.right().saturating_sub(x);
+            buf.set_style(
+                Rect {
+                    x,
+                    y,
+                    width,
+                    height: 1,
+                },
+                original_style,
+            );
+            buf.set_spans(x, y, &title, width);
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    struct LegendTestCase {
+        chart_area: Rect,
+        hidden_legend_constraints: (Constraint, Constraint),
+        legend_area: Option<Rect>,
+    }
+
+    #[test]
+    fn it_should_hide_the_legend() {
+        let data = [(0.0, 5.0), (1.0, 6.0), (3.0, 7.0)];
+        let cases = [
+            LegendTestCase {
+                chart_area: Rect::new(0, 0, 100, 100),
+                hidden_legend_constraints: (Constraint::Ratio(1, 4), Constraint::Ratio(1, 4)),
+                legend_area: Some(Rect::new(88, 0, 12, 12)),
+            },
+            LegendTestCase {
+                chart_area: Rect::new(0, 0, 100, 100),
+                hidden_legend_constraints: (Constraint::Ratio(1, 10), Constraint::Ratio(1, 4)),
+                legend_area: None,
+            },
+        ];
+        for case in &cases {
+            let datasets = (0..10)
+                .map(|i| {
+                    let name = format!("Dataset #{}", i);
+                    Dataset::default().name(name).data(&data)
+                })
+                .collect::<Vec<_>>();
+            let chart = Chart::new(datasets)
+                .x_axis(Axis::default().title("X axis"))
+                .y_axis(Axis::default().title("Y axis"))
+                .hidden_legend_constraints(case.hidden_legend_constraints);
+            let layout = chart.layout(case.chart_area);
+            assert_eq!(layout.legend_area, case.legend_area);
+        }
     }
 }

src/widgets/clear.rs

@@ -0,0 +1,36 @@
+use crate::buffer::Buffer;
+use crate::layout::Rect;
+use crate::widgets::Widget;
+
+/// A widget to to clear/reset a certain area to allow overdrawing (e.g. for popups)
+///
+/// # Examples
+///
+/// ```
+/// # use tui::widgets::{Clear, Block, Borders};
+/// # use tui::layout::Rect;
+/// # use tui::Frame;
+/// # use tui::backend::Backend;
+/// fn draw_on_clear<B: Backend>(f: &mut Frame<B>, area: Rect) {
+///     let block = Block::default().title("Block").borders(Borders::ALL);
+///     f.render_widget(Clear, area); // <- this will clear/reset the area first
+///     f.render_widget(block, area); // now render the block widget
+/// }
+/// ```
+///
+/// # Popup Example
+///
+/// For a more complete example how to utilize `Clear` to realize popups see
+/// the example `examples/popup.rs`
+#[derive(Debug, Clone)]
+pub struct Clear;
+
+impl Widget for Clear {
+    fn render(self, area: Rect, buf: &mut Buffer) {
+        for x in area.left()..area.right() {
+            for y in area.top()..area.bottom() {
+                buf.get_mut(x, y).reset();
+            }
+        }
+    }
+}

src/widgets/gauge.rs

@@ -1,39 +1,41 @@
-use unicode_width::UnicodeWidthStr;
-
-use buffer::Buffer;
-use layout::Rect;
-use style::{Color, Style};
-use widgets::{Block, Widget};
+use crate::{
+    buffer::Buffer,
+    layout::Rect,
+    style::{Color, Style},
+    symbols,
+    text::{Span, Spans},
+    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))
+///     .gauge_style(Style::default().fg(Color::White).bg(Color::Black).add_modifier(Modifier::ITALIC))
 ///     .percent(20);
-/// # }
 /// ```
+#[derive(Debug, Clone)]
 pub struct Gauge<'a> {
     block: Option<Block<'a>>,
-    percent: u16,
-    label: Option<&'a str>,
+    ratio: f64,
+    label: Option<Span<'a>>,
     style: Style,
+    gauge_style: Style,
 }
 
 impl<'a> Default for Gauge<'a> {
     fn default() -> Gauge<'a> {
         Gauge {
             block: None,
-            percent: 0,
+            ratio: 0.0,
             label: None,
-            style: Default::default(),
+            style: Style::default(),
+            gauge_style: Style::default(),
         }
     }
 }
@@ -45,12 +47,29 @@ 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
     }
 
-    pub fn label(mut self, string: &'a str) -> Gauge<'a> {
-        self.label = Some(string);
+    /// 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
+    }
+
+    pub fn label<T>(mut self, label: T) -> Gauge<'a>
+    where
+        T: Into<Span<'a>>,
+    {
+        self.label = Some(label.into());
         self
     }
 
@@ -58,28 +77,37 @@ impl<'a> Gauge<'a> {
         self.style = style;
         self
     }
+
+    pub fn gauge_style(mut self, style: Style) -> Gauge<'a> {
+        self.gauge_style = style;
+        self
+    }
 }
 
 impl<'a> Widget for Gauge<'a> {
-    fn draw(&mut self, area: Rect, buf: &mut Buffer) {
-        let gauge_area = match self.block {
-            Some(ref mut b) => {
-                b.draw(area, buf);
-                b.inner(area)
+    fn render(mut self, area: Rect, buf: &mut Buffer) {
+        buf.set_style(area, self.style);
+        let gauge_area = match self.block.take() {
+            Some(b) => {
+                let inner_area = b.inner(area);
+                b.render(area, buf);
+                inner_area
             }
             None => area,
         };
+        buf.set_style(gauge_area, self.gauge_style);
         if gauge_area.height < 1 {
             return;
         }
 
-        if self.style.bg != Color::Reset {
-            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;
+        // Label
+        let ratio = self.ratio;
+        let label = self
+            .label
+            .unwrap_or_else(|| Span::from(format!("{}%", (ratio * 100.0).round())));
         for y in gauge_area.top()..gauge_area.bottom() {
             // Gauge
             for x in gauge_area.left()..end {
@@ -87,20 +115,171 @@ impl<'a> Widget for Gauge<'a> {
             }
 
             if y == center {
-                // Label
-                let precent_label = format!("{}%", self.percent);
-                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();
-                buf.set_string(middle, y, label, self.style);
+                buf.set_span(middle, y, &label, gauge_area.right() - middle);
             }
 
             // Fix colors
             for x in gauge_area.left()..end {
                 buf.get_mut(x, y)
-                    .set_fg(self.style.bg)
-                    .set_bg(self.style.fg);
+                    .set_fg(self.gauge_style.bg.unwrap_or(Color::Reset))
+                    .set_bg(self.gauge_style.fg.unwrap_or(Color::Reset));
             }
         }
     }
 }
+
+/// A compact widget to display a task progress over a single line.
+///
+/// # Examples:
+///
+/// ```
+/// # use tui::widgets::{Widget, LineGauge, Block, Borders};
+/// # use tui::style::{Style, Color, Modifier};
+/// # use tui::symbols;
+/// LineGauge::default()
+///     .block(Block::default().borders(Borders::ALL).title("Progress"))
+///     .gauge_style(Style::default().fg(Color::White).bg(Color::Black).add_modifier(Modifier::BOLD))
+///     .line_set(symbols::line::THICK)
+///     .ratio(0.4);
+/// ```
+pub struct LineGauge<'a> {
+    block: Option<Block<'a>>,
+    ratio: f64,
+    label: Option<Spans<'a>>,
+    line_set: symbols::line::Set,
+    style: Style,
+    gauge_style: Style,
+}
+
+impl<'a> Default for LineGauge<'a> {
+    fn default() -> Self {
+        Self {
+            block: None,
+            ratio: 0.0,
+            label: None,
+            style: Style::default(),
+            line_set: symbols::line::NORMAL,
+            gauge_style: Style::default(),
+        }
+    }
+}
+
+impl<'a> LineGauge<'a> {
+    pub fn block(mut self, block: Block<'a>) -> Self {
+        self.block = Some(block);
+        self
+    }
+
+    pub fn ratio(mut self, ratio: f64) -> Self {
+        assert!(
+            ratio <= 1.0 && ratio >= 0.0,
+            "Ratio should be between 0 and 1 inclusively."
+        );
+        self.ratio = ratio;
+        self
+    }
+
+    pub fn line_set(mut self, set: symbols::line::Set) -> Self {
+        self.line_set = set;
+        self
+    }
+
+    pub fn label<T>(mut self, label: T) -> Self
+    where
+        T: Into<Spans<'a>>,
+    {
+        self.label = Some(label.into());
+        self
+    }
+
+    pub fn style(mut self, style: Style) -> Self {
+        self.style = style;
+        self
+    }
+
+    pub fn gauge_style(mut self, style: Style) -> Self {
+        self.gauge_style = style;
+        self
+    }
+}
+
+impl<'a> Widget for LineGauge<'a> {
+    fn render(mut self, area: Rect, buf: &mut Buffer) {
+        buf.set_style(area, self.style);
+        let gauge_area = match self.block.take() {
+            Some(b) => {
+                let inner_area = b.inner(area);
+                b.render(area, buf);
+                inner_area
+            }
+            None => area,
+        };
+
+        if gauge_area.height < 1 {
+            return;
+        }
+
+        let ratio = self.ratio;
+        let label = self
+            .label
+            .unwrap_or_else(move || Spans::from(format!("{:.0}%", ratio * 100.0)));
+        let (col, row) = buf.set_spans(
+            gauge_area.left(),
+            gauge_area.top(),
+            &label,
+            gauge_area.width,
+        );
+        let start = col + 1;
+        if start >= gauge_area.right() {
+            return;
+        }
+
+        let end = start
+            + (f64::from(gauge_area.right().saturating_sub(start)) * self.ratio).floor() as u16;
+        for col in start..end {
+            buf.get_mut(col, row)
+                .set_symbol(self.line_set.horizontal)
+                .set_style(Style {
+                    fg: self.gauge_style.fg,
+                    bg: None,
+                    add_modifier: self.gauge_style.add_modifier,
+                    sub_modifier: self.gauge_style.sub_modifier,
+                });
+        }
+        for col in end..gauge_area.right() {
+            buf.get_mut(col, row)
+                .set_symbol(self.line_set.horizontal)
+                .set_style(Style {
+                    fg: self.gauge_style.bg,
+                    bg: None,
+                    add_modifier: self.gauge_style.add_modifier,
+                    sub_modifier: self.gauge_style.sub_modifier,
+                });
+        }
+    }
+}
+
+#[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,114 +1,65 @@
-use std::iter;
-use std::iter::Iterator;
-
+use crate::{
+    buffer::Buffer,
+    layout::{Corner, Rect},
+    style::Style,
+    text::Text,
+    widgets::{Block, StatefulWidget, Widget},
+};
+use std::iter::{self, Iterator};
 use unicode_width::UnicodeWidthStr;
 
-use buffer::Buffer;
-use layout::{Corner, Rect};
-use style::Style;
-use widgets::{Block, Text, Widget};
+#[derive(Debug, Clone)]
+pub struct ListState {
+    offset: usize,
+    selected: Option<usize>,
+}
 
-pub struct List<'b, L>
-where
-    L: Iterator<Item = Text<'b>>,
-{
-    block: Option<Block<'b>>,
-    items: L,
+impl Default for ListState {
+    fn default() -> ListState {
+        ListState {
+            offset: 0,
+            selected: None,
+        }
+    }
+}
+
+impl ListState {
+    pub fn selected(&self) -> Option<usize> {
+        self.selected
+    }
+
+    pub fn select(&mut self, index: Option<usize>) {
+        self.selected = index;
+        if index.is_none() {
+            self.offset = 0;
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct ListItem<'a> {
+    content: Text<'a>,
     style: Style,
-    start_corner: Corner,
 }
 
-impl<'b, L> Default for List<'b, L>
-where
-    L: Iterator<Item = Text<'b>> + Default,
-{
-    fn default() -> List<'b, L> {
-        List {
-            block: None,
-            items: L::default(),
-            style: Default::default(),
-            start_corner: Corner::TopLeft,
-        }
-    }
-}
-
-impl<'b, L> List<'b, L>
-where
-    L: Iterator<Item = Text<'b>>,
-{
-    pub fn new(items: L) -> List<'b, L> {
-        List {
-            block: None,
-            items,
-            style: Default::default(),
-            start_corner: Corner::TopLeft,
-        }
-    }
-
-    pub fn block(mut self, block: Block<'b>) -> List<'b, L> {
-        self.block = Some(block);
-        self
-    }
-
-    pub fn items<I>(mut self, items: I) -> List<'b, L>
+impl<'a> ListItem<'a> {
+    pub fn new<T>(content: T) -> ListItem<'a>
     where
-        I: IntoIterator<Item = Text<'b>, IntoIter = L>,
+        T: Into<Text<'a>>,
     {
-        self.items = items.into_iter();
-        self
+        ListItem {
+            content: content.into(),
+            style: Style::default(),
+        }
     }
 
-    pub fn style(mut self, style: Style) -> List<'b, L> {
+    pub fn style(mut self, style: Style) -> ListItem<'a> {
         self.style = style;
         self
     }
 
-    pub fn start_corner(mut self, corner: Corner) -> List<'b, L> {
-        self.start_corner = corner;
-        self
-    }
-}
-
-impl<'b, L> Widget for List<'b, L>
-where
-    L: Iterator<Item = Text<'b>>,
-{
-    fn draw(&mut self, area: Rect, buf: &mut Buffer) {
-        let list_area = match self.block {
-            Some(ref mut b) => {
-                b.draw(area, buf);
-                b.inner(area)
-            }
-            None => area,
-        };
-
-        if list_area.width < 1 || list_area.height < 1 {
-            return;
-        }
-
-        self.background(&list_area, buf, self.style.bg);
-
-        for (i, item) in self
-            .items
-            .by_ref()
-            .enumerate()
-            .take(list_area.height as usize)
-        {
-            let (x, y) = match self.start_corner {
-                Corner::TopLeft => (list_area.left(), list_area.top() + i as u16),
-                Corner::BottomLeft => (list_area.left(), list_area.bottom() - (i + 1) as u16),
-                // Not supported
-                _ => (list_area.left(), list_area.top() + i as u16),
-            };
-            match item {
-                Text::Raw(ref v) => {
-                    buf.set_stringn(x, y, v, list_area.width as usize, Style::default());
-                }
-                Text::Styled(ref v, s) => {
-                    buf.set_stringn(x, y, v, list_area.width as usize, s);
-                }
-            };
-        }
+    pub fn height(&self) -> usize {
+        self.content.height()
     }
 }
 
@@ -117,130 +68,182 @@ where
 /// # Examples
 ///
 /// ```
-/// # extern crate tui;
-/// # use tui::widgets::{Block, Borders, SelectableList};
+/// # use tui::widgets::{Block, Borders, List, ListItem};
 /// # use tui::style::{Style, Color, Modifier};
-/// # fn main() {
-/// SelectableList::default()
-///     .block(Block::default().title("SelectableList").borders(Borders::ALL))
-///     .items(&["Item 1", "Item 2", "Item 3"])
-///     .select(Some(1))
+/// let items = [ListItem::new("Item 1"), ListItem::new("Item 2"), ListItem::new("Item 3")];
+/// List::new(items)
+///     .block(Block::default().title("List").borders(Borders::ALL))
 ///     .style(Style::default().fg(Color::White))
-///     .highlight_style(Style::default().modifier(Modifier::Italic))
+///     .highlight_style(Style::default().add_modifier(Modifier::ITALIC))
 ///     .highlight_symbol(">>");
-/// # }
 /// ```
-pub struct SelectableList<'b> {
-    block: Option<Block<'b>>,
-    /// Items to be displayed
-    items: Vec<&'b str>,
-    /// Index of the one selected
-    selected: Option<usize>,
-    /// Base style of the widget
+#[derive(Debug, Clone)]
+pub struct List<'a> {
+    block: Option<Block<'a>>,
+    items: Vec<ListItem<'a>>,
+    /// Style used as a base style for the widget
     style: Style,
+    start_corner: Corner,
     /// Style used to render selected item
     highlight_style: Style,
     /// Symbol in front of the selected item (Shift all items to the right)
-    highlight_symbol: Option<&'b str>,
+    highlight_symbol: Option<&'a str>,
 }
 
-impl<'b> Default for SelectableList<'b> {
-    fn default() -> SelectableList<'b> {
-        SelectableList {
+impl<'a> List<'a> {
+    pub fn new<T>(items: T) -> List<'a>
+    where
+        T: Into<Vec<ListItem<'a>>>,
+    {
+        List {
             block: None,
-            items: Vec::new(),
-            selected: None,
-            style: Default::default(),
-            highlight_style: Default::default(),
+            style: Style::default(),
+            items: items.into(),
+            start_corner: Corner::TopLeft,
+            highlight_style: Style::default(),
             highlight_symbol: None,
         }
     }
-}
 
-impl<'b> SelectableList<'b> {
-    pub fn block(mut self, block: Block<'b>) -> SelectableList<'b> {
+    pub fn block(mut self, block: Block<'a>) -> List<'a> {
         self.block = Some(block);
         self
     }
 
-    pub fn items<I>(mut self, items: &'b [I]) -> SelectableList<'b>
-    where
-        I: AsRef<str> + 'b,
-    {
-        self.items = items.iter().map(|i| i.as_ref()).collect::<Vec<&str>>();
-        self
-    }
-
-    pub fn style(mut self, style: Style) -> SelectableList<'b> {
+    pub fn style(mut self, style: Style) -> List<'a> {
         self.style = style;
         self
     }
 
-    pub fn highlight_symbol(mut self, highlight_symbol: &'b str) -> SelectableList<'b> {
+    pub fn highlight_symbol(mut self, highlight_symbol: &'a str) -> List<'a> {
         self.highlight_symbol = Some(highlight_symbol);
         self
     }
 
-    pub fn highlight_style(mut self, highlight_style: Style) -> SelectableList<'b> {
-        self.highlight_style = highlight_style;
+    pub fn highlight_style(mut self, style: Style) -> List<'a> {
+        self.highlight_style = style;
         self
     }
 
-    pub fn select(mut self, index: Option<usize>) -> SelectableList<'b> {
-        self.selected = index;
+    pub fn start_corner(mut self, corner: Corner) -> List<'a> {
+        self.start_corner = corner;
         self
     }
 }
 
-impl<'b> Widget for SelectableList<'b> {
-    fn draw(&mut self, area: Rect, buf: &mut Buffer) {
-        let list_area = match self.block {
-            Some(ref mut b) => b.inner(area),
+impl<'a> StatefulWidget for List<'a> {
+    type State = ListState;
+
+    fn render(mut self, area: Rect, buf: &mut Buffer, state: &mut Self::State) {
+        buf.set_style(area, self.style);
+        let list_area = match self.block.take() {
+            Some(b) => {
+                let inner_area = b.inner(area);
+                b.render(area, buf);
+                inner_area
+            }
             None => area,
         };
 
+        if list_area.width < 1 || list_area.height < 1 {
+            return;
+        }
+
+        if self.items.is_empty() {
+            return;
+        }
         let list_height = list_area.height as usize;
 
-        // Use highlight_style only if something is selected
-        let (selected, highlight_style) = match self.selected {
-            Some(i) => (Some(i), self.highlight_style),
-            None => (None, self.style),
-        };
+        let mut start = state.offset;
+        let mut end = state.offset;
+        let mut height = 0;
+        for item in self.items.iter().skip(state.offset) {
+            if height + item.height() > list_height {
+                break;
+            }
+            height += item.height();
+            end += 1;
+        }
+
+        let selected = state.selected.unwrap_or(0).min(self.items.len() - 1);
+        while selected >= end {
+            height = height.saturating_add(self.items[end].height());
+            end += 1;
+            while height > list_height {
+                height = height.saturating_sub(self.items[start].height());
+                start += 1;
+            }
+        }
+        while selected < start {
+            start -= 1;
+            height = height.saturating_add(self.items[start].height());
+            while height > list_height {
+                end -= 1;
+                height = height.saturating_sub(self.items[end].height());
+            }
+        }
+        state.offset = start;
+
         let highlight_symbol = self.highlight_symbol.unwrap_or("");
         let blank_symbol = iter::repeat(" ")
             .take(highlight_symbol.width())
             .collect::<String>();
-        // Make sure the list show the selected item
-        let offset = if let Some(selected) = selected {
-            if selected >= list_height {
-                selected - list_height + 1
-            } else {
-                0
-            }
-        } else {
-            0
-        };
 
-        // Render items
-        let items = self
+        let mut current_height = 0;
+        let has_selection = state.selected.is_some();
+        for (i, item) in self
             .items
-            .iter()
+            .iter_mut()
             .enumerate()
-            .map(|(i, &item)| {
-                if let Some(s) = selected {
-                    if i == s {
-                        Text::styled(format!("{} {}", highlight_symbol, item), highlight_style)
-                    } else {
-                        Text::styled(format!("{} {}", blank_symbol, item), self.style)
-                    }
-                } else {
-                    Text::styled(item, self.style)
+            .skip(state.offset)
+            .take(end - start)
+        {
+            let (x, y) = match self.start_corner {
+                Corner::BottomLeft => {
+                    current_height += item.height() as u16;
+                    (list_area.left(), list_area.bottom() - current_height)
                 }
-            })
-            .skip(offset as usize);
-        List::new(items)
-            .block(self.block.unwrap_or_default())
-            .style(self.style)
-            .draw(area, buf);
+                _ => {
+                    let pos = (list_area.left(), list_area.top() + current_height);
+                    current_height += item.height() as u16;
+                    pos
+                }
+            };
+            let area = Rect {
+                x,
+                y,
+                width: list_area.width,
+                height: item.height() as u16,
+            };
+            let item_style = self.style.patch(item.style);
+            buf.set_style(area, item_style);
+
+            let is_selected = state.selected.map(|s| s == i).unwrap_or(false);
+            let elem_x = if has_selection {
+                let symbol = if is_selected {
+                    highlight_symbol
+                } else {
+                    &blank_symbol
+                };
+                let (x, _) = buf.set_stringn(x, y, symbol, list_area.width as usize, item_style);
+                x
+            } else {
+                x
+            };
+            let max_element_width = (list_area.width - (elem_x - x)) as usize;
+            for (j, line) in item.content.lines.iter().enumerate() {
+                buf.set_spans(elem_x, y + j as u16, line, max_element_width as u16);
+            }
+            if is_selected {
+                buf.set_style(area, self.highlight_style);
+            }
+        }
+    }
+}
+
+impl<'a> Widget for List<'a> {
+    fn render(self, area: Rect, buf: &mut Buffer) {
+        let mut state = ListState::default();
+        StatefulWidget::render(self, area, buf, &mut state);
     }
 }

src/widgets/mod.rs

@@ -1,34 +1,49 @@
-use std::borrow::Cow;
+//! `widgets` is a collection of types that implement [`Widget`] or [`StatefulWidget`] or both.
+//!
+//! All widgets are implemented using the builder pattern and are consumable objects. They are not
+//! meant to be stored but used as *commands* to draw common figures in the UI.
+//!
+//! The available widgets are:
+//! - [`Block`]
+//! - [`Tabs`]
+//! - [`List`]
+//! - [`Table`]
+//! - [`Paragraph`]
+//! - [`Chart`]
+//! - [`BarChart`]
+//! - [`Gauge`]
+//! - [`Sparkline`]
+//! - [`Clear`]
 
 mod barchart;
 mod block;
 pub mod canvas;
 mod chart;
+mod clear;
 mod gauge;
 mod list;
 mod paragraph;
+mod reflow;
 mod sparkline;
 mod table;
 mod tabs;
 
 pub use self::barchart::BarChart;
-pub use self::block::Block;
-pub use self::chart::{Axis, Chart, Dataset, Marker};
-pub use self::gauge::Gauge;
-pub use self::list::{List, SelectableList};
-pub use self::paragraph::Paragraph;
+pub use self::block::{Block, BorderType};
+pub use self::chart::{Axis, Chart, Dataset, GraphType};
+pub use self::clear::Clear;
+pub use self::gauge::{Gauge, LineGauge};
+pub use self::list::{List, ListItem, ListState};
+pub use self::paragraph::{Paragraph, Wrap};
 pub use self::sparkline::Sparkline;
-pub use self::table::{Row, Table};
+pub use self::table::{Row, Table, TableState};
 pub use self::tabs::Tabs;
 
-use backend::Backend;
-use buffer::Buffer;
-use layout::Rect;
-use style::{Color, Style};
-use terminal::Frame;
+use crate::{buffer::Buffer, layout::Rect};
+use bitflags::bitflags;
 
-/// Bitflags that can be composed to set the visible borders essentially on the block widget.
 bitflags! {
+    /// Bitflags that can be composed to set the visible borders essentially on the block widget.
     pub struct Borders: u32 {
         /// Show no border (default)
         const NONE  = 0b0000_0001;
@@ -45,40 +60,126 @@ bitflags! {
     }
 }
 
-pub enum Text<'b> {
-    Raw(Cow<'b, str>),
-    Styled(Cow<'b, str>, Style),
-}
-
-impl<'b> Text<'b> {
-    pub fn raw<D: Into<Cow<'b, str>>>(data: D) -> Text<'b> {
-        Text::Raw(data.into())
-    }
-
-    pub fn styled<D: Into<Cow<'b, str>>>(data: D, style: Style) -> Text<'b> {
-        Text::Styled(data.into(), style)
-    }
-}
-
 /// Base requirements for a Widget
 pub trait Widget {
     /// Draws the current state of the widget in the given buffer. That the only method required to
     /// 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) {
-        for y in area.top()..area.bottom() {
-            for x in area.left()..area.right() {
-                buf.get_mut(x, y).set_bg(color);
-            }
-        }
-    }
-    /// Helper method that can be chained with a widget's builder methods to render it.
-    fn render<B>(&mut self, f: &mut Frame<B>, area: Rect)
-    where
-        Self: Sized,
-        B: Backend,
-    {
-        f.render(self, area);
-    }
+    fn render(self, area: Rect, buf: &mut Buffer);
+}
+
+/// A `StatefulWidget` is a widget that can take advantage of some local state to remember things
+/// between two draw calls.
+///
+/// Most widgets can be drawn directly based on the input parameters. However, some features may
+/// require some kind of associated state to be implemented.
+///
+/// For example, the [`List`] widget can highlight the item currently selected. This can be
+/// translated in an offset, which is the number of elements to skip in order to have the selected
+/// item within the viewport currently allocated to this widget. The widget can therefore only
+/// provide the following behavior: whenever the selected item is out of the viewport scroll to a
+/// predefined position (making the selected item the last viewable item or the one in the middle
+/// for example). Nonetheless, if the widget has access to the last computed offset then it can
+/// implement a natural scrolling experience where the last offset is reused until the selected
+/// item is out of the viewport.
+///
+/// ## Examples
+///
+/// ```rust,no_run
+/// # use std::io;
+/// # use tui::Terminal;
+/// # use tui::backend::{Backend, TermionBackend};
+/// # use tui::widgets::{Widget, List, ListItem, ListState};
+///
+/// // Let's say we have some events to display.
+/// struct Events {
+///     // `items` is the state managed by your application.
+///     items: Vec<String>,
+///     // `state` is the state that can be modified by the UI. It stores the index of the selected
+///     // item as well as the offset computed during the previous draw call (used to implement
+///     // natural scrolling).
+///     state: ListState
+/// }
+///
+/// impl Events {
+///     fn new(items: Vec<String>) -> Events {
+///         Events {
+///             items,
+///             state: ListState::default(),
+///         }
+///     }
+///
+///     pub fn set_items(&mut self, items: Vec<String>) {
+///         self.items = items;
+///         // We reset the state as the associated items have changed. This effectively reset
+///         // the selection as well as the stored offset.
+///         self.state = ListState::default();
+///     }
+///
+///     // Select the next item. This will not be reflected until the widget is drawn in the
+///     // `Terminal::draw` callback using `Frame::render_stateful_widget`.
+///     pub fn next(&mut self) {
+///         let i = match self.state.selected() {
+///             Some(i) => {
+///                 if i >= self.items.len() - 1 {
+///                     0
+///                 } else {
+///                     i + 1
+///                 }
+///             }
+///             None => 0,
+///         };
+///         self.state.select(Some(i));
+///     }
+///
+///     // Select the previous item. This will not be reflected until the widget is drawn in the
+///     // `Terminal::draw` callback using `Frame::render_stateful_widget`.
+///     pub fn previous(&mut self) {
+///         let i = match self.state.selected() {
+///             Some(i) => {
+///                 if i == 0 {
+///                     self.items.len() - 1
+///                 } else {
+///                     i - 1
+///                 }
+///             }
+///             None => 0,
+///         };
+///         self.state.select(Some(i));
+///     }
+///
+///     // Unselect the currently selected item if any. The implementation of `ListState` makes
+///     // sure that the stored offset is also reset.
+///     pub fn unselect(&mut self) {
+///         self.state.select(None);
+///     }
+/// }
+///
+/// let stdout = io::stdout();
+/// let backend = TermionBackend::new(stdout);
+/// let mut terminal = Terminal::new(backend).unwrap();
+///
+/// let mut events = Events::new(vec![
+///     String::from("Item 1"),
+///     String::from("Item 2")
+/// ]);
+///
+/// loop {
+///     terminal.draw(|f| {
+///         // The items managed by the application are transformed to something
+///         // that is understood by tui.
+///         let items: Vec<ListItem>= events.items.iter().map(|i| ListItem::new(i.as_ref())).collect();
+///         // The `List` widget is then built with those items.
+///         let list = List::new(items);
+///         // Finally the widget is rendered using the associated state. `events.state` is
+///         // effectively the only thing that we will "remember" from this draw call.
+///         f.render_stateful_widget(list, f.size(), &mut events.state);
+///     });
+///
+///     // In response to some input events or an external http request or whatever:
+///     events.next();
+/// }
+/// ```
+pub trait StatefulWidget {
+    type State;
+    fn render(self, area: Rect, buf: &mut Buffer, state: &mut Self::State);
 }

src/widgets/paragraph.rs

@@ -1,110 +1,145 @@
-use either::Either;
-use itertools::{multipeek, MultiPeek};
-use unicode_segmentation::UnicodeSegmentation;
+use crate::{
+    buffer::Buffer,
+    layout::{Alignment, Rect},
+    style::Style,
+    text::{StyledGrapheme, Text},
+    widgets::{
+        reflow::{LineComposer, LineTruncator, WordWrapper},
+        Block, Widget,
+    },
+};
+use std::iter;
 use unicode_width::UnicodeWidthStr;
 
-use buffer::Buffer;
-use layout::{Alignment, Rect};
-use style::Style;
-use 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::text::{Text, Spans, Span};
+/// # use tui::widgets::{Block, Borders, Paragraph, Wrap};
+/// # use tui::style::{Style, Color, Modifier};
 /// # use tui::layout::{Alignment};
-/// # fn main() {
-/// let text = [
-///     Text::raw("First line\n"),
-///     Text::styled("Second line\n", Style::default().fg(Color::Red))
+/// let text = vec![
+///     Spans::from(vec![
+///         Span::raw("First"),
+///         Span::styled("line",Style::default().add_modifier(Modifier::ITALIC)),
+///         Span::raw("."),
+///     ]),
+///     Spans::from(Span::styled("Second line", Style::default().fg(Color::Red))),
 /// ];
-/// Paragraph::new(text.iter())
+/// Paragraph::new(text)
 ///     .block(Block::default().title("Paragraph").borders(Borders::ALL))
 ///     .style(Style::default().fg(Color::White).bg(Color::Black))
 ///     .alignment(Alignment::Center)
-///     .wrap(true);
-/// # }
+///     .wrap(Wrap { trim: true });
 /// ```
-pub struct Paragraph<'a, 't, T>
-where
-    T: Iterator<Item = &'t Text<'t>>,
-{
+#[derive(Debug, Clone)]
+pub struct Paragraph<'a> {
     /// A block to wrap the widget in
     block: Option<Block<'a>>,
     /// Widget style
     style: Style,
-    /// Wrap the text or not
-    wrapping: bool,
+    /// How to wrap the text
+    wrap: Option<Wrap>,
     /// The text to display
-    text: T,
-    /// Should we parse the text for embedded commands
-    raw: bool,
+    text: Text<'a>,
     /// Scroll
-    scroll: u16,
-    /// Aligenment of the text
+    scroll: (u16, u16),
+    /// Alignment of the text
     alignment: Alignment,
 }
 
-impl<'a, 't, T> Paragraph<'a, 't, T>
-where
-    T: Iterator<Item = &'t Text<'t>>,
-{
-    pub fn new(text: T) -> Paragraph<'a, 't, T> {
+/// Describes how to wrap text across lines.
+///
+/// ## Examples
+///
+/// ```
+/// # use tui::widgets::{Paragraph, Wrap};
+/// # use tui::text::Text;
+/// let bullet_points = Text::from(r#"Some indented points:
+///     - First thing goes here and is long so that it wraps
+///     - Here is another point that is long enough to wrap"#);
+///
+/// // With leading spaces trimmed (window width of 30 chars):
+/// Paragraph::new(bullet_points.clone()).wrap(Wrap { trim: true });
+/// // Some indented points:
+/// // - First thing goes here and is
+/// // long so that it wraps
+/// // - Here is another point that
+/// // is long enough to wrap
+///
+/// // But without trimming, indentation is preserved:
+/// Paragraph::new(bullet_points).wrap(Wrap { trim: false });
+/// // Some indented points:
+/// //     - First thing goes here
+/// // and is long so that it wraps
+/// //     - Here is another point
+/// // that is long enough to wrap
+/// ```
+#[derive(Debug, Clone, Copy)]
+pub struct Wrap {
+    /// Should leading whitespace be trimmed
+    pub trim: bool,
+}
+
+impl<'a> Paragraph<'a> {
+    pub fn new<T>(text: T) -> Paragraph<'a>
+    where
+        T: Into<Text<'a>>,
+    {
         Paragraph {
             block: None,
             style: Default::default(),
-            wrapping: false,
-            raw: false,
-            text,
-            scroll: 0,
+            wrap: None,
+            text: text.into(),
+            scroll: (0, 0),
             alignment: Alignment::Left,
         }
     }
 
-    pub fn block(mut self, block: Block<'a>) -> Paragraph<'a, 't, T> {
+    pub fn block(mut self, block: Block<'a>) -> Paragraph<'a> {
         self.block = Some(block);
         self
     }
 
-    pub fn style(mut self, style: Style) -> Paragraph<'a, 't, T> {
+    pub fn style(mut self, style: Style) -> Paragraph<'a> {
         self.style = style;
         self
     }
 
-    pub fn wrap(mut self, flag: bool) -> Paragraph<'a, 't, T> {
-        self.wrapping = flag;
+    pub fn wrap(mut self, wrap: Wrap) -> Paragraph<'a> {
+        self.wrap = Some(wrap);
         self
     }
 
-    pub fn raw(mut self, flag: bool) -> Paragraph<'a, 't, T> {
-        self.raw = flag;
-        self
-    }
-
-    pub fn scroll(mut self, offset: u16) -> Paragraph<'a, 't, T> {
+    pub fn scroll(mut self, offset: (u16, u16)) -> Paragraph<'a> {
         self.scroll = offset;
         self
     }
 
-    pub fn alignment(mut self, alignment: Alignment) -> Paragraph<'a, 't, T> {
+    pub fn alignment(mut self, alignment: Alignment) -> Paragraph<'a> {
         self.alignment = alignment;
         self
     }
 }
 
-impl<'a, 't, T> Widget for Paragraph<'a, 't, T>
-where
-    T: Iterator<Item = &'t Text<'t>>,
-{
-    fn draw(&mut self, area: Rect, buf: &mut Buffer) {
-        let text_area = match self.block {
-            Some(ref mut b) => {
-                b.draw(area, buf);
-                b.inner(area)
+impl<'a> Widget for Paragraph<'a> {
+    fn render(mut self, area: Rect, buf: &mut Buffer) {
+        buf.set_style(area, self.style);
+        let text_area = match self.block.take() {
+            Some(b) => {
+                let inner_area = b.inner(area);
+                b.render(area, buf);
+                inner_area
             }
             None => area,
         };
@@ -113,91 +148,50 @@ where
             return;
         }
 
-        self.background(&text_area, buf, self.style.bg);
-
         let style = self.style;
-        let 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)))
-            }
-            Text::Styled(ref d, s) => {
-                let data: &'t str = d; // coerce to &str
-                Either::Right(UnicodeSegmentation::graphemes(data, true).map(move |g| (g, s)))
-            }
+        let mut styled = self.text.lines.iter().flat_map(|spans| {
+            spans
+                .0
+                .iter()
+                .flat_map(|span| span.styled_graphemes(style))
+                // Required given the way composers work but might be refactored out if we change
+                // composers to operate on lines instead of a stream of graphemes.
+                .chain(iter::once(StyledGrapheme {
+                    symbol: "\n",
+                    style: self.style,
+                }))
         });
-        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;
+        let mut line_composer: Box<dyn LineComposer> = if let Some(Wrap { trim }) = self.wrap {
+            Box::new(WordWrapper::new(&mut styled, text_area.width, trim))
+        } else {
+            let mut line_composer = Box::new(LineTruncator::new(&mut styled, text_area.width));
+            if let Alignment::Left = self.alignment {
+                line_composer.set_horizontal_offset(self.scroll.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,
+            line_composer
         };
         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.0 {
+                let mut x = get_line_offset(current_line_width, text_area.width, self.alignment);
+                for StyledGrapheme { symbol, style } in current_line {
+                    buf.get_mut(text_area.left() + x, text_area.top() + y - self.scroll.0)
+                        .set_symbol(if symbol.is_empty() {
+                            // If the symbol is empty, the last char which rendered last time will
+                            // leave on the line. It's a quick fix.
+                            " "
+                        } else {
+                            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.0 {
                 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,534 @@
+use crate::text::StyledGrapheme;
+use unicode_segmentation::UnicodeSegmentation;
+use unicode_width::UnicodeWidthStr;
+
+const NBSP: &str = "\u{00a0}";
+
+/// 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<(&[StyledGrapheme<'a>], u16)>;
+}
+
+/// A state machine that wraps lines on word boundaries.
+pub struct WordWrapper<'a, 'b> {
+    symbols: &'b mut dyn Iterator<Item = StyledGrapheme<'a>>,
+    max_line_width: u16,
+    current_line: Vec<StyledGrapheme<'a>>,
+    next_line: Vec<StyledGrapheme<'a>>,
+    /// Removes the leading whitespace from lines
+    trim: bool,
+}
+
+impl<'a, 'b> WordWrapper<'a, 'b> {
+    pub fn new(
+        symbols: &'b mut dyn Iterator<Item = StyledGrapheme<'a>>,
+        max_line_width: u16,
+        trim: bool,
+    ) -> WordWrapper<'a, 'b> {
+        WordWrapper {
+            symbols,
+            max_line_width,
+            current_line: vec![],
+            next_line: vec![],
+            trim,
+        }
+    }
+}
+
+impl<'a, 'b> LineComposer<'a> for WordWrapper<'a, 'b> {
+    fn next_line(&mut self) -> Option<(&[StyledGrapheme<'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(|StyledGrapheme { symbol, .. }| symbol.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 StyledGrapheme { 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 when trim is enabled.
+                || self.trim && 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(StyledGrapheme { 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(|StyledGrapheme { symbol, .. }| {
+                            !symbol.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 dyn Iterator<Item = StyledGrapheme<'a>>,
+    max_line_width: u16,
+    current_line: Vec<StyledGrapheme<'a>>,
+    /// Record the offet to skip render
+    horizontal_offset: u16,
+}
+
+impl<'a, 'b> LineTruncator<'a, 'b> {
+    pub fn new(
+        symbols: &'b mut dyn Iterator<Item = StyledGrapheme<'a>>,
+        max_line_width: u16,
+    ) -> LineTruncator<'a, 'b> {
+        LineTruncator {
+            symbols,
+            max_line_width,
+            horizontal_offset: 0,
+            current_line: vec![],
+        }
+    }
+
+    pub fn set_horizontal_offset(&mut self, horizontal_offset: u16) {
+        self.horizontal_offset = horizontal_offset;
+    }
+}
+
+impl<'a, 'b> LineComposer<'a> for LineTruncator<'a, 'b> {
+    fn next_line(&mut self) -> Option<(&[StyledGrapheme<'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;
+        let mut horizontal_offset = self.horizontal_offset as usize;
+        for StyledGrapheme { 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;
+            }
+
+            let symbol = if horizontal_offset == 0 {
+                symbol
+            } else {
+                let w = symbol.width();
+                if w > horizontal_offset {
+                    let t = trim_offset(symbol, horizontal_offset);
+                    horizontal_offset = 0;
+                    t
+                } else {
+                    horizontal_offset -= w;
+                    ""
+                }
+            };
+            current_line_width += symbol.width() as u16;
+            self.current_line.push(StyledGrapheme { symbol, style });
+        }
+
+        if skip_rest {
+            for StyledGrapheme { 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))
+        }
+    }
+}
+
+/// This function will return a str slice which start at specified offset.
+/// As src is a unicode str, start offset has to be calculated with each character.
+fn trim_offset(src: &str, mut offset: usize) -> &str {
+    let mut start = 0;
+    for c in UnicodeSegmentation::graphemes(src, true) {
+        let w = c.width();
+        if w <= offset {
+            offset -= w;
+            start += c.len();
+        } else {
+            break;
+        }
+    }
+    &src[start..]
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use unicode_segmentation::UnicodeSegmentation;
+
+    enum Composer {
+        WordWrapper { trim: bool },
+        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| StyledGrapheme { symbol: g, style });
+        let mut composer: Box<dyn LineComposer> = match which {
+            Composer::WordWrapper { trim } => {
+                Box::new(WordWrapper::new(&mut styled, text_area_width, trim))
+            }
+            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(|StyledGrapheme { symbol, .. }| *symbol)
+                .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 { trim: true }, &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 { trim: true }, 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 { trim: true }, 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 detect 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 { trim: true }, text, width as u16);
+        let (word_wrapper_multi_space, _) = run_composer(
+            Composer::WordWrapper { trim: true },
+            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 { trim: true }, 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 { trim: true }, 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 { trim: true }, 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 { trim: true }, 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 { trim: true }, &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 { trim: true }, 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 { trim: true }, 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 { trim: true }, 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 { trim: true }, 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 { trim: true }, 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 { trim: true }, &text_space, width);
+        assert_eq!(word_wrapper_space, vec!["AAAAAAAAAAAAAAA AAAA", "AAA",]);
+    }
+
+    #[test]
+    fn line_composer_word_wrapper_preserve_indentation() {
+        let width = 20;
+        let text = "AAAAAAAAAAAAAAAAAAAA    AAA";
+        let (word_wrapper, _) = run_composer(Composer::WordWrapper { trim: false }, text, width);
+        assert_eq!(word_wrapper, vec!["AAAAAAAAAAAAAAAAAAAA", "   AAA",]);
+    }
+
+    #[test]
+    fn line_composer_word_wrapper_preserve_indentation_with_wrap() {
+        let width = 10;
+        let text = "AAA AAA AAAAA AA AAAAAA\n B\n  C\n   D";
+        let (word_wrapper, _) = run_composer(Composer::WordWrapper { trim: false }, text, width);
+        assert_eq!(
+            word_wrapper,
+            vec!["AAA AAA", "AAAAA AA", "AAAAAA", " B", "  C", "   D"]
+        );
+    }
+
+    #[test]
+    fn line_composer_word_wrapper_preserve_indentation_lots_of_whitespace() {
+        let width = 10;
+        let text = "               4 Indent\n                 must wrap!";
+        let (word_wrapper, _) = run_composer(Composer::WordWrapper { trim: false }, text, width);
+        assert_eq!(
+            word_wrapper,
+            vec![
+                "          ",
+                "    4",
+                "Indent",
+                "          ",
+                "      must",
+                "wrap!"
+            ]
+        );
+    }
+}

src/widgets/sparkline.rs

@@ -1,27 +1,26 @@
+use crate::{
+    buffer::Buffer,
+    layout::Rect,
+    style::Style,
+    symbols,
+    widgets::{Block, Widget},
+};
 use std::cmp::min;
 
-use buffer::Buffer;
-use layout::Rect;
-use style::Style;
-use symbols::bar;
-use 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() {
 /// Sparkline::default()
 ///     .block(Block::default().title("Sparkline").borders(Borders::ALL))
 ///     .data(&[0, 2, 3, 4, 1, 4, 10])
 ///     .max(5)
 ///     .style(Style::default().fg(Color::Red).bg(Color::White));
-/// # }
 /// ```
+#[derive(Debug, Clone)]
 pub struct Sparkline<'a> {
     /// A block to wrap the widget in
     block: Option<Block<'a>>,
@@ -32,6 +31,8 @@ pub struct Sparkline<'a> {
     /// The maximum value to take to compute the maximum bar height (if nothing is specified, the
     /// widget uses the max of the dataset)
     max: Option<u64>,
+    /// A set of bar symbols used to represent the give data
+    bar_set: symbols::bar::Set,
 }
 
 impl<'a> Default for Sparkline<'a> {
@@ -41,6 +42,7 @@ impl<'a> Default for Sparkline<'a> {
             style: Default::default(),
             data: &[],
             max: None,
+            bar_set: symbols::bar::NINE_LEVELS,
         }
     }
 }
@@ -65,14 +67,20 @@ impl<'a> Sparkline<'a> {
         self.max = Some(max);
         self
     }
+
+    pub fn bar_set(mut self, bar_set: symbols::bar::Set) -> Sparkline<'a> {
+        self.bar_set = bar_set;
+        self
+    }
 }
 
 impl<'a> Widget for Sparkline<'a> {
-    fn draw(&mut self, area: Rect, buf: &mut Buffer) {
-        let spark_area = match self.block {
-            Some(ref mut b) => {
-                b.draw(area, buf);
-                b.inner(area)
+    fn render(mut self, area: Rect, buf: &mut Buffer) {
+        let spark_area = match self.block.take() {
+            Some(b) => {
+                let inner_area = b.inner(area);
+                b.render(area, buf);
+                inner_area
             }
             None => area,
         };
@@ -90,25 +98,30 @@ 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() {
                 let symbol = match *d {
-                    0 => " ",
-                    1 => bar::ONE_EIGHTH,
-                    2 => bar::ONE_QUATER,
-                    3 => bar::THREE_EIGHTHS,
-                    4 => bar::HALF,
-                    5 => bar::FIVE_EIGHTHS,
-                    6 => bar::THREE_QUATERS,
-                    7 => bar::SEVEN_EIGHTHS,
-                    _ => bar::FULL,
+                    0 => self.bar_set.empty,
+                    1 => self.bar_set.one_eighth,
+                    2 => self.bar_set.one_quarter,
+                    3 => self.bar_set.three_eighths,
+                    4 => self.bar_set.half,
+                    5 => self.bar_set.five_eighths,
+                    6 => self.bar_set.three_quarters,
+                    7 => self.bar_set.seven_eighths,
+                    _ => self.bar_set.full,
                 };
                 buf.get_mut(spark_area.left() + i as u16, spark_area.top() + j)
                     .set_symbol(symbol)
-                    .set_fg(self.style.fg)
-                    .set_bg(self.style.bg);
+                    .set_style(self.style);
 
                 if *d > 8 {
                     *d -= 8;
@@ -119,3 +132,24 @@ impl<'a> Widget for Sparkline<'a> {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn it_does_not_panic_if_max_is_zero() {
+        let widget = Sparkline::default().data(&[0, 0, 0]);
+        let area = Rect::new(0, 0, 3, 1);
+        let mut buffer = Buffer::empty(area);
+        widget.render(area, &mut buffer);
+    }
+
+    #[test]
+    fn it_does_not_panic_if_max_is_set_to_zero() {
+        let widget = Sparkline::default().data(&[0, 1, 2]).max(0);
+        let area = Rect::new(0, 0, 3, 1);
+        let mut buffer = Buffer::empty(area);
+        widget.render(area, &mut buffer);
+    }
+}

src/widgets/table.rs

@@ -1,16 +1,55 @@
-use std::fmt::Display;
-use std::iter::Iterator;
+use crate::{
+    buffer::Buffer,
+    layout::{Constraint, Rect},
+    style::Style,
+    widgets::{Block, StatefulWidget, Widget},
+};
+use cassowary::{
+    strength::{MEDIUM, REQUIRED, WEAK},
+    WeightedRelation::*,
+    {Expression, Solver},
+};
+use std::{
+    collections::HashMap,
+    fmt::Display,
+    iter::{self, Iterator},
+};
+use unicode_width::UnicodeWidthStr;
 
-use buffer::Buffer;
-use layout::Rect;
-use style::Style;
-use widgets::{Block, Widget};
+#[derive(Debug, Clone)]
+pub struct TableState {
+    offset: usize,
+    selected: Option<usize>,
+}
+
+impl Default for TableState {
+    fn default() -> TableState {
+        TableState {
+            offset: 0,
+            selected: None,
+        }
+    }
+}
+
+impl TableState {
+    pub fn selected(&self) -> Option<usize> {
+        self.selected
+    }
+
+    pub fn select(&mut self, index: Option<usize>) {
+        self.selected = index;
+        if index.is_none() {
+            self.offset = 0;
+        }
+    }
+}
 
 /// Holds data to be displayed in a Table widget
-pub enum Row<D, I>
+#[derive(Debug, Clone)]
+pub enum Row<D>
 where
-    D: Iterator<Item = I>,
-    I: Display,
+    D: Iterator,
+    D::Item: Display,
 {
     Data(D),
     StyledData(D, Style),
@@ -22,8 +61,8 @@ where
 ///
 /// ```
 /// # use tui::widgets::{Block, Borders, Table, Row};
+/// # use tui::layout::Constraint;
 /// # use tui::style::{Style, Color};
-/// # fn main() {
 /// let row_style = Style::default().fg(Color::White);
 /// Table::new(
 ///         ["Col1", "Col2", "Col3"].into_iter(),
@@ -36,19 +75,12 @@ where
 ///     )
 ///     .block(Block::default().title("Table"))
 ///     .header_style(Style::default().fg(Color::Yellow))
-///     .widths(&[5, 5, 10])
+///     .widths(&[Constraint::Length(5), Constraint::Length(5), Constraint::Length(10)])
 ///     .style(Style::default().fg(Color::White))
 ///     .column_spacing(1);
-/// # }
 /// ```
-pub struct Table<'a, T, H, I, D, R>
-where
-    T: Display,
-    H: Iterator<Item = T>,
-    I: Display,
-    D: Iterator<Item = I>,
-    R: Iterator<Item = Row<D, I>>,
-{
+#[derive(Debug, Clone)]
+pub struct Table<'a, H, R> {
     /// A block to wrap the widget in
     block: Option<Block<'a>>,
     /// Base style for the widget
@@ -57,155 +89,281 @@ where
     header: H,
     /// Style for the header
     header_style: Style,
-    /// Width of each column (if the total width is greater than the widget width some columns may
-    /// not be displayed)
-    widths: &'a [u16],
+    /// Width constraints for each column
+    widths: &'a [Constraint],
     /// Space between each column
     column_spacing: u16,
+    /// Space between the header and the rows
+    header_gap: u16,
+    /// Style used to render the selected row
+    highlight_style: Style,
+    /// Symbol in front of the selected rom
+    highlight_symbol: Option<&'a str>,
     /// Data to display in each row
     rows: R,
 }
 
-impl<'a, T, H, I, D, R> Default for Table<'a, T, H, I, D, R>
+impl<'a, H, R> Default for Table<'a, H, R>
 where
-    T: Display,
-    H: Iterator<Item = T> + Default,
-    I: Display,
-    D: Iterator<Item = I>,
-    R: Iterator<Item = Row<D, I>> + Default,
+    H: Iterator + Default,
+    R: Iterator + Default,
 {
-    fn default() -> Table<'a, T, H, I, D, R> {
+    fn default() -> Table<'a, H, R> {
         Table {
             block: None,
             style: Style::default(),
             header: H::default(),
             header_style: Style::default(),
             widths: &[],
-            rows: R::default(),
             column_spacing: 1,
+            header_gap: 1,
+            highlight_style: Style::default(),
+            highlight_symbol: None,
+            rows: R::default(),
         }
     }
 }
-
-impl<'a, T, H, I, D, R> Table<'a, T, H, I, D, R>
+impl<'a, H, D, R> Table<'a, H, R>
 where
-    T: Display,
-    H: Iterator<Item = T>,
-    I: Display,
-    D: Iterator<Item = I>,
-    R: Iterator<Item = Row<D, I>>,
+    H: Iterator,
+    D: Iterator,
+    D::Item: Display,
+    R: Iterator<Item = Row<D>>,
 {
-    pub fn new(header: H, rows: R) -> Table<'a, T, H, I, D, R> {
+    pub fn new(header: H, rows: R) -> Table<'a, H, R> {
         Table {
             block: None,
             style: Style::default(),
             header,
             header_style: Style::default(),
             widths: &[],
-            rows,
             column_spacing: 1,
+            header_gap: 1,
+            highlight_style: Style::default(),
+            highlight_symbol: None,
+            rows,
         }
     }
-    pub fn block(mut self, block: Block<'a>) -> Table<'a, T, H, I, D, R> {
+    pub fn block(mut self, block: Block<'a>) -> Table<'a, H, R> {
         self.block = Some(block);
         self
     }
 
-    pub fn header<II>(mut self, header: II) -> Table<'a, T, H, I, D, R>
+    pub fn header<II>(mut self, header: II) -> Table<'a, H, R>
     where
-        II: IntoIterator<Item = T, IntoIter = H>,
+        II: IntoIterator<Item = H::Item, IntoIter = H>,
     {
         self.header = header.into_iter();
         self
     }
 
-    pub fn header_style(mut self, style: Style) -> Table<'a, T, H, I, D, R> {
+    pub fn header_style(mut self, style: Style) -> Table<'a, H, R> {
         self.header_style = style;
         self
     }
 
-    pub fn widths(mut self, widths: &'a [u16]) -> Table<'a, T, H, I, D, R> {
+    pub fn widths(mut self, widths: &'a [Constraint]) -> Table<'a, H, R> {
+        let between_0_and_100 = |&w| match w {
+            Constraint::Percentage(p) => p <= 100,
+            _ => true,
+        };
+        assert!(
+            widths.iter().all(between_0_and_100),
+            "Percentages should be between 0 and 100 inclusively."
+        );
         self.widths = widths;
         self
     }
 
-    pub fn rows<II>(mut self, rows: II) -> Table<'a, T, H, I, D, R>
+    pub fn rows<II>(mut self, rows: II) -> Table<'a, H, R>
     where
-        II: IntoIterator<Item = Row<D, I>, IntoIter = R>,
+        II: IntoIterator<Item = Row<D>, IntoIter = R>,
     {
         self.rows = rows.into_iter();
         self
     }
 
-    pub fn style(mut self, style: Style) -> Table<'a, T, H, I, D, R> {
+    pub fn style(mut self, style: Style) -> Table<'a, H, R> {
         self.style = style;
         self
     }
 
-    pub fn column_spacing(mut self, spacing: u16) -> Table<'a, T, H, I, D, R> {
+    pub fn highlight_symbol(mut self, highlight_symbol: &'a str) -> Table<'a, H, R> {
+        self.highlight_symbol = Some(highlight_symbol);
+        self
+    }
+
+    pub fn highlight_style(mut self, highlight_style: Style) -> Table<'a, H, R> {
+        self.highlight_style = highlight_style;
+        self
+    }
+
+    pub fn column_spacing(mut self, spacing: u16) -> Table<'a, H, R> {
         self.column_spacing = spacing;
         self
     }
+
+    pub fn header_gap(mut self, gap: u16) -> Table<'a, H, R> {
+        self.header_gap = gap;
+        self
+    }
 }
 
-impl<'a, T, H, I, D, R> Widget for Table<'a, T, H, I, D, R>
+impl<'a, H, D, R> StatefulWidget for Table<'a, H, R>
 where
-    T: Display,
-    H: Iterator<Item = T>,
-    I: Display,
-    D: Iterator<Item = I>,
-    R: Iterator<Item = Row<D, I>>,
+    H: Iterator,
+    H::Item: Display,
+    D: Iterator,
+    D::Item: Display,
+    R: Iterator<Item = Row<D>>,
 {
-    fn draw(&mut self, area: Rect, buf: &mut Buffer) {
+    type State = TableState;
+
+    fn render(mut self, area: Rect, buf: &mut Buffer, state: &mut Self::State) {
+        buf.set_style(area, self.style);
+
         // Render block if necessary and get the drawing area
-        let table_area = match self.block {
-            Some(ref mut b) => {
-                b.draw(area, buf);
-                b.inner(area)
+        let table_area = match self.block.take() {
+            Some(b) => {
+                let inner_area = b.inner(area);
+                b.render(area, buf);
+                inner_area
             }
             None => area,
         };
 
-        // Set the background
-        self.background(&table_area, buf, self.style.bg);
-
-        // Save widths of the columns that will fit in the given area
-        let mut x = 0;
-        let mut widths = Vec::with_capacity(self.widths.len());
-        for width in self.widths.iter() {
-            if x + width < table_area.width {
-                widths.push(*width);
-            }
-            x += *width;
+        let mut solver = Solver::new();
+        let mut var_indices = HashMap::new();
+        let mut ccs = Vec::new();
+        let mut variables = Vec::new();
+        for i in 0..self.widths.len() {
+            let var = cassowary::Variable::new();
+            variables.push(var);
+            var_indices.insert(var, i);
+        }
+        for (i, constraint) in self.widths.iter().enumerate() {
+            ccs.push(variables[i] | GE(WEAK) | 0.);
+            ccs.push(match *constraint {
+                Constraint::Length(v) => variables[i] | EQ(MEDIUM) | f64::from(v),
+                Constraint::Percentage(v) => {
+                    variables[i] | EQ(WEAK) | (f64::from(v * area.width) / 100.0)
+                }
+                Constraint::Ratio(n, d) => {
+                    variables[i] | EQ(WEAK) | (f64::from(area.width) * f64::from(n) / f64::from(d))
+                }
+                Constraint::Min(v) => variables[i] | GE(WEAK) | f64::from(v),
+                Constraint::Max(v) => variables[i] | LE(WEAK) | f64::from(v),
+            })
+        }
+        solver
+            .add_constraint(
+                variables
+                    .iter()
+                    .fold(Expression::from_constant(0.), |acc, v| acc + *v)
+                    | LE(REQUIRED)
+                    | f64::from(
+                        area.width - 2 - (self.column_spacing * (variables.len() as u16 - 1)),
+                    ),
+            )
+            .unwrap();
+        solver.add_constraints(&ccs).unwrap();
+        let mut solved_widths = vec![0; variables.len()];
+        for &(var, value) in solver.fetch_changes() {
+            let index = var_indices[&var];
+            let value = if value.is_sign_negative() {
+                0
+            } else {
+                value as u16
+            };
+            solved_widths[index] = value
         }
 
         let mut y = table_area.top();
+        let mut x = table_area.left();
 
         // Draw header
         if y < table_area.bottom() {
-            x = table_area.left();
-            for (w, t) in widths.iter().zip(self.header.by_ref()) {
-                buf.set_string(x, y, format!("{}", t), self.header_style);
+            for (w, t) in solved_widths.iter().zip(self.header.by_ref()) {
+                buf.set_stringn(x, y, format!("{}", t), *w as usize, self.header_style);
                 x += *w + self.column_spacing;
             }
         }
-        y += 2;
+        y += 1 + self.header_gap;
+
+        // Use highlight_style only if something is selected
+        let (selected, highlight_style) = match state.selected {
+            Some(i) => (Some(i), self.highlight_style),
+            None => (None, self.style),
+        };
+        let highlight_symbol = self.highlight_symbol.unwrap_or("");
+        let blank_symbol = iter::repeat(" ")
+            .take(highlight_symbol.width())
+            .collect::<String>();
 
         // Draw rows
         let default_style = Style::default();
         if y < table_area.bottom() {
             let remaining = (table_area.bottom() - y) as usize;
-            for (i, row) in self.rows.by_ref().take(remaining).enumerate() {
-                let (data, style) = match row {
-                    Row::Data(d) => (d, default_style),
-                    Row::StyledData(d, s) => (d, s),
+
+            // Make sure the table shows the selected item
+            state.offset = if let Some(selected) = selected {
+                if selected >= remaining + state.offset - 1 {
+                    selected + 1 - remaining
+                } else if selected < state.offset {
+                    selected
+                } else {
+                    state.offset
+                }
+            } else {
+                0
+            };
+            for (i, row) in self.rows.skip(state.offset).take(remaining).enumerate() {
+                let (data, style, symbol) = match row {
+                    Row::Data(d) | Row::StyledData(d, _)
+                        if Some(i) == state.selected.map(|s| s - state.offset) =>
+                    {
+                        (d, highlight_style, highlight_symbol)
+                    }
+                    Row::Data(d) => (d, default_style, blank_symbol.as_ref()),
+                    Row::StyledData(d, s) => (d, s, blank_symbol.as_ref()),
                 };
                 x = table_area.left();
-                for (w, elt) in widths.iter().zip(data) {
-                    buf.set_stringn(x, y + i as u16, format!("{}", elt), *w as usize, style);
+                for (c, (w, elt)) in solved_widths.iter().zip(data).enumerate() {
+                    let s = if c == 0 {
+                        format!("{}{}", symbol, elt)
+                    } else {
+                        format!("{}", elt)
+                    };
+                    buf.set_stringn(x, y + i as u16, s, *w as usize, style);
                     x += *w + self.column_spacing;
                 }
             }
         }
     }
 }
+
+impl<'a, H, D, R> Widget for Table<'a, H, R>
+where
+    H: Iterator,
+    H::Item: Display,
+    D: Iterator,
+    D::Item: Display,
+    R: Iterator<Item = Row<D>>,
+{
+    fn render(self, area: Rect, buf: &mut Buffer) {
+        let mut state = TableState::default();
+        StatefulWidget::render(self, area, buf, &mut state);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    #[should_panic]
+    fn table_invalid_percentages() {
+        Table::new([""].iter(), vec![Row::Data([""].iter())].into_iter())
+            .widths(&[Constraint::Percentage(110)]);
+    }
+}

src/widgets/tabs.rs

@@ -1,97 +1,93 @@
-use unicode_width::UnicodeWidthStr;
-
-use buffer::Buffer;
-use layout::Rect;
-use style::Style;
-use symbols::line;
-use widgets::{Block, Widget};
+use crate::{
+    buffer::Buffer,
+    layout::Rect,
+    style::Style,
+    symbols,
+    text::{Span, Spans},
+    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};
-/// # fn main() {
-/// Tabs::default()
+/// # use tui::text::{Spans};
+/// # use tui::symbols::{DOT};
+/// let titles = ["Tab1", "Tab2", "Tab3", "Tab4"].iter().cloned().map(Spans::from).collect();
+/// Tabs::new(titles)
 ///     .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>
-where
-    T: AsRef<str> + 'a,
-{
+#[derive(Debug, Clone)]
+pub struct Tabs<'a> {
     /// A block to wrap this widget in if necessary
     block: Option<Block<'a>>,
     /// One title for each tab
-    titles: &'a [T],
+    titles: Vec<Spans<'a>>,
     /// The index of the selected tabs
     selected: usize,
     /// The style used to draw the text
     style: Style,
-    /// The style used to display the selected item
+    /// Style to apply to the selected item
     highlight_style: Style,
+    /// Tab divider
+    divider: Span<'a>,
 }
 
-impl<'a, T> Default for Tabs<'a, T>
-where
-    T: AsRef<str>,
-{
-    fn default() -> Tabs<'a, T> {
+impl<'a> Tabs<'a> {
+    pub fn new(titles: Vec<Spans<'a>>) -> Tabs<'a> {
         Tabs {
             block: None,
-            titles: &[],
+            titles,
             selected: 0,
             style: Default::default(),
             highlight_style: Default::default(),
+            divider: Span::raw(symbols::line::VERTICAL),
         }
     }
-}
 
-impl<'a, T> Tabs<'a, T>
-where
-    T: AsRef<str>,
-{
-    pub fn block(mut self, block: Block<'a>) -> Tabs<'a, T> {
+    pub fn block(mut self, block: Block<'a>) -> Tabs<'a> {
         self.block = Some(block);
         self
     }
 
-    pub fn titles(mut self, titles: &'a [T]) -> Tabs<'a, T> {
-        self.titles = titles;
-        self
-    }
-
-    pub fn select(mut self, selected: usize) -> Tabs<'a, T> {
+    pub fn select(mut self, selected: usize) -> Tabs<'a> {
         self.selected = selected;
         self
     }
 
-    pub fn style(mut self, style: Style) -> Tabs<'a, T> {
+    pub fn style(mut self, style: Style) -> Tabs<'a> {
         self.style = style;
         self
     }
 
-    pub fn highlight_style(mut self, style: Style) -> Tabs<'a, T> {
+    pub fn highlight_style(mut self, style: Style) -> Tabs<'a> {
         self.highlight_style = style;
         self
     }
+
+    pub fn divider<T>(mut self, divider: T) -> Tabs<'a>
+    where
+        T: Into<Span<'a>>,
+    {
+        self.divider = divider.into();
+        self
+    }
 }
 
-impl<'a, T> Widget for Tabs<'a, T>
-where
-    T: AsRef<str>,
-{
-    fn draw(&mut self, area: Rect, buf: &mut Buffer) {
-        let tabs_area = match self.block {
-            Some(ref mut b) => {
-                b.draw(area, buf);
-                b.inner(area)
+impl<'a> Widget for Tabs<'a> {
+    fn render(mut self, area: Rect, buf: &mut Buffer) {
+        buf.set_style(area, self.style);
+        let tabs_area = match self.block.take() {
+            Some(b) => {
+                let inner_area = b.inner(area);
+                b.render(area, buf);
+                inner_area
             }
             None => area,
         };
@@ -100,32 +96,34 @@ where
             return;
         }
 
-        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)| {
-            if i == self.selected {
-                (t, self.highlight_style)
-            } else {
-                (t, self.style)
-            }
-        }) {
-            x += 1;
-            if x > tabs_area.right() {
+        let titles_length = self.titles.len();
+        for (i, title) in self.titles.into_iter().enumerate() {
+            let last_title = titles_length - 1 == i;
+            x = x.saturating_add(1);
+            let remaining_width = tabs_area.right().saturating_sub(x);
+            if remaining_width == 0 {
                 break;
-            } 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() {
-                    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;
-                }
             }
+            let pos = buf.set_spans(x, tabs_area.top(), &title, remaining_width);
+            if i == self.selected {
+                buf.set_style(
+                    Rect {
+                        x,
+                        y: tabs_area.top(),
+                        width: pos.0.saturating_sub(x),
+                        height: 1,
+                    },
+                    self.highlight_style,
+                );
+            }
+            x = pos.0.saturating_add(1);
+            let remaining_width = tabs_area.right().saturating_sub(x);
+            if remaining_width == 0 || last_title {
+                break;
+            }
+            let pos = buf.set_span(x, tabs_area.top(), &self.divider, remaining_width);
+            x = pos.0;
         }
     }
 }

tests/backend_termion.rs

@@ -0,0 +1,63 @@
+#[cfg(feature = "termion")]
+#[test]
+fn backend_termion_should_only_write_diffs() -> Result<(), Box<dyn std::error::Error>> {
+    use std::{fmt::Write, io::Cursor};
+
+    let mut bytes = Vec::new();
+    let mut stdout = Cursor::new(&mut bytes);
+    {
+        use tui::{
+            backend::TermionBackend, layout::Rect, widgets::Paragraph, Terminal, TerminalOptions,
+            Viewport,
+        };
+        let backend = TermionBackend::new(&mut stdout);
+        let area = Rect::new(0, 0, 3, 1);
+        let mut terminal = Terminal::with_options(
+            backend,
+            TerminalOptions {
+                viewport: Viewport::fixed(area),
+            },
+        )?;
+        terminal.draw(|f| {
+            f.render_widget(Paragraph::new("a"), area);
+        })?;
+        terminal.draw(|f| {
+            f.render_widget(Paragraph::new("ab"), area);
+        })?;
+        terminal.draw(|f| {
+            f.render_widget(Paragraph::new("abc"), area);
+        })?;
+    }
+
+    let expected = {
+        use termion::{color, cursor, style};
+        let mut s = String::new();
+        // First draw
+        write!(s, "{}", cursor::Goto(1, 1))?;
+        s.push_str("a");
+        write!(s, "{}", color::Fg(color::Reset))?;
+        write!(s, "{}", color::Bg(color::Reset))?;
+        write!(s, "{}", style::Reset)?;
+        write!(s, "{}", cursor::Hide)?;
+        // Second draw
+        write!(s, "{}", cursor::Goto(2, 1))?;
+        s.push_str("b");
+        write!(s, "{}", color::Fg(color::Reset))?;
+        write!(s, "{}", color::Bg(color::Reset))?;
+        write!(s, "{}", style::Reset)?;
+        write!(s, "{}", cursor::Hide)?;
+        // Third draw
+        write!(s, "{}", cursor::Goto(3, 1))?;
+        s.push_str("c");
+        write!(s, "{}", color::Fg(color::Reset))?;
+        write!(s, "{}", color::Bg(color::Reset))?;
+        write!(s, "{}", style::Reset)?;
+        write!(s, "{}", cursor::Hide)?;
+        // Terminal drop
+        write!(s, "{}", cursor::Show)?;
+        s
+    };
+    assert_eq!(std::str::from_utf8(&bytes)?, expected);
+
+    Ok(())
+}

tests/terminal.rs

@@ -0,0 +1,13 @@
+use tui::{
+    backend::{Backend, TestBackend},
+    Terminal,
+};
+
+#[test]
+fn terminal_buffer_size_should_be_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);
+}

tests/widgets_barchart.rs

@@ -0,0 +1,40 @@
+use tui::backend::TestBackend;
+use tui::buffer::Buffer;
+use tui::widgets::{BarChart, Block, Borders};
+use tui::Terminal;
+
+#[test]
+fn widgets_barchart_not_full_below_max_value() {
+    let test_case = |expected| {
+        let backend = TestBackend::new(30, 10);
+        let mut terminal = Terminal::new(backend).unwrap();
+
+        terminal
+            .draw(|f| {
+                let size = f.size();
+                let barchart = BarChart::default()
+                    .block(Block::default().borders(Borders::ALL))
+                    .data(&[("empty", 0), ("half", 50), ("almost", 99), ("full", 100)])
+                    .max(100)
+                    .bar_width(7)
+                    .bar_gap(0);
+                f.render_widget(barchart, size);
+            })
+            .unwrap();
+        terminal.backend().assert_buffer(&expected);
+    };
+
+    // check that bars fill up correctly up to max value
+    test_case(Buffer::with_lines(vec![
+        "┌────────────────────────────┐",
+        "│              ▇▇▇▇▇▇▇███████│",
+        "│              ██████████████│",
+        "│              ██████████████│",
+        "│       ▄▄▄▄▄▄▄██████████████│",
+        "│       █████████████████████│",
+        "│       █████████████████████│",
+        "│       ██50█████99█████100██│",
+        "│empty  half   almost full   │",
+        "└────────────────────────────┘",
+    ]));
+}

tests/widgets_block.rs

@@ -0,0 +1,47 @@
+use tui::{
+    backend::TestBackend,
+    buffer::Buffer,
+    layout::Rect,
+    style::{Color, Style},
+    text::Span,
+    widgets::{Block, Borders},
+    Terminal,
+};
+
+#[test]
+fn widgets_block_renders() {
+    let backend = TestBackend::new(10, 10);
+    let mut terminal = Terminal::new(backend).unwrap();
+    terminal
+        .draw(|f| {
+            let block = Block::default()
+                .title(Span::styled("Title", Style::default().fg(Color::LightBlue)))
+                .borders(Borders::ALL);
+            f.render_widget(
+                block,
+                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);
+    }
+    terminal.backend().assert_buffer(&expected);
+}

tests/widgets_chart.rs

@@ -0,0 +1,379 @@
+use tui::{
+    backend::TestBackend,
+    buffer::Buffer,
+    layout::Rect,
+    style::{Color, Style},
+    symbols,
+    text::Span,
+    widgets::{Axis, Block, Borders, Chart, Dataset, GraphType::Line},
+    Terminal,
+};
+
+fn create_labels<'a>(labels: &'a [&'a str]) -> Vec<Span<'a>> {
+    labels.iter().map(|l| Span::from(*l)).collect()
+}
+
+#[test]
+fn widgets_chart_can_have_axis_with_zero_length_bounds() {
+    let backend = TestBackend::new(100, 100);
+    let mut terminal = Terminal::new(backend).unwrap();
+
+    terminal
+        .draw(|f| {
+            let datasets = vec![Dataset::default()
+                .marker(symbols::Marker::Braille)
+                .style(Style::default().fg(Color::Magenta))
+                .data(&[(0.0, 0.0)])];
+            let chart = Chart::new(datasets)
+                .block(Block::default().title("Plot").borders(Borders::ALL))
+                .x_axis(
+                    Axis::default()
+                        .bounds([0.0, 0.0])
+                        .labels(create_labels(&["0.0", "1.0"])),
+                )
+                .y_axis(
+                    Axis::default()
+                        .bounds([0.0, 0.0])
+                        .labels(create_labels(&["0.0", "1.0"])),
+                );
+            f.render_widget(
+                chart,
+                Rect {
+                    x: 0,
+                    y: 0,
+                    width: 100,
+                    height: 100,
+                },
+            );
+        })
+        .unwrap();
+}
+
+#[test]
+fn widgets_chart_handles_overflows() {
+    let backend = TestBackend::new(80, 30);
+    let mut terminal = Terminal::new(backend).unwrap();
+
+    terminal
+        .draw(|f| {
+            let datasets = vec![Dataset::default()
+                .marker(symbols::Marker::Braille)
+                .style(Style::default().fg(Color::Magenta))
+                .data(&[
+                    (1_588_298_471.0, 1.0),
+                    (1_588_298_473.0, 0.0),
+                    (1_588_298_496.0, 1.0),
+                ])];
+            let chart = Chart::new(datasets)
+                .block(Block::default().title("Plot").borders(Borders::ALL))
+                .x_axis(
+                    Axis::default()
+                        .bounds([1_588_298_471.0, 1_588_992_600.0])
+                        .labels(create_labels(&["1588298471.0", "1588992600.0"])),
+                )
+                .y_axis(
+                    Axis::default()
+                        .bounds([0.0, 1.0])
+                        .labels(create_labels(&["0.0", "1.0"])),
+                );
+            f.render_widget(
+                chart,
+                Rect {
+                    x: 0,
+                    y: 0,
+                    width: 80,
+                    height: 30,
+                },
+            );
+        })
+        .unwrap();
+}
+
+#[test]
+fn widgets_chart_can_have_empty_datasets() {
+    let backend = TestBackend::new(100, 100);
+    let mut terminal = Terminal::new(backend).unwrap();
+
+    terminal
+        .draw(|f| {
+            let datasets = vec![Dataset::default().data(&[]).graph_type(Line)];
+            let chart = Chart::new(datasets)
+                .block(
+                    Block::default()
+                        .title("Empty Dataset With Line")
+                        .borders(Borders::ALL),
+                )
+                .x_axis(
+                    Axis::default()
+                        .bounds([0.0, 0.0])
+                        .labels(create_labels(&["0.0", "1.0"])),
+                )
+                .y_axis(
+                    Axis::default()
+                        .bounds([0.0, 1.0])
+                        .labels(create_labels(&["0.0", "1.0"])),
+                );
+            f.render_widget(
+                chart,
+                Rect {
+                    x: 0,
+                    y: 0,
+                    width: 100,
+                    height: 100,
+                },
+            );
+        })
+        .unwrap();
+}
+
+#[test]
+fn widgets_chart_can_have_a_legend() {
+    let backend = TestBackend::new(60, 30);
+    let mut terminal = Terminal::new(backend).unwrap();
+    terminal
+        .draw(|f| {
+            let datasets = vec![
+                Dataset::default()
+                    .name("Dataset 1")
+                    .style(Style::default().fg(Color::Blue))
+                    .data(&[
+                        (0.0, 0.0),
+                        (10.0, 1.0),
+                        (20.0, 2.0),
+                        (30.0, 3.0),
+                        (40.0, 4.0),
+                        (50.0, 5.0),
+                        (60.0, 6.0),
+                        (70.0, 7.0),
+                        (80.0, 8.0),
+                        (90.0, 9.0),
+                        (100.0, 10.0),
+                    ])
+                    .graph_type(Line),
+                Dataset::default()
+                    .name("Dataset 2")
+                    .style(Style::default().fg(Color::Green))
+                    .data(&[
+                        (0.0, 10.0),
+                        (10.0, 9.0),
+                        (20.0, 8.0),
+                        (30.0, 7.0),
+                        (40.0, 6.0),
+                        (50.0, 5.0),
+                        (60.0, 4.0),
+                        (70.0, 3.0),
+                        (80.0, 2.0),
+                        (90.0, 1.0),
+                        (100.0, 0.0),
+                    ])
+                    .graph_type(Line),
+            ];
+            let chart = Chart::new(datasets)
+                .style(Style::default().bg(Color::White))
+                .block(Block::default().title("Chart Test").borders(Borders::ALL))
+                .x_axis(
+                    Axis::default()
+                        .bounds([0.0, 100.0])
+                        .title(Span::styled("X Axis", Style::default().fg(Color::Yellow)))
+                        .labels(create_labels(&["0.0", "50.0", "100.0"])),
+                )
+                .y_axis(
+                    Axis::default()
+                        .bounds([0.0, 10.0])
+                        .title("Y Axis")
+                        .labels(create_labels(&["0.0", "5.0", "10.0"])),
+                );
+            f.render_widget(
+                chart,
+                Rect {
+                    x: 0,
+                    y: 0,
+                    width: 60,
+                    height: 30,
+                },
+            );
+        })
+        .unwrap();
+    let mut expected = Buffer::with_lines(vec![
+        "┌Chart Test────────────────────────────────────────────────┐",
+        "│10.0│Y Axis                                    ┌─────────┐│",
+        "│    │  ••                                      │Dataset 1││",
+        "│    │    ••                                    │Dataset 2││",
+        "│    │      ••                                  └─────────┘│",
+        "│    │        ••                                ••         │",
+        "│    │          ••                            ••           │",
+        "│    │            ••                        ••             │",
+        "│    │              ••                    ••               │",
+        "│    │                ••                ••                 │",
+        "│    │                  ••            ••                   │",
+        "│    │                    ••        ••                     │",
+        "│    │                      •••   ••                       │",
+        "│    │                         •••                         │",
+        "│5.0 │                        •• ••                        │",
+        "│    │                      ••     ••                      │",
+        "│    │                   •••         ••                    │",
+        "│    │                 ••              ••                  │",
+        "│    │               ••                  ••                │",
+        "│    │             ••                      ••              │",
+        "│    │           ••                          ••            │",
+        "│    │         ••                              ••          │",
+        "│    │       ••                                  ••        │",
+        "│    │     ••                                      •••     │",
+        "│    │   ••                                           ••   │",
+        "│    │ ••                                               •• │",
+        "│0.0 │•                                              X Axis│",
+        "│    └─────────────────────────────────────────────────────│",
+        "│  0.0                      50.0                     100.0 │",
+        "└──────────────────────────────────────────────────────────┘",
+    ]);
+
+    // Set expected backgound color
+    for row in 0..30 {
+        for col in 0..60 {
+            expected.get_mut(col, row).set_bg(Color::White);
+        }
+    }
+
+    // Set expected colors of the first dataset
+    let line1 = vec![
+        (48, 5),
+        (49, 5),
+        (46, 6),
+        (47, 6),
+        (44, 7),
+        (45, 7),
+        (42, 8),
+        (43, 8),
+        (40, 9),
+        (41, 9),
+        (38, 10),
+        (39, 10),
+        (36, 11),
+        (37, 11),
+        (34, 12),
+        (35, 12),
+        (33, 13),
+        (30, 14),
+        (31, 14),
+        (28, 15),
+        (29, 15),
+        (25, 16),
+        (26, 16),
+        (27, 16),
+        (23, 17),
+        (24, 17),
+        (21, 18),
+        (22, 18),
+        (19, 19),
+        (20, 19),
+        (17, 20),
+        (18, 20),
+        (15, 21),
+        (16, 21),
+        (13, 22),
+        (14, 22),
+        (11, 23),
+        (12, 23),
+        (9, 24),
+        (10, 24),
+        (7, 25),
+        (8, 25),
+        (6, 26),
+    ];
+    let legend1 = vec![
+        (49, 2),
+        (50, 2),
+        (51, 2),
+        (52, 2),
+        (53, 2),
+        (54, 2),
+        (55, 2),
+        (56, 2),
+        (57, 2),
+    ];
+    for (col, row) in line1 {
+        expected.get_mut(col, row).set_fg(Color::Blue);
+    }
+    for (col, row) in legend1 {
+        expected.get_mut(col, row).set_fg(Color::Blue);
+    }
+
+    // Set expected colors of the second dataset
+    let line2 = vec![
+        (8, 2),
+        (9, 2),
+        (10, 3),
+        (11, 3),
+        (12, 4),
+        (13, 4),
+        (14, 5),
+        (15, 5),
+        (16, 6),
+        (17, 6),
+        (18, 7),
+        (19, 7),
+        (20, 8),
+        (21, 8),
+        (22, 9),
+        (23, 9),
+        (24, 10),
+        (25, 10),
+        (26, 11),
+        (27, 11),
+        (28, 12),
+        (29, 12),
+        (30, 12),
+        (31, 13),
+        (32, 13),
+        (33, 14),
+        (34, 14),
+        (35, 15),
+        (36, 15),
+        (37, 16),
+        (38, 16),
+        (39, 17),
+        (40, 17),
+        (41, 18),
+        (42, 18),
+        (43, 19),
+        (44, 19),
+        (45, 20),
+        (46, 20),
+        (47, 21),
+        (48, 21),
+        (49, 22),
+        (50, 22),
+        (51, 23),
+        (52, 23),
+        (53, 23),
+        (54, 24),
+        (55, 24),
+        (56, 25),
+        (57, 25),
+    ];
+    let legend2 = vec![
+        (49, 3),
+        (50, 3),
+        (51, 3),
+        (52, 3),
+        (53, 3),
+        (54, 3),
+        (55, 3),
+        (56, 3),
+        (57, 3),
+    ];
+    for (col, row) in line2 {
+        expected.get_mut(col, row).set_fg(Color::Green);
+    }
+    for (col, row) in legend2 {
+        expected.get_mut(col, row).set_fg(Color::Green);
+    }
+
+    // Set expected colors of the x axis
+    let x_axis_title = vec![(53, 26), (54, 26), (55, 26), (56, 26), (57, 26), (58, 26)];
+    for (col, row) in x_axis_title {
+        expected.get_mut(col, row).set_fg(Color::Yellow);
+    }
+
+    terminal.backend().assert_buffer(&expected);
+}

tests/widgets_gauge.rs

@@ -0,0 +1,98 @@
+use tui::{
+    backend::TestBackend,
+    buffer::Buffer,
+    layout::{Constraint, Direction, Layout, Rect},
+    style::{Color, Style},
+    symbols,
+    widgets::{Block, Borders, Gauge, LineGauge},
+    Terminal,
+};
+
+#[test]
+fn widgets_gauge_renders() {
+    let backend = TestBackend::new(40, 10);
+    let mut terminal = Terminal::new(backend).unwrap();
+    terminal
+        .draw(|f| {
+            let chunks = Layout::default()
+                .direction(Direction::Vertical)
+                .margin(2)
+                .constraints([Constraint::Percentage(50), Constraint::Percentage(50)].as_ref())
+                .split(f.size());
+
+            let gauge = Gauge::default()
+                .block(Block::default().title("Percentage").borders(Borders::ALL))
+                .percent(43);
+            f.render_widget(gauge, chunks[0]);
+            let gauge = Gauge::default()
+                .block(Block::default().title("Ratio").borders(Borders::ALL))
+                .ratio(0.211_313_934_313_1);
+            f.render_widget(gauge, chunks[1]);
+        })
+        .unwrap();
+    let expected = Buffer::with_lines(vec![
+        "                                        ",
+        "                                        ",
+        "  ┌Percentage────────────────────────┐  ",
+        "  │               43%                │  ",
+        "  └──────────────────────────────────┘  ",
+        "  ┌Ratio─────────────────────────────┐  ",
+        "  │               21%                │  ",
+        "  └──────────────────────────────────┘  ",
+        "                                        ",
+        "                                        ",
+    ]);
+    terminal.backend().assert_buffer(&expected);
+}
+
+#[test]
+fn widgets_line_gauge_renders() {
+    let backend = TestBackend::new(20, 4);
+    let mut terminal = Terminal::new(backend).unwrap();
+    terminal
+        .draw(|f| {
+            let gauge = LineGauge::default()
+                .gauge_style(Style::default().fg(Color::Green).bg(Color::White))
+                .ratio(0.43);
+            f.render_widget(
+                gauge,
+                Rect {
+                    x: 0,
+                    y: 0,
+                    width: 20,
+                    height: 1,
+                },
+            );
+            let gauge = LineGauge::default()
+                .block(Block::default().title("Gauge 2").borders(Borders::ALL))
+                .gauge_style(Style::default().fg(Color::Green))
+                .line_set(symbols::line::THICK)
+                .ratio(0.211_313_934_313_1);
+            f.render_widget(
+                gauge,
+                Rect {
+                    x: 0,
+                    y: 1,
+                    width: 20,
+                    height: 3,
+                },
+            );
+        })
+        .unwrap();
+    let mut expected = Buffer::with_lines(vec![
+        "43% ────────────────",
+        "┌Gauge 2───────────┐",
+        "│21% ━━━━━━━━━━━━━━│",
+        "└──────────────────┘",
+    ]);
+    for col in 4..10 {
+        expected.get_mut(col, 0).set_fg(Color::Green);
+    }
+    for col in 10..20 {
+        expected.get_mut(col, 0).set_fg(Color::White);
+    }
+    for col in 5..7 {
+        expected.get_mut(col, 2).set_fg(Color::Green);
+    }
+    terminal.backend().assert_buffer(&expected);
+}

tests/widgets_list.rs

@@ -0,0 +1,88 @@
+use tui::{
+    backend::TestBackend,
+    buffer::Buffer,
+    layout::Rect,
+    style::{Color, Style},
+    symbols,
+    widgets::{Block, Borders, List, ListItem, ListState},
+    Terminal,
+};
+
+#[test]
+fn widgets_list_should_highlight_the_selected_item() {
+    let backend = TestBackend::new(10, 3);
+    let mut terminal = Terminal::new(backend).unwrap();
+    let mut state = ListState::default();
+    state.select(Some(1));
+    terminal
+        .draw(|f| {
+            let size = f.size();
+            let items = vec![
+                ListItem::new("Item 1"),
+                ListItem::new("Item 2"),
+                ListItem::new("Item 3"),
+            ];
+            let list = List::new(items)
+                .highlight_style(Style::default().bg(Color::Yellow))
+                .highlight_symbol(">> ");
+            f.render_stateful_widget(list, size, &mut state);
+        })
+        .unwrap();
+    let mut expected = Buffer::with_lines(vec!["   Item 1 ", ">> Item 2 ", "   Item 3 "]);
+    for x in 0..10 {
+        expected.get_mut(x, 1).set_bg(Color::Yellow);
+    }
+    terminal.backend().assert_buffer(&expected);
+}
+
+#[test]
+fn widgets_list_should_truncate_items() {
+    let backend = TestBackend::new(10, 2);
+    let mut terminal = Terminal::new(backend).unwrap();
+
+    struct TruncateTestCase<'a> {
+        selected: Option<usize>,
+        items: Vec<ListItem<'a>>,
+        expected: Buffer,
+    }
+
+    let cases = vec![
+        // An item is selected
+        TruncateTestCase {
+            selected: Some(0),
+            items: vec![
+                ListItem::new("A very long line"),
+                ListItem::new("A very long line"),
+            ],
+            expected: Buffer::with_lines(vec![
+                format!(">> A ve{}  ", symbols::line::VERTICAL),
+                format!("   A ve{}  ", symbols::line::VERTICAL),
+            ]),
+        },
+        // No item is selected
+        TruncateTestCase {
+            selected: None,
+            items: vec![
+                ListItem::new("A very long line"),
+                ListItem::new("A very long line"),
+            ],
+            expected: Buffer::with_lines(vec![
+                format!("A very {}  ", symbols::line::VERTICAL),
+                format!("A very {}  ", symbols::line::VERTICAL),
+            ]),
+        },
+    ];
+    for case in cases {
+        let mut state = ListState::default();
+        state.select(case.selected);
+        terminal
+            .draw(|f| {
+                let list = List::new(case.items.clone())
+                    .block(Block::default().borders(Borders::RIGHT))
+                    .highlight_symbol(">> ");
+                f.render_stateful_widget(list, Rect::new(0, 0, 8, 2), &mut state);
+            })
+            .unwrap();
+        terminal.backend().assert_buffer(&case.expected);
+    }
+}

tests/widgets_paragraph.rs

@@ -0,0 +1,199 @@
+use tui::{
+    backend::TestBackend,
+    buffer::Buffer,
+    layout::Alignment,
+    text::{Spans, Text},
+    widgets::{Block, Borders, Paragraph, Wrap},
+    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 widgets_paragraph_can_wrap_its_content() {
+    let test_case = |alignment, expected| {
+        let backend = TestBackend::new(20, 10);
+        let mut terminal = Terminal::new(backend).unwrap();
+
+        terminal
+            .draw(|f| {
+                let size = f.size();
+                let text = vec![Spans::from(SAMPLE_STRING)];
+                let paragraph = Paragraph::new(text)
+                    .block(Block::default().borders(Borders::ALL))
+                    .alignment(alignment)
+                    .wrap(Wrap { trim: true });
+                f.render_widget(paragraph, size);
+            })
+            .unwrap();
+        terminal.backend().assert_buffer(&expected);
+    };
+
+    test_case(
+        Alignment::Left,
+        Buffer::with_lines(vec![
+            "┌──────────────────┐",
+            "│The library is    │",
+            "│based on the      │",
+            "│principle of      │",
+            "│immediate         │",
+            "│rendering with    │",
+            "│intermediate      │",
+            "│buffers. This     │",
+            "│means that at each│",
+            "└──────────────────┘",
+        ]),
+    );
+    test_case(
+        Alignment::Right,
+        Buffer::with_lines(vec![
+            "┌──────────────────┐",
+            "│    The library is│",
+            "│      based on the│",
+            "│      principle of│",
+            "│         immediate│",
+            "│    rendering with│",
+            "│      intermediate│",
+            "│     buffers. This│",
+            "│means that at each│",
+            "└──────────────────┘",
+        ]),
+    );
+    test_case(
+        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 widgets_paragraph_renders_double_width_graphemes() {
+    let backend = TestBackend::new(10, 10);
+    let mut terminal = Terminal::new(backend).unwrap();
+
+    let s = "コンピュータ上で文字を扱う場合、典型的には文字による通信を行う場合にその両端点では、";
+    terminal
+        .draw(|f| {
+            let size = f.size();
+            let text = vec![Spans::from(s)];
+            let paragraph = Paragraph::new(text)
+                .block(Block::default().borders(Borders::ALL))
+                .wrap(Wrap { trim: true });
+            f.render_widget(paragraph, size);
+        })
+        .unwrap();
+
+    let expected = Buffer::with_lines(vec![
+        "┌────────┐",
+        "│コンピュ│",
+        "│ータ上で│",
+        "│文字を扱│",
+        "│う場合、│",
+        "│典型的に│",
+        "│は文字に│",
+        "│よる通信│",
+        "│を行う場│",
+        "└────────┘",
+    ]);
+    terminal.backend().assert_buffer(&expected);
+}
+
+#[test]
+fn widgets_paragraph_renders_mixed_width_graphemes() {
+    let backend = TestBackend::new(10, 7);
+    let mut terminal = Terminal::new(backend).unwrap();
+
+    let s = "aコンピュータ上で文字を扱う場合、";
+    terminal
+        .draw(|f| {
+            let size = f.size();
+            let text = vec![Spans::from(s)];
+            let paragraph = Paragraph::new(text)
+                .block(Block::default().borders(Borders::ALL))
+                .wrap(Wrap { trim: true });
+            f.render_widget(paragraph, 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.
+        "│ュータ上│",
+        "│で文字を│",
+        "│扱う場合│",
+        "│、      │",
+        "└────────┘",
+    ]);
+    terminal.backend().assert_buffer(&expected);
+}
+
+#[test]
+fn widgets_paragraph_can_scroll_horizontally() {
+    let test_case = |alignment, scroll, expected| {
+        let backend = TestBackend::new(20, 10);
+        let mut terminal = Terminal::new(backend).unwrap();
+
+        terminal
+            .draw(|f| {
+                let size = f.size();
+                let text = Text::from(
+                    "段落现在可以水平滚动了！\nParagraph can scroll horizontally!\nShort line",
+                );
+                let paragraph = Paragraph::new(text)
+                    .block(Block::default().borders(Borders::ALL))
+                    .alignment(alignment)
+                    .scroll(scroll);
+                f.render_widget(paragraph, size);
+            })
+            .unwrap();
+        terminal.backend().assert_buffer(&expected);
+    };
+
+    test_case(
+        Alignment::Left,
+        (0, 7),
+        Buffer::with_lines(vec![
+            "┌──────────────────┐",
+            "│在可以水平滚动了！│",
+            "│ph can scroll hori│",
+            "│ine               │",
+            "│                  │",
+            "│                  │",
+            "│                  │",
+            "│                  │",
+            "│                  │",
+            "└──────────────────┘",
+        ]),
+    );
+    // only support Alignment::Left
+    test_case(
+        Alignment::Right,
+        (0, 7),
+        Buffer::with_lines(vec![
+            "┌──────────────────┐",
+            "│段落现在可以水平滚│",
+            "│Paragraph can scro│",
+            "│        Short line│",
+            "│                  │",
+            "│                  │",
+            "│                  │",
+            "│                  │",
+            "│                  │",
+            "└──────────────────┘",
+        ]),
+    );
+}

tests/widgets_table.rs

@@ -0,0 +1,418 @@
+use tui::backend::TestBackend;
+use tui::buffer::Buffer;
+use tui::layout::Constraint;
+use tui::widgets::{Block, Borders, Row, Table};
+use tui::Terminal;
+
+#[test]
+fn widgets_table_column_spacing_can_be_changed() {
+    let test_case = |column_spacing, expected| {
+        let backend = TestBackend::new(30, 10);
+        let mut terminal = Terminal::new(backend).unwrap();
+
+        terminal
+            .draw(|f| {
+                let size = f.size();
+                let table = Table::new(
+                    ["Head1", "Head2", "Head3"].iter(),
+                    vec![
+                        Row::Data(["Row11", "Row12", "Row13"].iter()),
+                        Row::Data(["Row21", "Row22", "Row23"].iter()),
+                        Row::Data(["Row31", "Row32", "Row33"].iter()),
+                        Row::Data(["Row41", "Row42", "Row43"].iter()),
+                    ]
+                    .into_iter(),
+                )
+                .block(Block::default().borders(Borders::ALL))
+                .widths(&[
+                    Constraint::Length(5),
+                    Constraint::Length(5),
+                    Constraint::Length(5),
+                ])
+                .column_spacing(column_spacing);
+                f.render_widget(table, size);
+            })
+            .unwrap();
+        terminal.backend().assert_buffer(&expected);
+    };
+
+    // no space between columns
+    test_case(
+        0,
+        Buffer::with_lines(vec![
+            "┌────────────────────────────┐",
+            "│Head1Head2Head3             │",
+            "│                            │",
+            "│Row11Row12Row13             │",
+            "│Row21Row22Row23             │",
+            "│Row31Row32Row33             │",
+            "│Row41Row42Row43             │",
+            "│                            │",
+            "│                            │",
+            "└────────────────────────────┘",
+        ]),
+    );
+
+    // one space between columns
+    test_case(
+        1,
+        Buffer::with_lines(vec![
+            "┌────────────────────────────┐",
+            "│Head1 Head2 Head3           │",
+            "│                            │",
+            "│Row11 Row12 Row13           │",
+            "│Row21 Row22 Row23           │",
+            "│Row31 Row32 Row33           │",
+            "│Row41 Row42 Row43           │",
+            "│                            │",
+            "│                            │",
+            "└────────────────────────────┘",
+        ]),
+    );
+
+    // enough space to just not hide the third column
+    test_case(
+        6,
+        Buffer::with_lines(vec![
+            "┌────────────────────────────┐",
+            "│Head1      Head2      Head3 │",
+            "│                            │",
+            "│Row11      Row12      Row13 │",
+            "│Row21      Row22      Row23 │",
+            "│Row31      Row32      Row33 │",
+            "│Row41      Row42      Row43 │",
+            "│                            │",
+            "│                            │",
+            "└────────────────────────────┘",
+        ]),
+    );
+
+    // enough space to hide part of the third column
+    test_case(
+        7,
+        Buffer::with_lines(vec![
+            "┌────────────────────────────┐",
+            "│Head1       Head2       Head│",
+            "│                            │",
+            "│Row11       Row12       Row1│",
+            "│Row21       Row22       Row2│",
+            "│Row31       Row32       Row3│",
+            "│Row41       Row42       Row4│",
+            "│                            │",
+            "│                            │",
+            "└────────────────────────────┘",
+        ]),
+    );
+}
+
+#[test]
+fn widgets_table_columns_widths_can_use_fixed_length_constraints() {
+    let test_case = |widths, expected| {
+        let backend = TestBackend::new(30, 10);
+        let mut terminal = Terminal::new(backend).unwrap();
+
+        terminal
+            .draw(|f| {
+                let size = f.size();
+                let table = Table::new(
+                    ["Head1", "Head2", "Head3"].iter(),
+                    vec![
+                        Row::Data(["Row11", "Row12", "Row13"].iter()),
+                        Row::Data(["Row21", "Row22", "Row23"].iter()),
+                        Row::Data(["Row31", "Row32", "Row33"].iter()),
+                        Row::Data(["Row41", "Row42", "Row43"].iter()),
+                    ]
+                    .into_iter(),
+                )
+                .block(Block::default().borders(Borders::ALL))
+                .widths(widths);
+                f.render_widget(table, size);
+            })
+            .unwrap();
+        terminal.backend().assert_buffer(&expected);
+    };
+
+    // columns of zero width show nothing
+    test_case(
+        &[
+            Constraint::Length(0),
+            Constraint::Length(0),
+            Constraint::Length(0),
+        ],
+        Buffer::with_lines(vec![
+            "┌────────────────────────────┐",
+            "│                            │",
+            "│                            │",
+            "│                            │",
+            "│                            │",
+            "│                            │",
+            "│                            │",
+            "│                            │",
+            "│                            │",
+            "└────────────────────────────┘",
+        ]),
+    );
+
+    // columns of 1 width trim
+    test_case(
+        &[
+            Constraint::Length(1),
+            Constraint::Length(1),
+            Constraint::Length(1),
+        ],
+        Buffer::with_lines(vec![
+            "┌────────────────────────────┐",
+            "│H H H                       │",
+            "│                            │",
+            "│R R R                       │",
+            "│R R R                       │",
+            "│R R R                       │",
+            "│R R R                       │",
+            "│                            │",
+            "│                            │",
+            "└────────────────────────────┘",
+        ]),
+    );
+
+    // columns of large width just before pushing a column off
+    test_case(
+        &[
+            Constraint::Length(8),
+            Constraint::Length(8),
+            Constraint::Length(8),
+        ],
+        Buffer::with_lines(vec![
+            "┌────────────────────────────┐",
+            "│Head1    Head2    Head3     │",
+            "│                            │",
+            "│Row11    Row12    Row13     │",
+            "│Row21    Row22    Row23     │",
+            "│Row31    Row32    Row33     │",
+            "│Row41    Row42    Row43     │",
+            "│                            │",
+            "│                            │",
+            "└────────────────────────────┘",
+        ]),
+    );
+}
+
+#[test]
+fn widgets_table_columns_widths_can_use_percentage_constraints() {
+    let test_case = |widths, expected| {
+        let backend = TestBackend::new(30, 10);
+        let mut terminal = Terminal::new(backend).unwrap();
+
+        terminal
+            .draw(|f| {
+                let size = f.size();
+                let table = Table::new(
+                    ["Head1", "Head2", "Head3"].iter(),
+                    vec![
+                        Row::Data(["Row11", "Row12", "Row13"].iter()),
+                        Row::Data(["Row21", "Row22", "Row23"].iter()),
+                        Row::Data(["Row31", "Row32", "Row33"].iter()),
+                        Row::Data(["Row41", "Row42", "Row43"].iter()),
+                    ]
+                    .into_iter(),
+                )
+                .block(Block::default().borders(Borders::ALL))
+                .widths(widths)
+                .column_spacing(0);
+                f.render_widget(table, size);
+            })
+            .unwrap();
+        terminal.backend().assert_buffer(&expected);
+    };
+
+    // columns of zero width show nothing
+    test_case(
+        &[
+            Constraint::Percentage(0),
+            Constraint::Percentage(0),
+            Constraint::Percentage(0),
+        ],
+        Buffer::with_lines(vec![
+            "┌────────────────────────────┐",
+            "│                            │",
+            "│                            │",
+            "│                            │",
+            "│                            │",
+            "│                            │",
+            "│                            │",
+            "│                            │",
+            "│                            │",
+            "└────────────────────────────┘",
+        ]),
+    );
+
+    // columns of not enough width trims the data
+    test_case(
+        &[
+            Constraint::Percentage(10),
+            Constraint::Percentage(10),
+            Constraint::Percentage(10),
+        ],
+        Buffer::with_lines(vec![
+            "┌────────────────────────────┐",
+            "│HeaHeaHea                   │",
+            "│                            │",
+            "│RowRowRow                   │",
+            "│RowRowRow                   │",
+            "│RowRowRow                   │",
+            "│RowRowRow                   │",
+            "│                            │",
+            "│                            │",
+            "└────────────────────────────┘",
+        ]),
+    );
+
+    // columns of large width just before pushing a column off
+    test_case(
+        &[
+            Constraint::Percentage(30),
+            Constraint::Percentage(30),
+            Constraint::Percentage(30),
+        ],
+        Buffer::with_lines(vec![
+            "┌────────────────────────────┐",
+            "│Head1    Head2    Head3     │",
+            "│                            │",
+            "│Row11    Row12    Row13     │",
+            "│Row21    Row22    Row23     │",
+            "│Row31    Row32    Row33     │",
+            "│Row41    Row42    Row43     │",
+            "│                            │",
+            "│                            │",
+            "└────────────────────────────┘",
+        ]),
+    );
+
+    // percentages summing to 100 should give equal widths
+    test_case(
+        &[Constraint::Percentage(50), Constraint::Percentage(50)],
+        Buffer::with_lines(vec![
+            "┌────────────────────────────┐",
+            "│Head1          Head2        │",
+            "│                            │",
+            "│Row11          Row12        │",
+            "│Row21          Row22        │",
+            "│Row31          Row32        │",
+            "│Row41          Row42        │",
+            "│                            │",
+            "│                            │",
+            "└────────────────────────────┘",
+        ]),
+    );
+}
+
+#[test]
+fn widgets_table_columns_widths_can_use_mixed_constraints() {
+    let test_case = |widths, expected| {
+        let backend = TestBackend::new(30, 10);
+        let mut terminal = Terminal::new(backend).unwrap();
+
+        terminal
+            .draw(|f| {
+                let size = f.size();
+                let table = Table::new(
+                    ["Head1", "Head2", "Head3"].iter(),
+                    vec![
+                        Row::Data(["Row11", "Row12", "Row13"].iter()),
+                        Row::Data(["Row21", "Row22", "Row23"].iter()),
+                        Row::Data(["Row31", "Row32", "Row33"].iter()),
+                        Row::Data(["Row41", "Row42", "Row43"].iter()),
+                    ]
+                    .into_iter(),
+                )
+                .block(Block::default().borders(Borders::ALL))
+                .widths(widths);
+                f.render_widget(table, size);
+            })
+            .unwrap();
+        terminal.backend().assert_buffer(&expected);
+    };
+
+    // columns of zero width show nothing
+    test_case(
+        &[
+            Constraint::Percentage(0),
+            Constraint::Length(0),
+            Constraint::Percentage(0),
+        ],
+        Buffer::with_lines(vec![
+            "┌────────────────────────────┐",
+            "│                            │",
+            "│                            │",
+            "│                            │",
+            "│                            │",
+            "│                            │",
+            "│                            │",
+            "│                            │",
+            "│                            │",
+            "└────────────────────────────┘",
+        ]),
+    );
+
+    // columns of not enough width trims the data
+    test_case(
+        &[
+            Constraint::Percentage(10),
+            Constraint::Length(20),
+            Constraint::Percentage(10),
+        ],
+        Buffer::with_lines(vec![
+            "┌────────────────────────────┐",
+            "│Hea Head2                Hea│",
+            "│                            │",
+            "│Row Row12                Row│",
+            "│Row Row22                Row│",
+            "│Row Row32                Row│",
+            "│Row Row42                Row│",
+            "│                            │",
+            "│                            │",
+            "└────────────────────────────┘",
+        ]),
+    );
+
+    // columns of large width just before pushing a column off
+    test_case(
+        &[
+            Constraint::Percentage(30),
+            Constraint::Length(10),
+            Constraint::Percentage(30),
+        ],
+        Buffer::with_lines(vec![
+            "┌────────────────────────────┐",
+            "│Head1     Head2      Head3  │",
+            "│                            │",
+            "│Row11     Row12      Row13  │",
+            "│Row21     Row22      Row23  │",
+            "│Row31     Row32      Row33  │",
+            "│Row41     Row42      Row43  │",
+            "│                            │",
+            "│                            │",
+            "└────────────────────────────┘",
+        ]),
+    );
+
+    // columns of large size (>100% total) hide the last column
+    test_case(
+        &[
+            Constraint::Percentage(60),
+            Constraint::Length(10),
+            Constraint::Percentage(60),
+        ],
+        Buffer::with_lines(vec![
+            "┌────────────────────────────┐",
+            "│Head1            Head2      │",
+            "│                            │",
+            "│Row11            Row12      │",
+            "│Row21            Row22      │",
+            "│Row31            Row32      │",
+            "│Row41            Row42      │",
+            "│                            │",
+            "│                            │",
+            "└────────────────────────────┘",
+        ]),
+    );
+}

tests/widgets_tabs.rs

@@ -0,0 +1,48 @@
+use tui::{
+    backend::TestBackend, buffer::Buffer, layout::Rect, symbols, text::Spans, widgets::Tabs,
+    Terminal,
+};
+
+#[test]
+fn widgets_tabs_should_not_panic_on_narrow_areas() {
+    let backend = TestBackend::new(1, 1);
+    let mut terminal = Terminal::new(backend).unwrap();
+    terminal
+        .draw(|f| {
+            let tabs = Tabs::new(["Tab1", "Tab2"].iter().cloned().map(Spans::from).collect());
+            f.render_widget(
+                tabs,
+                Rect {
+                    x: 0,
+                    y: 0,
+                    width: 1,
+                    height: 1,
+                },
+            );
+        })
+        .unwrap();
+    let expected = Buffer::with_lines(vec![" "]);
+    terminal.backend().assert_buffer(&expected);
+}
+
+#[test]
+fn widgets_tabs_should_truncate_the_last_item() {
+    let backend = TestBackend::new(10, 1);
+    let mut terminal = Terminal::new(backend).unwrap();
+    terminal
+        .draw(|f| {
+            let tabs = Tabs::new(["Tab1", "Tab2"].iter().cloned().map(Spans::from).collect());
+            f.render_widget(
+                tabs,
+                Rect {
+                    x: 0,
+                    y: 0,
+                    width: 9,
+                    height: 1,
+                },
+            );
+        })
+        .unwrap();
+    let expected = Buffer::with_lines(vec![format!(" Tab1 {} T ", symbols::line::VERTICAL)]);
+    terminal.backend().assert_buffer(&expected);
+}