Give the crate::widgets::reflow module public visibility

Signed-off-by: Luc Perkins <luc@timber.io>

.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,85 @@
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master
+
+name: CI
+
+env:
+  CI_CARGO_MAKE_VERSION: 0.32.9
+
+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: hecrj/setup-rust-action@967aec96c6a27a0ce15c1dac3aaba332d60565e2
+        with:
+          rust-version: ${{ matrix.rust }}
+          components: rustfmt,clippy
+      - uses: actions/checkout@v1
+      - name: "Get cargo bin directory"
+        id: cargo-bin-dir
+        run: echo "::set-output name=dir::$HOME/.cargo/bin"
+      - name: "Cache cargo make"
+        id: cache-cargo-make
+        uses: actions/cache@v2
+        with:
+          path: ${{ steps.cargo-bin-dir.outputs.dir }}/cargo-make
+          key: ${{ runner.os }}-${{ matrix.rust }}-cargo-make-${{ env.CI_CARGO_MAKE_VERSION }}
+      - name: "Install cargo-make"
+        if: steps.cache-cargo-make.outputs.cache-hit != 'true'
+        run: cargo install cargo-make --version ${{ env.CI_CARGO_MAKE_VERSION }}
+      - name: "Format"
+        run: cargo make fmt
+      - name: "Check"
+        run: cargo make check
+      - name: "Test"
+        run: cargo make test
+        env:
+          RUST_BACKTRACE: full
+      - name: "Clippy"
+        run: cargo make clippy
+  windows:
+    name: Windows
+    runs-on: windows-latest
+    strategy:
+      matrix:
+        rust: ["1.44.0", "stable"]
+    steps:
+      - uses: actions/checkout@v1
+      - uses: hecrj/setup-rust-action@967aec96c6a27a0ce15c1dac3aaba332d60565e2
+        with:
+          rust-version: ${{ matrix.rust }}
+          components: rustfmt,clippy
+      - uses: actions/checkout@v1
+      - name: "Get cargo bin directory"
+        id: cargo-bin-dir
+        run: echo "::set-output name=dir::$HOME\.cargo\bin"
+      - name: "Cache cargo make"
+        id: cache-cargo-make
+        uses: actions/cache@v2
+        with:
+          path: ${{ steps.cargo-bin-dir.outputs.dir }}\cargo-make.exe
+          key: ${{ runner.os }}-${{ matrix.rust }}-cargo-make-${{ env.CI_CARGO_MAKE_VERSION }}
+      - name: "Install cargo-make"
+        if: steps.cache-cargo-make.outputs.cache-hit != 'true'
+        run: cargo install cargo-make --version ${{ env.CI_CARGO_MAKE_VERSION }}
+      - name: "Format"
+        run: cargo make fmt
+      - name: "Check"
+        run: cargo make check
+      - name: "Test"
+        run: cargo make test
+        env:
+          RUST_BACKTRACE: full
+      - name: "Clippy"
+        run: cargo make clippy

.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,15 +2,497 @@
 
 ## To be released
 
-## v0.5.1 - 2019-04-14
+## v0.14.0 - 2021-01-01
 
-### Fixed
+### Breaking changes
+
+#### New API for the Table widget
+
+The `Table` widget got a lot of improvements that should make it easier to work with:
+* It should not longer panic when rendered on small areas.
+* `Row`s are now a collection of `Cell`s, themselves wrapping a `Text`. This means you can style
+the entire `Table`, an entire `Row`, an entire `Cell` and rely on the styling capabilities of
+`Text` to get full control over the look of your `Table`.
+* `Row`s can have multiple lines.
+* The header is now optional and is just another `Row` always visible at the top.
+* `Row`s can have a bottom margin.
+* The header alignment is no longer off when an item is selected.
+
+Taking the example of the code in `examples/demo/ui.rs`, this is what you may have to change:
+```diff
+     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)
++        Row::new(vec![s.name, s.location, s.status]).style(style)
+     });
+-    let table = Table::new(header.iter(), rows)
++    let table = Table::new(rows)
++        .header(
++            Row::new(vec!["Server", "Location", "Status"])
++                .style(Style::default().fg(Color::Yellow))
++                .bottom_margin(1),
++        )
+         .block(Block::default().title("Servers").borders(Borders::ALL))
+-        .header_style(Style::default().fg(Color::Yellow))
+         .widths(&[
+             Constraint::Length(15),
+             Constraint::Length(15),
+```
+Here, we had to:
+- Change the way we construct [`Row`](https://docs.rs/tui/*/tui/widgets/struct.Row.html) which is no
+longer an `enum` but a `struct`. It accepts anything that can be converted to an iterator of things
+that can be converted to a [`Cell`](https://docs.rs/tui/*/tui/widgets/struct.Cell.html)
+- The header is no longer a required parameter so we use
+[`Table::header`](https://docs.rs/tui/*/tui/widgets/struct.Table.html#method.header) to set it.
+`Table::header_style` has been removed since the style can be directly set using
+[`Row::style`](https://docs.rs/tui/*/tui/widgets/struct.Row.html#method.style). In addition, we want
+to preserve the old margin between the header and the rest of the rows so we add a bottom margin to
+the header using
+[`Row::bottom_margin`](https://docs.rs/tui/*/tui/widgets/struct.Row.html#method.bottom_margin).
+
+You may want to look at the documentation of the different types to get a better understanding:
+- [`Table`](https://docs.rs/tui/*/tui/widgets/struct.Table.html)
+- [`Row`](https://docs.rs/tui/*/tui/widgets/struct.Row.html)
+- [`Cell`](https://docs.rs/tui/*/tui/widgets/struct.Cell.html)
+
+### Fixes
+
+- Fix handling of Non Breaking Space (NBSP) in wrapped text in `Paragraph` widget.
+
+### Features
+
+- Add `Style::reset` to create a `Style` resetting all styling properties when applied.
+- Add an option to render the `Gauge` widget with unicode blocks.
+- Manage common project tasks with `cargo-make` rather than `make` for easier on-boarding.
+
+## v0.13.0 - 2020-11-14
+
+### Features
+
+* Add `LineGauge` widget which is a more compact variant of the existing `Gauge`.
+* Bump `crossterm` to 0.18
+
+### Fixes
+
+* Take into account the borders of the `Table` widget when the widths of columns is controlled by
+`Percentage` and `Ratio` constraints.
+
+## v0.12.0 - 2020-09-27
+
+### 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
 
-### Added
+### Features
 
 * Add a new curses backend (with Windows support thanks to `pancurses`).
 * Add `Backend::get_cursor` and `Backend::set_cursor` methods to query and
@@ -20,7 +502,7 @@ set the position of the cursor.
 * Add `Ratio` as a new variant of layout `Constraint`. It can be used to define
 exact ratios constraints.
 
-### Changed
+### Breaking Changes
 
 * Add support for multiple modifiers on the same `Style` by changing `Modifier`
 from an enum to a bitflags struct.
@@ -28,25 +510,25 @@ from an enum to a bitflags struct.
 So instead of writing:
 
 ```rust
-let style = Style::default().modifier(Modifier::Italic);
+let style = Style::default().add_modifier(Modifier::Italic);
 ```
 
 one should use:
 
 ```rust
-let style = Style::default().modifier(Modifier::ITALIC);
+let style = Style::default().add_modifier(Modifier::ITALIC);
 // or
-let style = Style::default().modifier(Modifier::ITALIC | Modifier::BOLD);
+let style = Style::default().add_modifier(Modifier::ITALIC | Modifier::BOLD);
 ```
 
-### Fixed
+### 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
 
-### Added
+### Features
 
 * Add a new canvas shape: `Rectangle`.
 * Official support of `Crossterm` backend.
@@ -55,11 +537,11 @@ let style = Style::default().modifier(Modifier::ITALIC | Modifier::BOLD);
 * The gauge widget accepts a ratio (f64 between 0 and 1) in addition of a
 percentage.
 
-### Changed
+### Breaking Changes
 
 * Upgrade to Rust 2018 edition.
 
-### Fixed
+### Bug Fixes
 
 * Fix rendering of double-width characters.
 * Fix race condition on the size of the terminal and expose a size that is
@@ -68,19 +550,19 @@ safe to use when drawing through `Frame::size`.
 
 ## v0.3.0 - 2018-11-04
 
-### Added
+### Features
 
 * Add experimental test backend
 
 ## v0.3.0-beta.3 - 2018-09-24
 
-### Changed
+### Features
 
 * `show_cursor` is called when `Terminal` is dropped if the cursor is hidden.
 
 ## v0.3.0-beta.2 - 2018-09-23
 
-### Changed
+### Breaking Changes
 
 * Remove custom `termion` backends. This is motivated by the fact that
 `termion` structs are meant to be combined/wrapped to provide additional
@@ -106,7 +588,7 @@ additional `termion` features.
 
 ## v0.3.0-beta.1 - 2018-09-08
 
-### Changed
+### Breaking Changes
 
 * Replace `Item` by a generic and flexible `Text` that can be used in both
 `Paragraph` and `List` widgets.
@@ -114,11 +596,11 @@ additional `termion` features.
 
 ## 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
@@ -138,24 +620,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
@@ -163,7 +645,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`
@@ -172,21 +654,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`

CONTRIBUTING.md

@@ -0,0 +1,26 @@
+# Contributing
+
+[cargo-make]: https://github.com/sagiegurari/cargo-make "cargo-make"
+
+`tui` is an ordinary Rust project where common tasks are managed with [cargo-make]. It wraps common
+`cargo` commands with sane defaults depending on your platform of choice. Bulding the project should
+be as easy as running `cargo make`.
+
+## Continous Integration
+
+We use Github Actions for the CI where we perform the following checks:
+- The code should compile on `stable` and the Minimum Supported Rust Version (MSRV).
+- The tests (docs, lib, tests and examples) should pass.
+- The code should conform to the default format enforced by `rustfmt`.
+- The code should not contain common style issues `clippy`.
+
+You can also check most of those things yourself locally using `cargo make ci` which will offer you
+a shorter feedback loop.
+
+## Tests
+
+The test coverage of the crate is far from being ideal but we already have a fair amount of tests in
+place. Beside the usal doc and unit tests, one of the most valuable test you can write for `tui` is
+a test again the `TestBackend` which allows you to assert the content of the output buffer that
+would have been flushed to the termminal after a given draw call (see `widgets_block_renders` in
+[tests/widgets_block.rs](./tests/widget_block.rs) for an example).

Cargo.toml

@@ -1,20 +1,20 @@
 [package]
 name = "tui"
-version = "0.5.1"
+version = "0.14.0"
 authors = ["Florian Dehau <work@fdehau.com>"]
 description = """
 A library to build rich terminal user interfaces or dashboards
 """
+documentation = "https://docs.rs/tui/0.14.0/tui/"
 keywords = ["tui", "terminal", "dashboard"]
 repository = "https://github.com/fdehau/tui-rs"
+readme = "README.md"
 license = "MIT"
-exclude = ["assets/*", ".travis.yml"]
+exclude = ["assets/*", ".github", "Makefile.toml", "CONTRIBUTING.md", "*.log", "tags"]
 autoexamples = true
 edition = "2018"
 
 [badges]
-travis-ci = { repository = "fdehau/tui-rs" }
-appveyor = { repository = "fdehau/tui-rs" }
 
 [features]
 default = ["termion"]
@@ -23,22 +23,88 @@ curses = ["easycurses", "pancurses"]
 [dependencies]
 bitflags = "1.0"
 cassowary = "0.3"
-itertools = "0.8"
-log = "0.4"
-either = "1.5"
 unicode-segmentation = "1.2"
 unicode-width = "0.1"
 termion = { version = "1.5", optional = true }
 rustbox = { version = "0.11", optional = true }
-crossterm = { version = "0.6", optional = true }
+crossterm = { version = "0.19", 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.6"
-failure = "0.1"
-structopt = "0.2"
+rand = "0.7"
+argh = "0.1"
+
+[[example]]
+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"

Makefile

@@ -1,113 +0,0 @@
-SHELL=/bin/bash
-
-# ================================ Cargo ======================================
-
-
-RUST_CHANNEL ?= stable
-CARGO_FLAGS =
-RUSTUP_INSTALLED = $(shell command -v rustup 2> /dev/null)
-
-ifndef RUSTUP_INSTALLED
-  CARGO = cargo
-else
-  ifdef CI
-    CARGO = cargo
-  else
-    CARGO = rustup run $(RUST_CHANNEL) cargo
-  endif
-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}'
-
-
-# =============================== 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 =======================================
-
-.PHONY: lint
-lint: fmt clippy ## Lint project files
-
-.PHONY: fmt
-fmt: ## Check the format of the source code
-	cargo fmt --all -- --check
-
-.PHONY: clippy
-clippy: ## Check the style of the source code and catch common errors
-	$(CARGO) clippy --all-features
-
-
-# ================================ Test =======================================
-
-.PHONY: test
-test: ## Run the tests
-	$(CARGO) test --all-features
-
-# =============================== Examples ====================================
-
-.PHONY: build-examples
-build-examples: ## Build all examples
-	@$(CARGO) build --examples --all-features
-
-.PHONY: run-examples
-run-examples: ## Run all examples
-	@for file in examples/*.rs; do \
-	  name=$$(basename $${file/.rs/}); \
-	  $(CARGO) run --all-features --release --example $$name; \
-	  done;
-
-# ================================ Doc ========================================
-
-
-.PHONY: doc
-doc: ## Build the documentation (available at ./target/doc)
-	$(CARGO) doc
-
-
-# ================================= Watch =====================================
-
-# 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: ## Watch file changes and rebuild the documentation if any
-	watchman-make -p 'src/**/*.rs' -t doc
-
-# ================================= Pipelines =================================
-
-.PHONY: stable
-stable: RUST_CHANNEL = stable
-stable: build test ## Run build and tests for stable
-
-.PHONY: beta
-beta: RUST_CHANNEL = beta
-beta: build test ## Run build and tests for beta
-
-.PHONY: nightly
-nightly: RUST_CHANNEL = nightly
-nightly: build lint test ## Run build, lint and tests for nightly

Makefile.toml

@@ -0,0 +1,142 @@
+[config]
+skip_core_tasks = true
+
+[env.TUI_FEATURES]
+source = "${CARGO_MAKE_RUST_TARGET_OS}"
+default_value = "unknown"
+
+[env.TUI_FEATURES.mapping]
+linux = "serde,crossterm,termion,rustbox,curses"
+macos = "serde,crossterm,termion,rustbox,curses"
+windows = "serde,crossterm"
+
+[tasks.default]
+dependencies = [
+  "check",
+]
+
+[tasks.ci]
+dependencies = [
+  "fmt",
+  "check",
+  "test",
+  "clippy",
+]
+
+
+[tasks.fmt]
+command = "cargo"
+args = [
+  "fmt",
+  "--all",
+  "--",
+  "--check",
+]
+
+[tasks.check]
+command = "cargo"
+args = [
+  "check",
+  "--no-default-features",
+  "--features",
+  "${TUI_FEATURES}",
+  "--all-targets",
+]
+
+[tasks.build]
+command = "cargo"
+args = [
+  "build",
+  "--no-default-features",
+  "--features",
+  "${TUI_FEATURES}",
+  "--all-targets",
+]
+
+[tasks.clippy]
+command = "cargo"
+args = [
+  "clippy",
+  "--no-default-features",
+  "--features",
+  "${TUI_FEATURES}",
+  "--",
+  "-D",
+  "warnings",
+]
+
+[tasks.test]
+linux_alias = "test-unix"
+mac_alias = "test-unix"
+windows_alias = "test-windows"
+
+[tasks.test-unix]
+command = "cargo"
+args = [
+  "test",
+  "--no-default-features",
+  "--features",
+  "${TUI_FEATURES}"
+]
+
+# Documentation tests cannot be run on Windows for now
+[tasks.test-windows]
+command = "cargo"
+args = [
+  "test",
+  "--no-default-features",
+  "--features",
+  "${TUI_FEATURES}",
+  "--lib",
+  "--tests",
+  "--examples",
+]
+
+[tasks.run-example]
+private = true
+condition = { env_set = ["TUI_EXAMPLE_NAME", "TUI_FEATURES"] }
+command = "cargo"
+args = [
+    "run",
+    "--features",
+    "${TUI_FEATURES}",
+    "--release",
+    "--example",
+    "${TUI_EXAMPLE_NAME}"
+]
+
+[tasks.run-example-windows]
+private = true
+condition = { env = {"TUI_EXAMPLE_NAME" = "crossterm_demo"} }
+run_task = "run-example"
+
+[tasks.run-example-router]
+private = true
+run_task = [
+    { name = "run-example-windows", condition = { platforms = ["window"] } },
+    { name = "run-example" }
+]
+
+[tasks.build-examples]
+condition = { env_set = ["TUI_FEATURES"] }
+command = "cargo"
+args = [
+    "build",
+    "--examples",
+    "--features",
+    "${TUI_FEATURES}",
+    "--release"
+]
+
+[tasks.run-examples]
+dependencies = ["build-examples"]
+script = '''
+#!@duckscript
+files = glob_array ./examples/*.rs
+for file in ${files}
+  name = basename ${file}
+  name = substring ${name} -3
+  set_env TUI_EXAMPLE_NAME ${name}
+  cm_run_task run-example-router
+end
+'''

README.md

@@ -1,7 +1,6 @@
 # tui-rs
 
-[![Build Status](https://travis-ci.org/fdehau/tui-rs.svg?branch=master)](https://travis-ci.org/fdehau/tui-rs)
-[![Build status](https://ci.appveyor.com/api/projects/status/t724mb1q31xpyxy5/branch/master?svg=true)](https://ci.appveyor.com/project/fdehau/tui-rs/branch/master)
+[![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/)
 
@@ -17,7 +16,7 @@ can either choose from:
 
   - [termion](https://github.com/ticki/termion)
   - [rustbox](https://github.com/gchp/rustbox)
-  - [crossterm](https://github.com/TimonPost/crossterm)
+  - [crossterm](https://github.com/crossterm-rs/crossterm)
   - [pancurses](https://github.com/ihalila/pancurses)
 
 However, some features may only be available in one of the four.
@@ -33,21 +32,41 @@ 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 demo shown in the gif can be run with all available backends
-(`exmples/*_demo.rs` files). For example to see the `termion` version one could
+(`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
 
 The library comes with the following list of widgets:
@@ -72,6 +91,26 @@ You can run all examples by running `make run-examples`.
 
 * [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)
+* [taskwarrior-tui](https://github.com/kdheepak/taskwarrior-tui)
+* [gping](https://github.com/orf/gping/)
+* [Vector](https://vector.dev)
+
 ### Alternatives
 
 You might want to checkout [Cursive](https://github.com/gyscos/Cursive) for an

appveyor.yml

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

examples/barchart.rs

@@ -1,19 +1,16 @@
 #[allow(dead_code)]
 mod util;
 
-use std::io;
-
-use termion::event::Key;
-use termion::input::MouseTerminal;
-use termion::raw::IntoRawMode;
-use termion::screen::AlternateScreen;
-use tui::backend::TermionBackend;
-use tui::layout::{Constraint, Direction, Layout};
-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> {
     data: Vec<(&'a str, u64)>,
@@ -57,14 +54,13 @@ impl<'a> App<'a> {
     }
 }
 
-fn main() -> Result<(), failure::Error> {
+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)?;
-    terminal.hide_cursor()?;
 
     // Setup event handlers
     let events = Events::new();
@@ -73,42 +69,51 @@ fn main() -> Result<(), failure::Error> {
     let mut app = App::new();
 
     loop {
-        terminal.draw(|mut f| {
+        terminal.draw(|f| {
             let chunks = Layout::default()
                 .direction(Direction::Vertical)
                 .margin(2)
                 .constraints([Constraint::Percentage(50), Constraint::Percentage(50)].as_ref())
                 .split(f.size());
-            BarChart::default()
+            let barchart = 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()
-                    .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()
-                    .block(Block::default().title("Data3").borders(Borders::ALL))
-                    .data(&app.data)
-                    .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]);
-            }
+                .bar_style(Style::default().fg(Color::Yellow))
+                .value_style(Style::default().fg(Color::Black).bg(Color::Yellow));
+            f.render_widget(barchart, chunks[0]);
+
+            let chunks = Layout::default()
+                .direction(Direction::Horizontal)
+                .constraints([Constraint::Percentage(50), Constraint::Percentage(50)].as_ref())
+                .split(chunks[1]);
+
+            let barchart = BarChart::default()
+                .block(Block::default().title("Data2").borders(Borders::ALL))
+                .data(&app.data)
+                .bar_width(5)
+                .bar_gap(3)
+                .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)
+                .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)
+                        .add_modifier(Modifier::ITALIC),
+                );
+            f.render_widget(barchart, chunks[1]);
         })?;
 
         match events.next()? {

examples/block.rs

@@ -1,87 +1,85 @@
 #[allow(dead_code)]
 mod util;
 
-use std::io;
-use termion::event::Key;
-use termion::input::MouseTerminal;
-use termion::raw::IntoRawMode;
-use termion::screen::AlternateScreen;
-use tui::backend::TermionBackend;
-use tui::layout::{Constraint, Direction, Layout};
-use tui::style::{Color, Modifier, Style};
-use tui::widgets::{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},
+    text::Span,
+    widgets::{Block, BorderType, Borders},
+    Terminal,
+};
 
-fn main() -> Result<(), failure::Error> {
+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)?;
-    terminal.hide_cursor()?;
 
     // Setup event handlers
     let events = Events::new();
 
     loop {
-        terminal.draw(|mut f| {
+        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();
-            Block::default().borders(Borders::ALL).render(&mut 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 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()
-                    .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")
-                    .border_style(Style::default().fg(Color::Cyan))
-                    .borders(Borders::LEFT | Borders::RIGHT)
-                    .render(&mut f, chunks[1]);
-            }
+
+            let top_chunks = Layout::default()
+                .direction(Direction::Horizontal)
+                .constraints([Constraint::Percentage(50), Constraint::Percentage(50)].as_ref())
+                .split(chunks[0]);
+            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]);
+            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)
+                .border_type(BorderType::Double);
+            f.render_widget(block, bottom_chunks[1]);
         })?;
 
-        match events.next()? {
-            Event::Input(key) => {
-                if key == Key::Char('q') {
-                    break;
-                }
+        if let Event::Input(key) = events.next()? {
+            if key == Key::Char('q') {
+                break;
             }
-            _ => {}
         }
     }
     Ok(())

examples/canvas.rs

@@ -1,29 +1,27 @@
 #[allow(dead_code)]
 mod util;
 
-use std::io;
-use std::time::Duration;
-
-use termion::event::Key;
-use termion::input::MouseTerminal;
-use termion::raw::IntoRawMode;
-use termion::screen::AlternateScreen;
-use tui::backend::TermionBackend;
-use tui::layout::{Constraint, Direction, Layout, Rect};
-use tui::style::Color;
-use tui::widgets::canvas::{Canvas, Map, MapResolution, Rectangle};
-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 {
     x: f64,
     y: f64,
-    ball: Rect,
+    ball: Rectangle,
     playground: Rect,
-    vx: u16,
-    vy: u16,
+    vx: f64,
+    vy: f64,
     dir_x: bool,
     dir_y: bool,
 }
@@ -33,21 +31,29 @@ impl App {
         App {
             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 update(&mut self) {
-        if self.ball.left() < self.playground.left() || self.ball.right() > self.playground.right()
+        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;
         }
@@ -66,18 +72,17 @@ impl App {
     }
 }
 
-fn main() -> Result<(), failure::Error> {
+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)?;
-    terminal.hide_cursor()?;
 
     // Setup event handlers
     let config = Config {
-        tick_rate: Duration::from_millis(100),
+        tick_rate: Duration::from_millis(250),
         ..Default::default()
     };
     let events = Events::with_config(config);
@@ -86,12 +91,12 @@ fn main() -> Result<(), failure::Error> {
     let mut app = App::new();
 
     loop {
-        terminal.draw(|mut f| {
+        terminal.draw(|f| {
             let chunks = Layout::default()
                 .direction(Direction::Horizontal)
                 .constraints([Constraint::Percentage(50), Constraint::Percentage(50)].as_ref())
                 .split(f.size());
-            Canvas::default()
+            let canvas = Canvas::default()
                 .block(Block::default().borders(Borders::ALL).title("World"))
                 .paint(|ctx| {
                     ctx.draw(&Map {
@@ -101,19 +106,16 @@ fn main() -> Result<(), failure::Error> {
                     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()
+                .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(&Rectangle {
-                        rect: app.ball,
-                        color: Color::Yellow,
-                    });
+                    ctx.draw(&app.ball);
                 })
                 .x_bounds([10.0, 110.0])
-                .y_bounds([10.0, 110.0])
-                .render(&mut f, chunks[1]);
+                .y_bounds([10.0, 110.0]);
+            f.render_widget(canvas, chunks[1]);
         })?;
 
         match events.next()? {

examples/chart.rs

@@ -1,19 +1,32 @@
 #[allow(dead_code)]
 mod util;
 
-use std::io;
+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::Key;
-use termion::input::MouseTerminal;
-use termion::raw::IntoRawMode;
-use termion::screen::AlternateScreen;
-use tui::backend::TermionBackend;
-use tui::style::{Color, Modifier, Style};
-use tui::widgets::{Axis, Block, Borders, Chart, Dataset, Marker, Widget};
-use tui::Terminal;
-
-use crate::util::event::{Event, Events};
-use crate::util::SinSignal;
+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 {
     signal1: SinSignal,
@@ -52,14 +65,13 @@ impl App {
     }
 }
 
-fn main() -> Result<(), failure::Error> {
+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)?;
-    terminal.hide_cursor()?;
 
     let events = Events::new();
 
@@ -67,48 +79,155 @@ fn main() -> Result<(), failure::Error> {
     let mut app = App::new();
 
     loop {
-        terminal.draw(|mut f| {
+        terminal.draw(|f| {
             let size = f.size();
-            Chart::default()
+            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(symbols::Marker::Dot)
+                    .style(Style::default().fg(Color::Cyan))
+                    .data(&app.data1),
+                Dataset::default()
+                    .name("data3")
+                    .marker(symbols::Marker::Braille)
+                    .style(Style::default().fg(Color::Yellow))
+                    .data(&app.data2),
+            ];
+
+            let chart = Chart::new(datasets)
                 .block(
                     Block::default()
-                        .title("Chart")
-                        .title_style(Style::default().fg(Color::Cyan).modifier(Modifier::BOLD))
+                        .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_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]),
+                        .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))
-                        .labels_style(Style::default().modifier(Modifier::ITALIC))
-                        .bounds([-20.0, 20.0])
-                        .labels(&["-20", "0", "20"]),
+                        .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),
                 )
-                .datasets(&[
-                    Dataset::default()
-                        .name("data2")
-                        .marker(Marker::Dot)
-                        .style(Style::default().fg(Color::Cyan))
-                        .data(&app.data1),
-                    Dataset::default()
-                        .name("data3")
-                        .marker(Marker::Braille)
-                        .style(Style::default().fg(Color::Yellow))
-                        .data(&app.data2),
-                ])
-                .render(&mut f, size);
+                .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()? {

examples/crossterm_demo.rs

@@ -3,83 +3,98 @@ mod demo;
 #[allow(dead_code)]
 mod util;
 
-use std::sync::mpsc;
-use std::thread;
-use std::time::Duration;
-
-use crossterm;
-use structopt::StructOpt;
-use tui::backend::CrosstermBackend;
-use tui::Terminal;
-
 use crate::demo::{ui, App};
+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,
+    sync::mpsc,
+    thread,
+    time::{Duration, Instant},
+};
+use tui::{backend::CrosstermBackend, Terminal};
 
 enum Event<I> {
     Input(I),
     Tick,
 }
 
-#[derive(Debug, StructOpt)]
+/// Crossterm demo
+#[derive(Debug, FromArgs)]
 struct Cli {
-    #[structopt(long = "tick-rate", default_value = "250")]
+    /// time in ms between two ticks.
+    #[argh(option, default = "250")]
     tick_rate: u64,
-    #[structopt(long = "log")]
-    log: bool,
+    /// whether unicode symbols are used to improve the overall look of the app
+    #[argh(option, default = "true")]
+    enhanced_graphics: bool,
 }
 
-fn main() -> Result<(), failure::Error> {
-    let cli = Cli::from_args();
-    stderrlog::new().quiet(!cli.log).verbosity(4).init()?;
+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 screen = crossterm::Screen::default();
-    let alternate_screen = screen.enable_alternate_modes(true)?;
-    let backend = CrosstermBackend::with_alternate_screen(alternate_screen)?;
     let mut terminal = Terminal::new(backend)?;
-    terminal.hide_cursor()?;
 
     // Setup input handling
     let (tx, rx) = mpsc::channel();
-    {
-        let tx = tx.clone();
-        thread::spawn(move || {
-            let input = crossterm::input();
-            loop {
-                match input.read_char() {
-                    Ok(key) => {
-                        if let Err(_) = tx.send(Event::Input(key)) {
-                            return;
-                        }
-                        if key == 'q' {
-                            return;
-                        }
-                    }
-                    Err(_) => {}
+
+    let 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();
                 }
             }
-        });
-    }
-    {
-        let tx = tx.clone();
-        thread::spawn(move || {
-            let tx = tx.clone();
-            loop {
+            if last_tick.elapsed() >= tick_rate {
                 tx.send(Event::Tick).unwrap();
-                thread::sleep(Duration::from_millis(cli.tick_rate));
+                last_tick = Instant::now();
             }
-        });
-    }
+        }
+    });
 
-    let mut app = App::new("Crossterm Demo");
+    let mut app = App::new("Crossterm Demo", cli.enhanced_graphics);
 
     terminal.clear()?;
 
     loop {
-        ui::draw(&mut terminal, &app)?;
+        terminal.draw(|f| ui::draw(f, &mut app))?;
         match rx.recv()? {
-            Event::Input(key) => {
-                // TODO: handle key events once they are supported by crossterm
-                app.on_key(key);
-            }
+            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();
             }

examples/curses_demo.rs

@@ -2,29 +2,31 @@ mod demo;
 #[allow(dead_code)]
 mod util;
 
-use std::io;
-use std::time::{Duration, Instant};
-
-use easycurses;
-use structopt::StructOpt;
-use tui::backend::CursesBackend;
-use tui::Terminal;
-
 use crate::demo::{ui, App};
+use argh::FromArgs;
+use std::{
+    error::Error,
+    io,
+    time::{Duration, Instant},
+};
+use tui::{backend::CursesBackend, Terminal};
 
-#[derive(Debug, StructOpt)]
+/// Curses demo
+#[derive(Debug, FromArgs)]
 struct Cli {
-    #[structopt(long = "tick-rate", default_value = "250")]
+    /// time in ms between two ticks.
+    #[argh(option, default = "250")]
     tick_rate: u64,
-    #[structopt(long = "log")]
-    log: bool,
+    /// whether unicode symbols are used to improve the overall look of the app
+    #[argh(option, default = "true")]
+    enhanced_graphics: bool,
 }
 
-fn main() -> Result<(), failure::Error> {
-    let cli = Cli::from_args();
-    stderrlog::new().quiet(!cli.log).verbosity(4).init()?;
+fn main() -> Result<(), Box<dyn Error>> {
+    let cli: Cli = argh::from_env();
 
-    let mut backend = CursesBackend::new().ok_or(io::Error::new(io::ErrorKind::Other, ""))?;
+    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));
@@ -33,34 +35,31 @@ fn main() -> Result<(), failure::Error> {
     let mut terminal = Terminal::new(backend)?;
     terminal.hide_cursor()?;
 
-    let mut app = App::new("Curses demo");
+    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 {
-        ui::draw(&mut terminal, &app)?;
-        match terminal.backend_mut().get_curses_mut().get_input() {
-            Some(input) => {
-                match input {
-                    easycurses::Input::Character(c) => {
-                        app.on_key(c);
-                    }
-                    easycurses::Input::KeyUp => {
-                        app.on_up();
-                    }
-                    easycurses::Input::KeyDown => {
-                        app.on_down();
-                    }
-                    easycurses::Input::KeyLeft => {
-                        app.on_left();
-                    }
-                    easycurses::Input::KeyRight => {
-                        app.on_right();
-                    }
-                    _ => {}
-                };
-            }
-            _ => {}
+        terminal.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 {

examples/custom_widget.rs

@@ -1,20 +1,12 @@
 #[allow(dead_code)]
 mod util;
 
-use std::io;
-
-use termion::event::Key;
-use termion::input::MouseTerminal;
-use termion::raw::IntoRawMode;
-use termion::screen::AlternateScreen;
-use tui::backend::TermionBackend;
-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,
@@ -27,19 +19,19 @@ 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() -> Result<(), failure::Error> {
+fn main() -> Result<(), Box<dyn Error>> {
     // Terminal initialization
     let stdout = io::stdout().into_raw_mode()?;
     let stdout = MouseTerminal::from(stdout);
@@ -50,18 +42,16 @@ fn main() -> Result<(), failure::Error> {
     let events = Events::new();
 
     loop {
-        terminal.draw(|mut f| {
+        terminal.draw(|f| {
             let size = f.size();
-            Label::default().text("Test").render(&mut f, size);
+            let label = Label::default().text("Test");
+            f.render_widget(label, size);
         })?;
 
-        match events.next()? {
-            Event::Input(key) => {
-                if key == Key::Char('q') {
-                    break;
-                }
+        if let Event::Input(key) = events.next()? {
+            if key == Key::Char('q') {
+                break;
             }
-            _ => {}
         }
     }
 

examples/demo/app.rs

@@ -1,12 +1,12 @@
-use crate::util::{RandomSignal, SinSignal, TabsState};
+use crate::util::{RandomSignal, SinSignal, StatefulList, TabsState};
 
-const TASKS: [&'static str; 24] = [
+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: [(&'static str, &'static str); 26] = [
+const LOGS: [(&str, &str); 26] = [
     ("Event1", "INFO"),
     ("Event2", "INFO"),
     ("Event3", "CRITICAL"),
@@ -35,7 +35,7 @@ const LOGS: [(&'static str, &'static str); 26] = [
     ("Event26", "INFO"),
 ];
 
-const EVENTS: [(&'static str, u64); 24] = [
+const EVENTS: [(&str, u64); 24] = [
     ("B1", 9),
     ("B2", 12),
     ("B3", 5),
@@ -96,27 +96,6 @@ impl Signals {
     }
 }
 
-pub struct ListState<I> {
-    pub items: Vec<I>,
-    pub selected: usize,
-}
-
-impl<I> ListState<I> {
-    fn new(items: Vec<I>) -> ListState<I> {
-        ListState { items, selected: 0 }
-    }
-    fn select_previous(&mut self) {
-        if self.selected > 0 {
-            self.selected -= 1;
-        }
-    }
-    fn select_next(&mut self) {
-        if self.selected < self.items.len() - 1 {
-            self.selected += 1
-        }
-    }
-}
-
 pub struct Server<'a> {
     pub name: &'a str,
     pub location: &'a str,
@@ -129,17 +108,18 @@ pub struct App<'a> {
     pub should_quit: bool,
     pub tabs: TabsState<'a>,
     pub show_chart: bool,
-    pub progress: u16,
+    pub progress: f64,
     pub sparkline: Signal<RandomSignal>,
-    pub tasks: ListState<(&'a str)>,
-    pub logs: ListState<(&'a str, &'a str)>,
+    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) -> 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);
@@ -149,16 +129,16 @@ impl<'a> App<'a> {
         App {
             title,
             should_quit: false,
-            tabs: TabsState::new(vec!["Tab0", "Tab1"]),
+            tabs: TabsState::new(vec!["Tab0", "Tab1", "Tab2"]),
             show_chart: true,
-            progress: 0,
+            progress: 0.0,
             sparkline: Signal {
                 source: rand_signal,
                 points: sparkline_points,
                 tick_rate: 1,
             },
-            tasks: ListState::new(TASKS.to_vec()),
-            logs: ListState::new(LOGS.to_vec()),
+            tasks: StatefulList::with_items(TASKS.to_vec()),
+            logs: StatefulList::with_items(LOGS.to_vec()),
             signals: Signals {
                 sin1: Signal {
                     source: sin_signal,
@@ -199,15 +179,16 @@ impl<'a> App<'a> {
                     status: "Up",
                 },
             ],
+            enhanced_graphics,
         }
     }
 
     pub fn on_up(&mut self) {
-        self.tasks.select_previous();
+        self.tasks.previous();
     }
 
     pub fn on_down(&mut self) {
-        self.tasks.select_next();
+        self.tasks.next();
     }
 
     pub fn on_right(&mut self) {
@@ -232,9 +213,9 @@ impl<'a> App<'a> {
 
     pub fn on_tick(&mut self) {
         // Update progress
-        self.progress += 5;
-        if self.progress > 100 {
-            self.progress = 0;
+        self.progress += 0.001;
+        if self.progress > 1.0 {
+            self.progress = 0.0;
         }
 
         self.sparkline.on_tick();

examples/demo/ui.rs

@@ -1,46 +1,50 @@
-use std::io;
-
-use tui::backend::Backend;
-use tui::layout::{Constraint, Direction, Layout, Rect};
-use tui::style::{Color, Modifier, Style};
-use tui::widgets::canvas::{Canvas, Line, Map, MapResolution, Rectangle};
-use tui::widgets::{
-    Axis, BarChart, Block, Borders, Chart, Dataset, Gauge, List, Marker, Paragraph, Row,
-    SelectableList, Sparkline, Table, Tabs, Text, Widget,
-};
-use tui::{Frame, Terminal};
-
 use crate::demo::App;
+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, Cell, Chart, Dataset, Gauge, LineGauge, List, ListItem,
+        Paragraph, Row, Sparkline, Table, Tabs, Wrap,
+    },
+    Frame,
+};
 
-pub fn draw<B: Backend>(terminal: &mut Terminal<B>, app: &App) -> Result<(), io::Error> {
-    terminal.draw(|mut f| {
-        let chunks = Layout::default()
-            .constraints([Constraint::Length(3), Constraint::Min(0)].as_ref())
-            .split(f.size());
-        Tabs::default()
-            .block(Block::default().borders(Borders::ALL).title(app.title))
-            .titles(&app.tabs.titles)
-            .style(Style::default().fg(Color::Green))
-            .highlight_style(Style::default().fg(Color::Yellow))
-            .select(app.tabs.index)
-            .render(&mut f, chunks[0]);
-        match app.tabs.index {
-            0 => draw_first_tab(&mut f, &app, chunks[1]),
-            1 => draw_second_tab(&mut f, &app, chunks[1]),
-            _ => {}
-        };
-    })
+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]),
+        2 => draw_third_tab(f, app, chunks[1]),
+        _ => {}
+    };
 }
 
-fn draw_first_tab<B>(f: &mut Frame<B>, app: &App, area: Rect)
+fn draw_first_tab<B>(f: &mut Frame<B>, app: &mut App, area: Rect)
 where
     B: Backend,
 {
     let chunks = Layout::default()
         .constraints(
             [
-                Constraint::Length(7),
-                Constraint::Min(7),
+                Constraint::Length(9),
+                Constraint::Min(8),
                 Constraint::Length(7),
             ]
             .as_ref(),
@@ -51,37 +55,61 @@ where
     draw_text(f, chunks[2]);
 }
 
-fn draw_gauges<B>(f: &mut Frame<B>, app: &App, area: Rect)
+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)].as_ref())
+        .constraints(
+            [
+                Constraint::Length(2),
+                Constraint::Length(3),
+                Constraint::Length(1),
+            ]
+            .as_ref(),
+        )
         .margin(1)
         .split(area);
-    Block::default()
-        .borders(Borders::ALL)
-        .title("Graphs")
-        .render(f, area);
-    Gauge::default()
+    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:"))
-        .style(
+        .gauge_style(
             Style::default()
                 .fg(Color::Magenta)
                 .bg(Color::Black)
-                .modifier(Modifier::ITALIC | Modifier::BOLD),
+                .add_modifier(Modifier::ITALIC | Modifier::BOLD),
         )
-        .label(&format!("{} / 100", app.progress))
-        .percent(app.progress)
-        .render(f, chunks[0]);
-    Sparkline::default()
+        .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)
-        .render(f, chunks[1]);
+        .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: &App, area: Rect)
+fn draw_charts<B>(f: &mut Frame<B>, app: &mut App, area: Rect)
 where
     B: Backend,
 {
@@ -103,88 +131,128 @@ where
                 .constraints([Constraint::Percentage(50), Constraint::Percentage(50)].as_ref())
                 .direction(Direction::Horizontal)
                 .split(chunks[0]);
-            SelectableList::default()
+
+            // 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"))
-                .items(&app.tasks.items)
-                .select(Some(app.tasks.selected))
-                .highlight_style(Style::default().fg(Color::Yellow).modifier(Modifier::BOLD))
-                .highlight_symbol(">")
-                .render(f, chunks[0]);
-            let info_style = Style::default().fg(Color::White);
+                .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 events = app.logs.items.iter().map(|&(evt, level)| {
-                Text::styled(
-                    format!("{}: {}", level, evt),
-                    match level {
+            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,
-                    },
-                )
-            });
-            List::new(events)
-                .block(Block::default().borders(Borders::ALL).title("List"))
-                .render(f, chunks[1]);
+                    };
+                    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);
         }
-        BarChart::default()
+
+        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)
-                    .modifier(Modifier::ITALIC),
+                    .add_modifier(Modifier::ITALIC),
             )
             .label_style(Style::default().fg(Color::Yellow))
-            .style(Style::default().fg(Color::Green))
-            .render(f, chunks[1]);
+            .bar_style(Style::default().fg(Color::Green));
+        f.render_widget(barchart, chunks[1]);
     }
     if app.show_chart {
-        Chart::default()
+        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("Chart")
-                    .title_style(Style::default().fg(Color::Cyan).modifier(Modifier::BOLD))
+                    .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))
-                    .labels_style(Style::default().modifier(Modifier::ITALIC))
                     .bounds(app.signals.window)
-                    .labels(&[
-                        &format!("{}", app.signals.window[0]),
-                        &format!("{}", (app.signals.window[0] + app.signals.window[1]) / 2.0),
-                        &format!("{}", app.signals.window[1]),
-                    ]),
+                    .labels(x_labels),
             )
             .y_axis(
                 Axis::default()
                     .title("Y Axis")
                     .style(Style::default().fg(Color::Gray))
-                    .labels_style(Style::default().modifier(Modifier::ITALIC))
                     .bounds([-20.0, 20.0])
-                    .labels(&["-20", "0", "20"]),
-            )
-            .datasets(&[
-                Dataset::default()
-                    .name("data2")
-                    .marker(Marker::Dot)
-                    .style(Style::default().fg(Color::Cyan))
-                    .data(&app.signals.sin1.points),
-                Dataset::default()
-                    .name("data3")
-                    .marker(Marker::Braille)
-                    .style(Style::default().fg(Color::Yellow))
-                    .data(&app.signals.sin2.points),
-            ])
-            .render(f, chunks[1]);
+                    .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]);
     }
 }
 
@@ -192,35 +260,44 @@ fn draw_text<B>(f: &mut Frame<B>, area: Rect)
 where
     B: Backend,
 {
-    let text = [
-        Text::raw("This is a paragraph with several lines. You can change style your text the way you want.\n\nFox example: "),
-        Text::styled("under", Style::default().fg(Color::Red)),
-        Text::raw(" "),
-        Text::styled("the", Style::default().fg(Color::Green)),
-        Text::raw(" "),
-        Text::styled("rainbow", Style::default().fg(Color::Blue)),
-        Text::raw(".\nOh and if you didn't "),
-        Text::styled("notice", Style::default().modifier(Modifier::ITALIC)),
-        Text::raw(" you can "),
-        Text::styled("automatically", Style::default().modifier(Modifier::BOLD)),
-        Text::raw(" "),
-        Text::styled("wrap", Style::default().modifier(Modifier::REVERSED)),
-        Text::raw(" your "),
-        Text::styled("text", Style::default().modifier(Modifier::UNDERLINED)),
-        Text::raw(".\nOne more thing is that it should display unicode characters: 10€")
+    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€"
+        ),
     ];
-    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);
+    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: &App, area: Rect)
+fn draw_second_tab<B>(f: &mut Frame<B>, app: &mut App, area: Rect)
 where
     B: Backend,
 {
@@ -231,23 +308,30 @@ where
     let up_style = Style::default().fg(Color::Green);
     let failure_style = Style::default()
         .fg(Color::Red)
-        .modifier(Modifier::RAPID_BLINK | Modifier::CROSSED_OUT);
-    let header = ["Server", "Location", "Status"];
+        .add_modifier(Modifier::RAPID_BLINK | Modifier::CROSSED_OUT);
     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)
+        Row::new(vec![s.name, s.location, s.status]).style(style)
     });
-    Table::new(header.into_iter(), rows)
+    let table = Table::new(rows)
+        .header(
+            Row::new(vec!["Server", "Location", "Status"])
+                .style(Style::default().fg(Color::Yellow))
+                .bottom_margin(1),
+        )
         .block(Block::default().title("Servers").borders(Borders::ALL))
-        .header_style(Style::default().fg(Color::Yellow))
-        .widths(&[15, 15, 10])
-        .render(f, chunks[0]);
+        .widths(&[
+            Constraint::Length(15),
+            Constraint::Length(15),
+            Constraint::Length(10),
+        ]);
+    f.render_widget(table, chunks[0]);
 
-    Canvas::default()
+    let map = Canvas::default()
         .block(Block::default().title("World").borders(Borders::ALL))
         .paint(|ctx| {
             ctx.draw(&Map {
@@ -256,12 +340,10 @@ where
             });
             ctx.layer();
             ctx.draw(&Rectangle {
-                rect: Rect {
-                    x: 0,
-                    y: 30,
-                    width: 10,
-                    height: 10,
-                },
+                x: 0.0,
+                y: 30.0,
+                width: 10.0,
+                height: 10.0,
                 color: Color::Yellow,
             });
             for (i, s1) in app.servers.iter().enumerate() {
@@ -284,7 +366,60 @@ where
                 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])
-        .render(f, chunks[1]);
+        .y_bounds([-90.0, 90.0]);
+    f.render_widget(map, chunks[1]);
+}
+
+fn draw_third_tab<B>(f: &mut Frame<B>, _app: &mut App, area: Rect)
+where
+    B: Backend,
+{
+    let chunks = Layout::default()
+        .direction(Direction::Horizontal)
+        .constraints([Constraint::Ratio(1, 2), Constraint::Ratio(1, 2)])
+        .split(area);
+    let colors = [
+        Color::Reset,
+        Color::Black,
+        Color::Red,
+        Color::Green,
+        Color::Yellow,
+        Color::Blue,
+        Color::Magenta,
+        Color::Cyan,
+        Color::Gray,
+        Color::DarkGray,
+        Color::LightRed,
+        Color::LightGreen,
+        Color::LightYellow,
+        Color::LightBlue,
+        Color::LightMagenta,
+        Color::LightCyan,
+        Color::White,
+    ];
+    let items: Vec<Row> = colors
+        .iter()
+        .map(|c| {
+            let cells = vec![
+                Cell::from(Span::raw(format!("{:?}: ", c))),
+                Cell::from(Span::styled("Foreground", Style::default().fg(*c))),
+                Cell::from(Span::styled("Background", Style::default().bg(*c))),
+            ];
+            Row::new(cells)
+        })
+        .collect();
+    let table = Table::new(items)
+        .block(Block::default().title("Colors").borders(Borders::ALL))
+        .widths(&[
+            Constraint::Ratio(1, 3),
+            Constraint::Ratio(1, 3),
+            Constraint::Ratio(1, 3),
+        ]);
+    f.render_widget(table, chunks[0]);
 }

examples/gauge.rs

@@ -1,19 +1,16 @@
 #[allow(dead_code)]
 mod util;
 
-use std::io;
-
-use termion::event::Key;
-use termion::input::MouseTerminal;
-use termion::raw::IntoRawMode;
-use termion::screen::AlternateScreen;
-use tui::backend::TermionBackend;
-use tui::layout::{Constraint, Direction, Layout};
-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 {
     progress1: u16,
@@ -52,21 +49,20 @@ impl App {
     }
 }
 
-fn main() -> Result<(), failure::Error> {
+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)?;
-    terminal.hide_cursor()?;
 
     let events = Events::new();
 
     let mut app = App::new();
 
     loop {
-        terminal.draw(|mut f| {
+        terminal.draw(|f| {
             let chunks = Layout::default()
                 .direction(Direction::Vertical)
                 .margin(2)
@@ -81,28 +77,38 @@ fn main() -> Result<(), failure::Error> {
                 )
                 .split(f.size());
 
-            Gauge::default()
+            let gauge = 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()
+                .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))
-                .style(Style::default().fg(Color::Magenta).bg(Color::Green))
+                .gauge_style(Style::default().fg(Color::Magenta).bg(Color::Green))
                 .percent(app.progress2)
-                .label(&format!("{}/100", app.progress2))
-                .render(&mut f, chunks[1]);
-            Gauge::default()
+                .label(label);
+            f.render_widget(gauge, chunks[1]);
+
+            let gauge = Gauge::default()
                 .block(Block::default().title("Gauge3").borders(Borders::ALL))
-                .style(Style::default().fg(Color::Yellow))
-                .ratio(app.progress3)
-                .render(&mut f, chunks[2]);
-            Gauge::default()
-                .block(Block::default().title("Gauge4").borders(Borders::ALL))
-                .style(Style::default().fg(Color::Cyan).modifier(Modifier::ITALIC))
+                .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(&format!("{}/100", app.progress2))
-                .render(&mut f, chunks[3]);
+                .label(label)
+                .use_unicode(true);
+            f.render_widget(gauge, chunks[3]);
         })?;
 
         match events.next()? {

examples/layout.rs

@@ -1,32 +1,28 @@
 #[allow(dead_code)]
 mod util;
 
-use std::io;
-
-use termion::event::Key;
-use termion::input::MouseTerminal;
-use termion::raw::IntoRawMode;
-use termion::screen::AlternateScreen;
-use tui::backend::TermionBackend;
-use tui::layout::{Constraint, Direction, Layout};
-use tui::widgets::{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},
+    widgets::{Block, Borders},
+    Terminal,
+};
 
-fn main() -> Result<(), failure::Error> {
+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)?;
-    terminal.hide_cursor()?;
 
     let events = Events::new();
 
     loop {
-        terminal.draw(|mut f| {
+        terminal.draw(|f| {
             let chunks = Layout::default()
                 .direction(Direction::Vertical)
                 .constraints(
@@ -39,23 +35,16 @@ fn main() -> Result<(), failure::Error> {
                 )
                 .split(f.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]);
+            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]);
         })?;
 
-        match events.next()? {
-            Event::Input(input) => {
-                if let Key::Char('q') = input {
-                    break;
-                }
+        if let Event::Input(input) = events.next()? {
+            if let Key::Char('q') = input {
+                break;
             }
-            _ => {}
         }
     }
 

examples/list.rs

@@ -1,39 +1,62 @@
 #[allow(dead_code)]
 mod util;
 
-use std::io;
-
-use termion::event::Key;
-use termion::input::MouseTerminal;
-use termion::raw::IntoRawMode;
-use termion::screen::AlternateScreen;
-use tui::backend::TermionBackend;
-use tui::layout::{Constraint, Corner, Direction, Layout};
-use tui::style::{Color, Modifier, Style};
-use tui::widgets::{Block, Borders, List, SelectableList, Text, Widget};
-use tui::Terminal;
-
-use crate::util::event::{Event, Events};
+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,
+};
 
+/// This struct holds the current state of the app. In particular, it has the `items` field which is a wrapper
+/// around `ListState`. Keeping track of the items state let us render the associated widget with its state
+/// and have access to features such as natural scrolling.
+///
+/// Check the event handling at the bottom to see how to change the state on incoming events.
+/// Check the drawing logic for items on how to specify the highlighting style for selected items.
 struct App<'a> {
-    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 {
-            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"),
@@ -62,97 +85,131 @@ 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),
         }
     }
 
+    /// Rotate through the event list.
+    /// This only exists to simulate some kind of "progress"
     fn advance(&mut self) {
-        let event = self.events.pop().unwrap();
-        self.events.insert(0, event);
+        let event = self.events.remove(0);
+        self.events.push(event);
     }
 }
 
-fn main() -> Result<(), failure::Error> {
+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)?;
-    terminal.hide_cursor()?;
 
     let events = Events::new();
 
-    // App
+    // Create a new app with some exapmle state
     let mut app = App::new();
 
     loop {
-        terminal.draw(|mut f| {
+        terminal.draw(|f| {
+            // Create two chunks with equal horizontal screen space
             let chunks = Layout::default()
                 .direction(Direction::Horizontal)
                 .constraints([Constraint::Percentage(50), Constraint::Percentage(50)].as_ref())
                 .split(f.size());
 
-            let style = Style::default().fg(Color::Black).bg(Color::White);
-            SelectableList::default()
+            // Iterate through all elements in the `items` app and append some debug text to it.
+            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();
+
+            // Create a List from all list items and highlight the currently selected one
+            let items = List::new(items)
                 .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]);
-            }
+                .highlight_style(
+                    Style::default()
+                        .bg(Color::LightGreen)
+                        .add_modifier(Modifier::BOLD),
+                )
+                .highlight_symbol(">> ");
+
+            // We can now render the item list
+            f.render_stateful_widget(items, chunks[0], &mut app.items.state);
+
+            // Let's do the same for the events.
+            // The event list doesn't have any state and only displays the current state of the list.
+            let events: Vec<ListItem> = app
+                .events
+                .iter()
+                .rev()
+                .map(|&(event, level)| {
+                    // Colorcode the level depending on its type
+                    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(),
+                    };
+                    // Add a example datetime and apply proper spacing between them
+                    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),
+                        ),
+                    ]);
+                    // The event gets it's own line
+                    let log = Spans::from(vec![Span::raw(event)]);
+
+                    // Here several things happen:
+                    // 1. Add a `---` spacing line above the final list entry
+                    // 2. Add the Level + datetime
+                    // 3. Add a spacer line
+                    // 4. Add the actual event
+                    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]);
         })?;
 
+        // This is a simple example on how to handle events
+        // 1. This breaks the loop and exits the program on `q` button press.
+        // 2. The `up`/`down` keys change the currently selected item in the App's `items` list.
+        // 3. `left` unselects the current item.
         match events.next()? {
             Event::Input(input) => match input {
                 Key::Char('q') => {
                     break;
                 }
                 Key::Left => {
-                    app.selected = None;
+                    app.items.unselect();
                 }
                 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)
-                    }
+                    app.items.next();
                 }
                 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)
-                    }
+                    app.items.previous();
                 }
                 _ => {}
             },

examples/paragraph.rs

@@ -1,34 +1,31 @@
 #[allow(dead_code)]
 mod util;
 
-use std::io;
-
-use termion::event::Key;
-use termion::input::MouseTerminal;
-use termion::raw::IntoRawMode;
-use termion::screen::AlternateScreen;
-use tui::backend::TermionBackend;
-use tui::layout::{Alignment, Constraint, Direction, Layout};
-use tui::style::{Color, Modifier, Style};
-use tui::widgets::{Block, Borders, Paragraph, Text, 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::{Alignment, Constraint, Direction, Layout},
+    style::{Color, Modifier, Style},
+    text::{Span, Spans},
+    widgets::{Block, Borders, Paragraph, Wrap},
+    Terminal,
+};
 
-fn main() -> Result<(), failure::Error> {
+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)?;
-    terminal.hide_cursor()?;
 
     let events = Events::new();
 
     let mut scroll: u16 = 0;
     loop {
-        terminal.draw(|mut f| {
+        terminal.draw(|f| {
             let size = f.size();
 
             // Words made "loooong" to demonstrate line breaking.
@@ -36,9 +33,9 @@ fn main() -> Result<(), failure::Error> {
             let mut long_line = s.repeat(usize::from(size.width) / s.len() + 4);
             long_line.push('\n');
 
-            Block::default()
-                .style(Style::default().bg(Color::White))
-                .render(&mut f, size);
+            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)
@@ -54,56 +51,60 @@ fn main() -> Result<(), failure::Error> {
                 )
                 .split(size);
 
-            let text = [
-                Text::raw("This is a line \n"),
-                Text::styled("This is a line   \n", Style::default().fg(Color::Red)),
-                Text::styled("This is a line\n", Style::default().bg(Color::Blue)),
-                Text::styled(
-                    "This is a longer line\n",
-                    Style::default().modifier(Modifier::CROSSED_OUT),
-                ),
-                Text::styled(&long_line, Style::default().bg(Color::Green)),
-                Text::styled(
-                    "This is a line\n",
-                    Style::default().fg(Color::Green).modifier(Modifier::ITALIC),
-                ),
+            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 block = Block::default()
-                .borders(Borders::ALL)
-                .title_style(Style::default().modifier(Modifier::BOLD));
-            Paragraph::new(text.iter())
-                .block(block.clone().title("Left, no wrap"))
+            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)
-                .render(&mut f, chunks[0]);
-            Paragraph::new(text.iter())
-                .block(block.clone().title("Left, wrap"))
-                .alignment(Alignment::Left)
-                .wrap(true)
-                .render(&mut f, chunks[1]);
-            Paragraph::new(text.iter())
-                .block(block.clone().title("Center, wrap"))
+                .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(true)
-                .scroll(scroll)
-                .render(&mut f, chunks[2]);
-            Paragraph::new(text.iter())
-                .block(block.clone().title("Right, wrap"))
+                .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(true)
-                .render(&mut f, chunks[3]);
+                .wrap(Wrap { trim: true });
+            f.render_widget(paragraph, chunks[3]);
         })?;
 
         scroll += 1;
         scroll %= 10;
 
-        match events.next()? {
-            Event::Input(key) => {
-                if key == Key::Char('q') {
-                    break;
-                }
+        if let Event::Input(key) = events.next()? {
+            if key == Key::Char('q') {
+                break;
             }
-            _ => {}
         }
     }
     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_demo.rs

@@ -2,39 +2,42 @@ mod demo;
 #[allow(dead_code)]
 mod util;
 
-use std::time::{Duration, Instant};
-
-use rustbox::keyboard::Key;
-use structopt::StructOpt;
-use tui::backend::RustboxBackend;
-use tui::Terminal;
-
 use crate::demo::{ui, App};
+use argh::FromArgs;
+use rustbox::keyboard::Key;
+use std::{
+    error::Error,
+    time::{Duration, Instant},
+};
+use tui::{backend::RustboxBackend, Terminal};
 
-#[derive(Debug, StructOpt)]
+/// Rustbox demo
+#[derive(Debug, FromArgs)]
 struct Cli {
-    #[structopt(long = "tick-rate", default_value = "250")]
+    /// time in ms between two ticks.
+    #[argh(option, default = "250")]
     tick_rate: u64,
-    #[structopt(long = "log")]
-    log: bool,
+    /// whether unicode symbols are used to improve the overall look of the app
+    #[argh(option, default = "true")]
+    enhanced_graphics: bool,
 }
 
-fn main() -> Result<(), failure::Error> {
-    let cli = Cli::from_args();
-    stderrlog::new().quiet(!cli.log).verbosity(4).init()?;
+fn main() -> Result<(), Box<dyn Error>> {
+    let cli: Cli = argh::from_env();
 
     let backend = RustboxBackend::new()?;
     let mut terminal = Terminal::new(backend)?;
-    terminal.hide_cursor()?;
 
-    let mut app = App::new("Rustbox demo");
+    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 {
-        ui::draw(&mut terminal, &app)?;
-        match terminal.backend().rustbox().peek_event(tick_rate, false) {
-            Ok(rustbox::Event::KeyEvent(key)) => match key {
+        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);
                 }
@@ -51,8 +54,7 @@ fn main() -> Result<(), failure::Error> {
                     app.on_right();
                 }
                 _ => {}
-            },
-            _ => {}
+            }
         }
         if last_tick.elapsed() > tick_rate {
             app.on_tick();

examples/sparkline.rs

@@ -1,20 +1,19 @@
 #[allow(dead_code)]
 mod util;
 
-use std::io;
-
-use termion::event::Key;
-use termion::input::MouseTerminal;
-use termion::raw::IntoRawMode;
-use termion::screen::AlternateScreen;
-use tui::backend::TermionBackend;
-use tui::layout::{Constraint, Direction, Layout};
-use tui::style::{Color, Style};
-use tui::widgets::{Block, Borders, Sparkline, Widget};
-use tui::Terminal;
-
-use crate::util::event::{Event, Events};
-use crate::util::RandomSignal;
+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 {
     signal: RandomSignal,
@@ -50,14 +49,13 @@ impl App {
     }
 }
 
-fn main() -> Result<(), failure::Error> {
+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)?;
-    terminal.hide_cursor()?;
 
     // Setup event handlers
     let events = Events::new();
@@ -66,7 +64,7 @@ fn main() -> Result<(), failure::Error> {
     let mut app = App::new();
 
     loop {
-        terminal.draw(|mut f| {
+        terminal.draw(|f| {
             let chunks = Layout::default()
                 .direction(Direction::Vertical)
                 .margin(2)
@@ -80,34 +78,34 @@ fn main() -> Result<(), failure::Error> {
                     .as_ref(),
                 )
                 .split(f.size());
-            Sparkline::default()
+            let sparkline = 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()
+                .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))
-                .render(&mut f, chunks[1]);
+                .style(Style::default().bg(Color::Green));
+            f.render_widget(sparkline, chunks[1]);
             // Multiline
-            Sparkline::default()
+            let sparkline = 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]);
+                .style(Style::default().fg(Color::Red));
+            f.render_widget(sparkline, chunks[2]);
         })?;
 
         match events.next()? {

examples/table.rs

@@ -1,100 +1,143 @@
 #[allow(dead_code)]
 mod util;
 
-use std::io;
-
-use termion::event::Key;
-use termion::input::MouseTerminal;
-use termion::raw::IntoRawMode;
-use termion::screen::AlternateScreen;
-use tui::backend::TermionBackend;
-use tui::layout::{Constraint, Layout};
-use tui::style::{Color, Modifier, Style};
-use tui::widgets::{Block, Borders, Row, Table, 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, Layout},
+    style::{Color, Modifier, Style},
+    widgets::{Block, Borders, Cell, Row, Table, TableState},
+    Terminal,
+};
 
-struct App<'a> {
+pub struct StatefulTable<'a> {
+    state: TableState,
     items: Vec<Vec<&'a str>>,
-    selected: usize,
 }
 
-impl<'a> App<'a> {
-    fn new() -> App<'a> {
-        App {
+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!["Row61", "Row62\nTest", "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,
         }
     }
+    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));
+    }
 }
 
-fn main() -> Result<(), failure::Error> {
+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)?;
-    terminal.hide_cursor()?;
 
     let events = Events::new();
 
-    // App
-    let mut app = App::new();
+    let mut table = StatefulTable::new();
 
     // Input
     loop {
-        terminal.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)
-                }
-            });
-
+        terminal.draw(|f| {
             let rects = Layout::default()
                 .constraints([Constraint::Percentage(100)].as_ref())
                 .margin(5)
                 .split(f.size());
-            Table::new(header.into_iter(), rows)
+
+            let selected_style = Style::default().add_modifier(Modifier::REVERSED);
+            let normal_style = Style::default().bg(Color::Blue);
+            let header_cells = ["Header1", "Header2", "Header3"]
+                .iter()
+                .map(|h| Cell::from(*h).style(Style::default().fg(Color::Red)));
+            let header = Row::new(header_cells)
+                .style(normal_style)
+                .height(1)
+                .bottom_margin(1);
+            let rows = table.items.iter().map(|item| {
+                let height = item
+                    .iter()
+                    .map(|content| content.chars().filter(|c| *c == '\n').count())
+                    .max()
+                    .unwrap_or(0)
+                    + 1;
+                let cells = item.iter().map(|c| Cell::from(*c));
+                Row::new(cells).height(height as u16).bottom_margin(1)
+            });
+            let t = Table::new(rows)
+                .header(header)
                 .block(Block::default().borders(Borders::ALL).title("Table"))
-                .widths(&[10, 10, 10])
-                .render(&mut f, rects[0]);
+                .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);
         })?;
 
-        match events.next()? {
-            Event::Input(key) => match key {
+        if let Event::Input(key) = events.next()? {
+            match key {
                 Key::Char('q') => {
                     break;
                 }
                 Key::Down => {
-                    app.selected += 1;
-                    if app.selected > app.items.len() - 1 {
-                        app.selected = 0;
-                    }
+                    table.next();
                 }
                 Key::Up => {
-                    if app.selected > 0 {
-                        app.selected -= 1;
-                    } else {
-                        app.selected = app.items.len() - 1;
-                    }
+                    table.previous();
                 }
                 _ => {}
-            },
-            _ => {}
+            }
         };
     }
 

examples/tabs.rs

@@ -1,33 +1,32 @@
 #[allow(dead_code)]
 mod util;
 
-use std::io;
-
-use termion::event::Key;
-use termion::input::MouseTerminal;
-use termion::raw::IntoRawMode;
-use termion::screen::AlternateScreen;
-use tui::backend::TermionBackend;
-use tui::layout::{Constraint, Direction, Layout};
-use tui::style::{Color, Style};
-use tui::widgets::{Block, Borders, Tabs, Widget};
-use tui::Terminal;
-
-use crate::util::event::{Event, Events};
-use crate::util::TabsState;
+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> {
     tabs: TabsState<'a>,
 }
 
-fn main() -> Result<(), failure::Error> {
+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)?;
-    terminal.hide_cursor()?;
 
     let events = Events::new();
 
@@ -38,7 +37,7 @@ fn main() -> Result<(), failure::Error> {
 
     // Main loop
     loop {
-        terminal.draw(|mut f| {
+        terminal.draw(|f| {
             let size = f.size();
             let chunks = Layout::default()
                 .direction(Direction::Vertical)
@@ -46,47 +45,49 @@ fn main() -> Result<(), failure::Error> {
                 .constraints([Constraint::Length(3), Constraint::Min(0)].as_ref())
                 .split(size);
 
-            Block::default()
-                .style(Style::default().bg(Color::White))
-                .render(&mut f, size);
-            Tabs::default()
+            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"))
-                .titles(&app.tabs.titles)
                 .select(app.tabs.index)
                 .style(Style::default().fg(Color::Cyan))
-                .highlight_style(Style::default().fg(Color::Yellow))
-                .render(&mut f, chunks[0]);
-            match app.tabs.index {
-                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]),
-                _ => {}
-            }
+                .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]);
         })?;
 
-        match events.next()? {
-            Event::Input(input) => match input {
+        if let Event::Input(input) = events.next()? {
+            match input {
                 Key::Char('q') => {
                     break;
                 }
                 Key::Right => app.tabs.next(),
                 Key::Left => app.tabs.previous(),
                 _ => {}
-            },
-            _ => {}
+            }
         }
     }
     Ok(())

examples/termion_demo.rs

@@ -2,31 +2,28 @@ mod demo;
 #[allow(dead_code)]
 mod util;
 
-use std::io;
-use std::time::Duration;
+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};
 
-use structopt::StructOpt;
-use termion::event::Key;
-use termion::input::MouseTerminal;
-use termion::raw::IntoRawMode;
-use termion::screen::AlternateScreen;
-use tui::backend::TermionBackend;
-use tui::Terminal;
-
-use crate::demo::{ui, App};
-use crate::util::event::{Config, Event, Events};
-
-#[derive(Debug, StructOpt)]
+/// Termion demo
+#[derive(Debug, FromArgs)]
 struct Cli {
-    #[structopt(long = "tick-rate", default_value = "250")]
+    /// time in ms between two ticks.
+    #[argh(option, default = "250")]
     tick_rate: u64,
-    #[structopt(long = "log")]
-    log: bool,
+    /// whether unicode symbols are used to improve the overall look of the app
+    #[argh(option, default = "true")]
+    enhanced_graphics: bool,
 }
 
-fn main() -> Result<(), failure::Error> {
-    let cli = Cli::from_args();
-    stderrlog::new().quiet(!cli.log).verbosity(4).init()?;
+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),
@@ -38,11 +35,11 @@ fn main() -> Result<(), failure::Error> {
     let stdout = AlternateScreen::from(stdout);
     let backend = TermionBackend::new(stdout);
     let mut terminal = Terminal::new(backend)?;
-    terminal.hide_cursor()?;
 
-    let mut app = App::new("Termion demo");
+    let mut app = App::new("Termion demo", cli.enhanced_graphics);
     loop {
-        ui::draw(&mut terminal, &app)?;
+        terminal.draw(|f| ui::draw(f, &mut app))?;
+
         match events.next()? {
             Event::Input(key) => match key {
                 Key::Char(c) => {

examples/user_input.rs

@@ -13,26 +13,30 @@
 #[allow(dead_code)]
 mod util;
 
-use std::io::{self, Write};
-
-use termion::cursor::Goto;
-use termion::event::Key;
-use termion::input::MouseTerminal;
-use termion::raw::IntoRawMode;
-use termion::screen::AlternateScreen;
-use tui::backend::TermionBackend;
-use tui::layout::{Constraint, Direction, Layout};
-use tui::style::{Color, Style};
-use tui::widgets::{Block, Borders, List, Paragraph, Text, 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},
+    text::{Span, Spans, Text},
+    widgets::{Block, Borders, List, ListItem, Paragraph},
+    Terminal,
+};
 use unicode_width::UnicodeWidthStr;
 
-use crate::util::event::{Event, Events};
+enum InputMode {
+    Normal,
+    Editing,
+}
 
 /// App holds the state of the application
 struct App {
     /// Current value of the input box
     input: String,
+    /// Current input mode
+    input_mode: InputMode,
     /// History of recorded messages
     messages: Vec<String>,
 }
@@ -41,12 +45,13 @@ impl Default for App {
     fn default() -> App {
         App {
             input: String::new(),
+            input_mode: InputMode::Normal,
             messages: Vec::new(),
         }
     }
 }
 
-fn main() -> Result<(), failure::Error> {
+fn main() -> Result<(), Box<dyn Error>> {
     // Terminal initialization
     let stdout = io::stdout().into_raw_mode()?;
     let stdout = MouseTerminal::from(stdout);
@@ -55,58 +60,121 @@ fn main() -> Result<(), failure::Error> {
     let mut terminal = Terminal::new(backend)?;
 
     // Setup event handlers
-    let events = Events::new();
+    let mut events = Events::new();
 
     // Create default app state
     let mut app = App::default();
 
     loop {
         // Draw UI
-        terminal.draw(|mut f| {
+        terminal.draw(|f| {
             let chunks = Layout::default()
                 .direction(Direction::Vertical)
                 .margin(2)
-                .constraints([Constraint::Length(3), Constraint::Min(1)].as_ref())
+                .constraints(
+                    [
+                        Constraint::Length(1),
+                        Constraint::Length(3),
+                        Constraint::Min(1),
+                    ]
+                    .as_ref(),
+                )
                 .split(f.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]);
-            let messages = app
+
+            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]);
+
+            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
+                    {}
+
+                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)));
-            List::new(messages)
-                .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]);
         })?;
 
-        // Put the cursor back inside the input box
-        write!(
-            terminal.backend_mut(),
-            "{}",
-            Goto(4 + app.input.width() as u16, 4)
-        )?;
-
         // Handle input
-        match events.next()? {
-            Event::Input(input) => match input {
-                Key::Char('q') => {
-                    break;
-                }
-                Key::Char('\n') => {
-                    app.messages.push(app.input.drain(..).collect());
-                }
-                Key::Char(c) => {
-                    app.input.push(c);
-                }
-                Key::Backspace => {
-                    app.input.pop();
-                }
-                _ => {}
-            },
-            _ => {}
+        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

@@ -1,5 +1,9 @@
 use std::io;
 use std::sync::mpsc;
+use std::sync::{
+    atomic::{AtomicBool, Ordering},
+    Arc,
+};
 use std::thread;
 use std::time::Duration;
 
@@ -16,6 +20,7 @@ pub enum Event<I> {
 pub struct Events {
     rx: mpsc::Receiver<Event<Key>>,
     input_handle: thread::JoinHandle<()>,
+    ignore_exit_key: Arc<AtomicBool>,
     tick_handle: thread::JoinHandle<()>,
 }
 
@@ -41,37 +46,36 @@ impl Events {
 
     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() {
-                    match evt {
-                        Ok(key) => {
-                            if let Err(_) = tx.send(Event::Input(key)) {
-                                return;
-                            }
-                            if key == config.exit_key {
-                                return;
-                            }
+                    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;
                         }
-                        Err(_) => {}
                     }
                 }
             })
         };
         let tick_handle = {
-            let tx = tx.clone();
-            thread::spawn(move || {
-                let tx = tx.clone();
-                loop {
-                    tx.send(Event::Tick).unwrap();
-                    thread::sleep(config.tick_rate);
+            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,
         }
@@ -80,4 +84,12 @@ impl Events {
     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

@@ -3,6 +3,7 @@ pub mod event;
 
 use rand::distributions::{Distribution, Uniform};
 use rand::rngs::ThreadRng;
+use tui::widgets::ListState;
 
 #[derive(Clone)]
 pub struct RandomSignal {
@@ -75,3 +76,56 @@ impl<'a> TabsState<'a> {
         }
     }
 }
+
+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);
+    }
+}

src/backend/crossterm.rs

@@ -1,235 +1,221 @@
-use std::io;
+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 crate::backend::Backend;
-use crate::buffer::Cell;
-use crate::layout::Rect;
-use crate::style::{Color, Modifier};
-use crossterm::error::ErrorKind;
-
-pub struct CrosstermBackend {
-    screen: Option<crossterm::Screen>,
-    crossterm: crossterm::Crossterm,
-    // Need to keep the AlternateScreen around even when not using it directly,
-    // see https://github.com/TimonPost/crossterm/issues/88
-    alternate_screen: Option<crossterm::AlternateScreen>,
+pub struct CrosstermBackend<W: Write> {
+    buffer: W,
 }
 
-impl Default for CrosstermBackend {
-    fn default() -> CrosstermBackend {
-        let screen = crossterm::Screen::default();
-        let crossterm = crossterm::Crossterm::from_screen(&screen);
-        CrosstermBackend {
-            screen: Some(screen),
-            crossterm,
-            alternate_screen: None,
-        }
+impl<W> CrosstermBackend<W>
+where
+    W: Write,
+{
+    pub fn new(buffer: W) -> CrosstermBackend<W> {
+        CrosstermBackend { buffer }
     }
 }
 
-impl CrosstermBackend {
-    pub fn new() -> CrosstermBackend {
-        CrosstermBackend::default()
-    }
-
-    pub fn with_screen(screen: crossterm::Screen) -> CrosstermBackend {
-        let crossterm = crossterm::Crossterm::from_screen(&screen);
-        CrosstermBackend {
-            screen: Some(screen),
-            crossterm,
-            alternate_screen: None,
-        }
-    }
-
-    pub fn with_alternate_screen(
-        alternate_screen: crossterm::AlternateScreen,
-    ) -> Result<CrosstermBackend, io::Error> {
-        let crossterm = crossterm::Crossterm::from_screen(&alternate_screen.screen);
-        Ok(CrosstermBackend {
-            screen: None,
-            crossterm,
-            alternate_screen: Some(alternate_screen),
-        })
-    }
-
-    pub fn screen(&self) -> Option<&crossterm::Screen> {
-        match &self.screen {
-            Some(screen) => Some(&screen),
-            None => None,
-        }
-    }
-
-    pub fn alternate_screen(&self) -> Option<&crossterm::AlternateScreen> {
-        match &self.alternate_screen {
-            Some(alt_screen) => Some(&alt_screen),
-            None => None,
-        }
-    }
-
-    pub fn crossterm(&self) -> &crossterm::Crossterm {
-        &self.crossterm
-    }
-}
-
-// TODO: consider associated Error type on Backend to allow custom error types
-// per backend
-fn convert_error(error: ErrorKind) -> io::Error {
-    match error {
-        ErrorKind::IoError(err) => err,
-        ErrorKind::FmtError(err) => {
-            io::Error::new(io::ErrorKind::Other, format!("Invalid formatting: {}", err))
-        }
-        ErrorKind::ResizingTerminalFailure(err) => io::Error::new(
-            io::ErrorKind::Other,
-            format!("Failed to resize terminal: {}", err),
-        ),
-        _ => io::Error::new(io::ErrorKind::Other, "Unknown crossterm error"),
-    }
-}
-
-impl Backend for CrosstermBackend {
-    fn clear(&mut self) -> io::Result<()> {
-        let terminal = self.crossterm.terminal();
-        terminal
-            .clear(crossterm::ClearType::All)
-            .map_err(convert_error)?;
-        Ok(())
-    }
-
-    fn hide_cursor(&mut self) -> io::Result<()> {
-        let cursor = self.crossterm.cursor();
-        cursor.hide().map_err(convert_error)?;
-        Ok(())
-    }
-
-    fn show_cursor(&mut self) -> io::Result<()> {
-        let cursor = self.crossterm.cursor();
-        cursor.show().map_err(convert_error)?;
-        Ok(())
-    }
-
-    fn get_cursor(&mut self) -> io::Result<(u16, u16)> {
-        let cursor = crossterm::cursor();
-        Ok(cursor.pos())
-    }
-
-    fn set_cursor(&mut self, x: u16, y: u16) -> io::Result<()> {
-        let cursor = crossterm::cursor();
-        cursor.goto(x, y).map_err(convert_error)
-    }
-
-    fn size(&self) -> io::Result<Rect> {
-        let terminal = self.crossterm.terminal();
-        let (width, height) = terminal.terminal_size();
-        Ok(Rect::new(0, 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 = self.crossterm.cursor();
-        let mut last_y = 0;
-        let mut last_x = 0;
-        let mut first = true;
+        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 || first {
-                cursor.goto(x, y).map_err(convert_error)?;
-                first = false;
+            // 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_x = x;
-            last_y = y;
-            let mut s = self.crossterm.style(&cell.symbol);
-            if let Some(color) = cell.style.fg.into() {
-                s = s.with(color)
+            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 let Some(color) = cell.style.bg.into() {
-                s = s.on(color)
+            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;
             }
-            s.object_style.attrs = cell.style.modifier.into();
 
-            self.crossterm.paint(s).map_err(convert_error)?;
+            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::Indexed(i) => Some(crossterm::Color::AnsiValue(i)),
-            Color::Rgb(r, g, b) => Some(crossterm::Color::Rgb { r, g, b }),
-        }
-    }
-}
-
-impl From<Modifier> for Vec<crossterm::Attribute> {
-    #[cfg(unix)]
-    fn from(modifier: Modifier) -> Vec<crossterm::Attribute> {
-        let mut result = Vec::new();
-
-        if modifier.contains(Modifier::BOLD) {
-            result.push(crossterm::Attribute::Bold)
-        }
-        if modifier.contains(Modifier::DIM) {
-            result.push(crossterm::Attribute::Dim)
-        }
-        if modifier.contains(Modifier::ITALIC) {
-            result.push(crossterm::Attribute::Italic)
-        }
-        if modifier.contains(Modifier::UNDERLINED) {
-            result.push(crossterm::Attribute::Underlined)
-        }
-        if modifier.contains(Modifier::SLOW_BLINK) {
-            result.push(crossterm::Attribute::SlowBlink)
-        }
-        if modifier.contains(Modifier::RAPID_BLINK) {
-            result.push(crossterm::Attribute::RapidBlink)
-        }
-        if modifier.contains(Modifier::REVERSED) {
-            result.push(crossterm::Attribute::Reverse)
-        }
-        if modifier.contains(Modifier::HIDDEN) {
-            result.push(crossterm::Attribute::Hidden)
-        }
-        if modifier.contains(Modifier::CROSSED_OUT) {
-            result.push(crossterm::Attribute::CrossedOut)
-        }
-
-        result
-    }
-
-    #[cfg(windows)]
-    fn from(modifier: Modifier) -> Vec<crossterm::Attribute> {
-        let mut result = Vec::new();
-
-        if modifier.contains(Modifier::BOLD) {
-            result.push(crossterm::Attribute::Bold)
-        }
-        if modifier.contains(Modifier::UNDERLINED) {
-            result.push(crossterm::Attribute::Underlined)
-        }
-
-        result
-    }
-}

src/backend/curses.rs

@@ -3,7 +3,7 @@ use std::io;
 use crate::backend::Backend;
 use crate::buffer::Cell;
 use crate::layout::Rect;
-use crate::style::{Color, Modifier, Style};
+use crate::style::{Color, Modifier};
 use crate::symbols::{bar, block};
 #[cfg(unix)]
 use crate::symbols::{line, DOT};
@@ -41,44 +41,41 @@ impl Backend for CursesBackend {
     {
         let mut last_col = 0;
         let mut last_row = 0;
-        let mut style = Style {
-            fg: Color::Reset,
-            bg: Color::Reset,
-            modifier: Modifier::empty(),
-        };
+        let mut 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 {
-            // eprintln!("{:?}", cell);
             if row != last_row || col != last_col + 1 {
                 self.curses.move_rc(i32::from(row), i32::from(col));
             }
             last_col = col;
             last_row = row;
-            if cell.style.modifier != style.modifier {
-                apply_modifier_diff(&mut self.curses.win, style.modifier, cell.style.modifier);
-                style.modifier = cell.style.modifier;
+            if cell.modifier != modifier {
+                apply_modifier_diff(&mut self.curses.win, modifier, cell.modifier);
+                modifier = cell.modifier;
             };
-            if cell.style.fg != style.fg {
+            if cell.fg != fg {
                 update_color = true;
-                if let Some(ccolor) = cell.style.fg.into() {
-                    style.fg = cell.style.fg;
+                if let Some(ccolor) = cell.fg.into() {
+                    fg = cell.fg;
                     curses_style.fg = ccolor;
                 } else {
-                    style.fg = Color::White;
+                    fg = Color::White;
                     curses_style.fg = easycurses::Color::White;
                 }
             };
-            if cell.style.bg != style.bg {
+            if cell.bg != bg {
                 update_color = true;
-                if let Some(ccolor) = cell.style.bg.into() {
-                    style.bg = cell.style.bg;
+                if let Some(ccolor) = cell.bg.into() {
+                    bg = cell.bg;
                     curses_style.bg = ccolor;
                 } else {
-                    style.bg = Color::Black;
+                    bg = Color::Black;
                     curses_style.bg = easycurses::Color::Black;
                 }
             };
@@ -107,11 +104,11 @@ impl Backend for CursesBackend {
         Ok(())
     }
     fn get_cursor(&mut self) -> io::Result<(u16, u16)> {
-        let (x, y) = self.curses.get_cursor_rc();
+        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(x), i32::from(y));
+        self.curses.move_rc(i32::from(y), i32::from(x));
         Ok(())
     }
     fn clear(&mut self) -> io::Result<()> {
@@ -151,18 +148,18 @@ fn draw(curses: &mut easycurses::EasyCurses, symbol: &str) {
             line::HORIZONTAL_UP => pancurses::ACS_BTEE(),
             block::FULL => pancurses::ACS_BLOCK(),
             block::SEVEN_EIGHTHS => pancurses::ACS_BLOCK(),
-            block::THREE_QUATERS => 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_QUATER => ' ' as chtype,
+            block::ONE_QUARTER => ' ' as chtype,
             block::ONE_EIGHTH => ' ' as chtype,
             bar::SEVEN_EIGHTHS => pancurses::ACS_BLOCK(),
-            bar::THREE_QUATERS => 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_QUATER => pancurses::ACS_S9(),
+            bar::ONE_QUARTER => pancurses::ACS_S9(),
             bar::ONE_EIGHTH => pancurses::ACS_S9(),
             DOT => pancurses::ACS_BULLET(),
             unicode_char => {
@@ -187,16 +184,16 @@ fn draw(curses: &mut easycurses::EasyCurses, symbol: &str) {
     for grapheme in symbol.graphemes(true) {
         let ch = match grapheme {
             block::SEVEN_EIGHTHS => block::FULL,
-            block::THREE_QUATERS => block::FULL,
+            block::THREE_QUARTERS => block::FULL,
             block::FIVE_EIGHTHS => block::HALF,
             block::THREE_EIGHTHS => block::HALF,
-            block::ONE_QUATER => block::HALF,
+            block::ONE_QUARTER => block::HALF,
             block::ONE_EIGHTH => " ",
             bar::SEVEN_EIGHTHS => bar::FULL,
-            bar::THREE_QUATERS => bar::FULL,
+            bar::THREE_QUARTERS => bar::FULL,
             bar::FIVE_EIGHTHS => bar::HALF,
             bar::THREE_EIGHTHS => bar::HALF,
-            bar::ONE_QUATER => bar::HALF,
+            bar::ONE_QUARTER => bar::HALF,
             bar::ONE_EIGHTH => " ",
             ch => ch,
         };

src/backend/rustbox.rs

@@ -1,18 +1,18 @@
-use log::debug;
+use crate::{
+    backend::Backend,
+    buffer::Cell,
+    layout::Rect,
+    style::{Color, Modifier},
+};
 use std::io;
 
-use super::Backend;
-use crate::buffer::Cell;
-use crate::layout::Rect;
-use crate::style::{Color, Modifier};
-
 pub struct RustboxBackend {
     rustbox: rustbox::RustBox,
 }
 
 impl RustboxBackend {
     pub fn new() -> Result<RustboxBackend, rustbox::InitError> {
-        let rustbox = r#try!(rustbox::RustBox::init(Default::default()));
+        let rustbox = rustbox::RustBox::init(Default::default())?;
         Ok(RustboxBackend { rustbox })
     }
 
@@ -30,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> {

src/backend/termion.rs

@@ -1,12 +1,13 @@
-use log::debug;
-use std::fmt;
-use std::io;
-use std::io::Write;
-
 use super::Backend;
-use crate::buffer::Cell;
-use crate::layout::Rect;
-use crate::style;
+use crate::{
+    buffer::Cell,
+    layout::Rect,
+    style::{Color, Modifier},
+};
+use std::{
+    fmt,
+    io::{self, Write},
+};
 
 pub struct TermionBackend<W>
 where
@@ -78,57 +79,51 @@ where
         use std::fmt::Write;
 
         let mut string = String::with_capacity(content.size_hint().0 * 3);
-        let mut style = 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 || inst == 0 {
+            // 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();
-                inst += 1;
             }
-            last_x = x;
-            last_y = y;
-            if cell.style.modifier != style.modifier {
+            last_pos = Some((x, y));
+            if cell.modifier != modifier {
                 write!(
                     string,
                     "{}",
                     ModifierDiff {
-                        from: style.modifier,
-                        to: cell.style.modifier
+                        from: modifier,
+                        to: cell.modifier
                     }
                 )
                 .unwrap();
-                style.modifier = cell.style.modifier;
-                inst += 1;
+                modifier = cell.modifier;
             }
-            if cell.style.fg != style.fg {
-                write!(string, "{}", Fg(cell.style.fg)).unwrap();
-                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 {
-                write!(string, "{}", Bg(cell.style.bg)).unwrap();
-                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,
-            Fg(style::Color::Reset),
-            Bg(style::Color::Reset),
+            Fg(Color::Reset),
+            Bg(Color::Reset),
             termion::style::Reset,
         )
     }
 
     /// Return the size of the terminal
     fn size(&self) -> io::Result<Rect> {
-        let terminal = r#try!(termion::terminal_size());
+        let terminal = termion::terminal_size()?;
         Ok(Rect::new(0, 0, terminal.0, terminal.1))
     }
 
@@ -137,64 +132,64 @@ where
     }
 }
 
-struct Fg(style::Color);
+struct Fg(Color);
 
-struct Bg(style::Color);
+struct Bg(Color);
 
 struct ModifierDiff {
-    from: style::Modifier,
-    to: style::Modifier,
+    from: Modifier,
+    to: Modifier,
 }
 
 impl fmt::Display for Fg {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        use termion::color::Color;
+        use termion::color::Color as TermionColor;
         match self.0 {
-            style::Color::Reset => termion::color::Reset.write_fg(f),
-            style::Color::Black => termion::color::Black.write_fg(f),
-            style::Color::Red => termion::color::Red.write_fg(f),
-            style::Color::Green => termion::color::Green.write_fg(f),
-            style::Color::Yellow => termion::color::Yellow.write_fg(f),
-            style::Color::Blue => termion::color::Blue.write_fg(f),
-            style::Color::Magenta => termion::color::Magenta.write_fg(f),
-            style::Color::Cyan => termion::color::Cyan.write_fg(f),
-            style::Color::Gray => termion::color::White.write_fg(f),
-            style::Color::DarkGray => termion::color::LightBlack.write_fg(f),
-            style::Color::LightRed => termion::color::LightRed.write_fg(f),
-            style::Color::LightGreen => termion::color::LightGreen.write_fg(f),
-            style::Color::LightBlue => termion::color::LightBlue.write_fg(f),
-            style::Color::LightYellow => termion::color::LightYellow.write_fg(f),
-            style::Color::LightMagenta => termion::color::LightMagenta.write_fg(f),
-            style::Color::LightCyan => termion::color::LightCyan.write_fg(f),
-            style::Color::White => termion::color::LightWhite.write_fg(f),
-            style::Color::Indexed(i) => termion::color::AnsiValue(i).write_fg(f),
-            style::Color::Rgb(r, g, b) => termion::color::Rgb(r, g, b).write_fg(f),
+            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),
         }
     }
 }
 impl fmt::Display for Bg {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        use termion::color::Color;
+        use termion::color::Color as TermionColor;
         match self.0 {
-            style::Color::Reset => termion::color::Reset.write_bg(f),
-            style::Color::Black => termion::color::Black.write_bg(f),
-            style::Color::Red => termion::color::Red.write_bg(f),
-            style::Color::Green => termion::color::Green.write_bg(f),
-            style::Color::Yellow => termion::color::Yellow.write_bg(f),
-            style::Color::Blue => termion::color::Blue.write_bg(f),
-            style::Color::Magenta => termion::color::Magenta.write_bg(f),
-            style::Color::Cyan => termion::color::Cyan.write_bg(f),
-            style::Color::Gray => termion::color::White.write_bg(f),
-            style::Color::DarkGray => termion::color::LightBlack.write_bg(f),
-            style::Color::LightRed => termion::color::LightRed.write_bg(f),
-            style::Color::LightGreen => termion::color::LightGreen.write_bg(f),
-            style::Color::LightBlue => termion::color::LightBlue.write_bg(f),
-            style::Color::LightYellow => termion::color::LightYellow.write_bg(f),
-            style::Color::LightMagenta => termion::color::LightMagenta.write_bg(f),
-            style::Color::LightCyan => termion::color::LightCyan.write_bg(f),
-            style::Color::White => termion::color::LightWhite.write_bg(f),
-            style::Color::Indexed(i) => termion::color::AnsiValue(i).write_bg(f),
-            style::Color::Rgb(r, g, b) => termion::color::Rgb(r, g, b).write_bg(f),
+            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),
         }
     }
 }
@@ -202,63 +197,61 @@ impl fmt::Display for Bg {
 impl fmt::Display for ModifierDiff {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let remove = self.from - self.to;
-        if remove.contains(style::Modifier::REVERSED) {
+        if remove.contains(Modifier::REVERSED) {
             write!(f, "{}", termion::style::NoInvert)?;
         }
-        if remove.contains(style::Modifier::BOLD) {
+        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(style::Modifier::DIM) {
+            if self.to.contains(Modifier::DIM) {
                 write!(f, "{}", termion::style::Faint)?;
             }
         }
-        if remove.contains(style::Modifier::ITALIC) {
+        if remove.contains(Modifier::ITALIC) {
             write!(f, "{}", termion::style::NoItalic)?;
         }
-        if remove.contains(style::Modifier::UNDERLINED) {
+        if remove.contains(Modifier::UNDERLINED) {
             write!(f, "{}", termion::style::NoUnderline)?;
         }
-        if remove.contains(style::Modifier::DIM) {
+        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(style::Modifier::BOLD) {
+            if self.to.contains(Modifier::BOLD) {
                 write!(f, "{}", termion::style::Bold)?;
             }
         }
-        if remove.contains(style::Modifier::CROSSED_OUT) {
+        if remove.contains(Modifier::CROSSED_OUT) {
             write!(f, "{}", termion::style::NoCrossedOut)?;
         }
-        if remove.contains(style::Modifier::SLOW_BLINK)
-            || remove.contains(style::Modifier::RAPID_BLINK)
-        {
+        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(style::Modifier::REVERSED) {
+        if add.contains(Modifier::REVERSED) {
             write!(f, "{}", termion::style::Invert)?;
         }
-        if add.contains(style::Modifier::BOLD) {
+        if add.contains(Modifier::BOLD) {
             write!(f, "{}", termion::style::Bold)?;
         }
-        if add.contains(style::Modifier::ITALIC) {
+        if add.contains(Modifier::ITALIC) {
             write!(f, "{}", termion::style::Italic)?;
         }
-        if add.contains(style::Modifier::UNDERLINED) {
+        if add.contains(Modifier::UNDERLINED) {
             write!(f, "{}", termion::style::Underline)?;
         }
-        if add.contains(style::Modifier::DIM) {
+        if add.contains(Modifier::DIM) {
             write!(f, "{}", termion::style::Faint)?;
         }
-        if add.contains(style::Modifier::CROSSED_OUT) {
+        if add.contains(Modifier::CROSSED_OUT) {
             write!(f, "{}", termion::style::CrossedOut)?;
         }
-        if add.contains(style::Modifier::SLOW_BLINK) || add.contains(style::Modifier::RAPID_BLINK) {
+        if add.contains(Modifier::SLOW_BLINK) || add.contains(Modifier::RAPID_BLINK) {
             write!(f, "{}", termion::style::Blink)?;
         }
 

src/backend/test.rs

@@ -1,8 +1,12 @@
-use crate::backend::Backend;
-use crate::buffer::{Buffer, Cell};
-use crate::layout::Rect;
-use std::io;
+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,
@@ -12,6 +16,35 @@ pub struct TestBackend {
     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 {
@@ -26,6 +59,50 @@ impl TestBackend {
     pub fn buffer(&self) -> &Buffer {
         &self.buffer
     }
+
+    pub fn resize(&mut self, width: u16, height: u16) {
+        self.buffer.resize(Rect::new(0, 0, width, height));
+        self.width = width;
+        self.height = height;
+    }
+
+    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 {
@@ -35,32 +112,38 @@ impl Backend for TestBackend {
     {
         for (x, y, c) in content {
             let cell = self.buffer.get_mut(x, y);
-            cell.symbol = c.symbol.clone();
-            cell.style = c.style;
+            *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,18 +1,19 @@
+use crate::{
+    layout::Rect,
+    style::{Color, Modifier, Style},
+    text::{Span, Spans},
+};
 use std::cmp::min;
-use std::fmt;
-use std::usize;
-
 use unicode_segmentation::UnicodeSegmentation;
 use unicode_width::UnicodeWidthStr;
 
-use crate::layout::Rect;
-use crate::style::{Color, Modifier, Style};
-
 /// 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 {
@@ -29,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();
     }
 }
 
@@ -59,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(),
         }
     }
 }
@@ -78,23 +92,20 @@ impl Default for 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::empty()
-///     }});
+///     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(Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct Buffer {
     /// The area represented by this buffer
     pub area: Rect,
@@ -112,49 +123,6 @@ impl Default for Buffer {
     }
 }
 
-impl fmt::Debug for Buffer {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        writeln!(f, "Buffer: {:?}", self.area)?;
-        f.write_str("Content (quoted lines):\n")?;
-        for cells in self.content.chunks(self.area.width as usize) {
-            let mut line = String::new();
-            let mut overwritten = vec![];
-            let mut skip: usize = 0;
-            for (x, c) in cells.iter().enumerate() {
-                if skip == 0 {
-                    line.push_str(&c.symbol);
-                } else {
-                    overwritten.push((x, &c.symbol))
-                }
-                skip = std::cmp::max(skip, c.symbol.width()).saturating_sub(1);
-            }
-            f.write_fmt(format_args!("{:?},", line))?;
-            if !overwritten.is_empty() {
-                f.write_fmt(format_args!(
-                    " Hidden by multi-width symbols: {:?}",
-                    overwritten
-                ))?;
-            }
-            f.write_str("\n")?;
-        }
-        f.write_str("Style:\n")?;
-        for cells in self.content.chunks(self.area.width as usize) {
-            f.write_str("|")?;
-            for cell in cells {
-                write!(
-                    f,
-                    "{} {} {}|",
-                    cell.style.fg.code(),
-                    cell.style.bg.code(),
-                    cell.style.modifier.code()
-                )?;
-            }
-            f.write_str("\n")?;
-        }
-        Ok(())
-    }
-}
-
 impl Buffer {
     /// Returns a Buffer with all cells set to the default one
     pub fn empty(area: Rect) -> Buffer {
@@ -178,9 +146,11 @@ impl Buffer {
         S: AsRef<str>,
     {
         let height = lines.len() as u16;
-        let width = lines.iter().fold(0, |acc, item| {
-            std::cmp::max(acc, item.as_ref().width() as u16)
-        });
+        let 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,
@@ -307,7 +277,14 @@ 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, width: 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>,
     {
@@ -317,6 +294,9 @@ impl Buffer {
         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) {
@@ -332,6 +312,52 @@ impl Buffer {
             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);
+            }
+        }
     }
 
     /// Resize the buffer so that the mapped area matches the given area and that the buffer
@@ -506,6 +532,22 @@ mod tests {
         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);
@@ -520,12 +562,8 @@ mod tests {
 
     #[test]
     fn buffer_with_lines() {
-        let buffer = Buffer::with_lines(vec![
-            "┌────────┐",
-            "│コンピュ│",
-            "│ーa 上で│",
-            "└────────┘",
-        ]);
+        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);
@@ -619,11 +657,7 @@ mod tests {
         let diff = prev.diff(&next);
         assert_eq!(
             diff,
-            vec![
-                (1, 0, &cell("─")),
-                (2, 0, &cell("称")),
-                (4, 0, &cell("号")),
-            ]
+            vec![(1, 0, &cell("─")), (2, 0, &cell("称")), (4, 0, &cell("号")),]
         );
     }
 

src/layout.rs

@@ -30,6 +30,27 @@ pub enum Constraint {
     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,
@@ -37,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>,
 }
 
@@ -53,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(),
         }
     }
@@ -69,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
     }
 
@@ -84,70 +120,66 @@ impl Layout {
     /// # Examples
     /// ```
     /// # 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
-    ///               }
-    ///           ]
-    ///       );
-    /// # }
-    ///
+    /// 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()
         })
     }
@@ -167,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));
@@ -177,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()));
@@ -367,7 +401,7 @@ impl Rect {
     }
 
     pub fn right(self) -> u16 {
-        self.x + self.width
+        self.x.saturating_add(self.width)
     }
 
     pub fn top(self) -> u16 {
@@ -375,18 +409,18 @@ impl Rect {
     }
 
     pub fn bottom(self) -> u16 {
-        self.y + self.height
+        self.y.saturating_add(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,
             }
         }
     }
@@ -425,46 +459,76 @@ impl Rect {
     }
 }
 
-#[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
+#[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));
     }
 
-    // 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);
+    #[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);
     }
 
-    // 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);
+    #[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

@@ -9,21 +9,18 @@
 //!
 //! ```toml
 //! [dependencies]
-//! tui = "0.5"
+//! tui = "0.14"
 //! termion = "1.5"
 //! ```
 //!
-//! The crate is using the `termion` backend by default but if for some reason you might want to use
-//! the `rustbox` backend instead, you need the to replace your dependency specification by:
+//! 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:
 //!
 //! ```toml
 //! [dependencies]
-//! rustbox = "0.11"
-//!
-//! [dependencies.tui]
-//! version = "0.5"
-//! default-features = false
-//! features = ['rustbox']
+//! crossterm = "0.19"
+//! tui = { version = "0.14", default-features = false, features = ['crossterm'] }
 //! ```
 //!
 //! The same logic applies for all other available backends.
@@ -48,16 +45,18 @@
 //! }
 //! ```
 //!
-//! If you had previously chosen `rustbox` as a backend, the terminal can be created in a similar
+//! 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::RustboxBackend;
+//! use tui::backend::CrosstermBackend;
 //!
 //! fn main() -> Result<(), io::Error> {
-//!     let backend = RustboxBackend::new()?;
-//!     let mut terminal = Terminal::new(backend);
+//!     let stdout = io::stdout();
+//!     let backend = CrosstermBackend::new(stdout);
+//!     let mut terminal = Terminal::new(backend)?;
 //!     Ok(())
 //! }
 //! ```
@@ -67,13 +66,13 @@
 //!
 //! ## 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.
+//! 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:
 //!
@@ -89,13 +88,14 @@
 //!     let stdout = io::stdout().into_raw_mode()?;
 //!     let backend = TermionBackend::new(stdout);
 //!     let mut terminal = Terminal::new(backend)?;
-//!     terminal.draw(|mut f| {
+//!     terminal.draw(|f| {
 //!         let size = f.size();
-//!         Block::default()
+//!         let block = Block::default()
 //!             .title("Block")
-//!             .borders(Borders::ALL)
-//!             .render(&mut f, size);
-//!     })
+//!             .borders(Borders::ALL);
+//!         f.render_widget(block, size);
+//!     })?;
+//!     Ok(())
 //! }
 //! ```
 //!
@@ -117,7 +117,7 @@
 //!     let stdout = io::stdout().into_raw_mode()?;
 //!     let backend = TermionBackend::new(stdout);
 //!     let mut terminal = Terminal::new(backend)?;
-//!     terminal.draw(|mut f| {
+//!     terminal.draw(|f| {
 //!         let chunks = Layout::default()
 //!             .direction(Direction::Vertical)
 //!             .margin(1)
@@ -129,15 +129,16 @@
 //!                 ].as_ref()
 //!             )
 //!             .split(f.size());
-//!         Block::default()
+//!         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]);
+//!     })?;
+//!     Ok(())
 //! }
 //! ```
 //!
@@ -152,6 +153,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,6 +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,
@@ -23,35 +26,19 @@ pub enum Color {
     Indexed(u8),
 }
 
-impl Color {
-    /// Returns a short code associated with the color, used for debug purpose
-    /// only
-    pub(crate) fn code(self) -> &'static str {
-        match self {
-            Color::Reset => "X",
-            Color::Black => "b",
-            Color::Red => "r",
-            Color::Green => "c",
-            Color::Yellow => "y",
-            Color::Blue => "b",
-            Color::Magenta => "m",
-            Color::Cyan => "c",
-            Color::Gray => "w",
-            Color::DarkGray => "B",
-            Color::LightRed => "R",
-            Color::LightGreen => "G",
-            Color::LightYellow => "Y",
-            Color::LightBlue => "B",
-            Color::LightMagenta => "M",
-            Color::LightCyan => "C",
-            Color::White => "W",
-            Color::Indexed(_) => "i",
-            Color::Rgb(_, _, _) => "o",
-        }
-    }
-}
-
 bitflags! {
+    /// 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;
@@ -65,80 +52,230 @@ bitflags! {
     }
 }
 
-impl Modifier {
-    /// Returns a short code associated with the color, used for debug purpose
-    /// only
-    pub(crate) fn code(self) -> String {
-        use std::fmt::Write;
-
-        let mut result = String::new();
-
-        if self.contains(Modifier::BOLD) {
-            write!(result, "BO").unwrap();
-        }
-        if self.contains(Modifier::DIM) {
-            write!(result, "DI").unwrap();
-        }
-        if self.contains(Modifier::ITALIC) {
-            write!(result, "IT").unwrap();
-        }
-        if self.contains(Modifier::UNDERLINED) {
-            write!(result, "UN").unwrap();
-        }
-        if self.contains(Modifier::SLOW_BLINK) {
-            write!(result, "SL").unwrap();
-        }
-        if self.contains(Modifier::RAPID_BLINK) {
-            write!(result, "RA").unwrap();
-        }
-        if self.contains(Modifier::REVERSED) {
-            write!(result, "RE").unwrap();
-        }
-        if self.contains(Modifier::HIDDEN) {
-            write!(result, "HI").unwrap();
-        }
-        if self.contains(Modifier::CROSSED_OUT) {
-            write!(result, "CR").unwrap();
-        }
-
-        result
-    }
-}
-
+/// Style let you control the main characteristics of the displayed elements.
+///
+/// ```rust
+/// # use tui::style::{Color, Modifier, Style};
+/// Style::default()
+///     .fg(Color::Black)
+///     .bg(Color::Green)
+///     .add_modifier(Modifier::ITALIC | Modifier::BOLD);
+/// ```
+///
+/// It represents an incremental change. If you apply the styles S1, S2, S3 to a cell of the
+/// terminal buffer, the style of this cell will be the result of the merge of S1, S2 and S3, not
+/// just S3.
+///
+/// ```rust
+/// # use tui::style::{Color, Modifier, Style};
+/// # use tui::buffer::Buffer;
+/// # use tui::layout::Rect;
+/// let styles = [
+///     Style::default().fg(Color::Blue).add_modifier(Modifier::BOLD | Modifier::ITALIC),
+///     Style::default().bg(Color::Red),
+///     Style::default().fg(Color::Yellow).remove_modifier(Modifier::ITALIC),
+/// ];
+/// let mut buffer = Buffer::empty(Rect::new(0, 0, 1, 1));
+/// for style in &styles {
+///   buffer.get_mut(0, 0).set_style(*style);
+/// }
+/// assert_eq!(
+///     Style {
+///         fg: Some(Color::Yellow),
+///         bg: Some(Color::Red),
+///         add_modifier: Modifier::BOLD,
+///         sub_modifier: Modifier::empty(),
+///     },
+///     buffer.get(0, 0).style(),
+/// );
+/// ```
+///
+/// The default implementation returns a `Style` that does not modify anything. If you wish to
+/// reset all properties until that point use [`Style::reset`].
+///
+/// ```
+/// # use tui::style::{Color, Modifier, Style};
+/// # use tui::buffer::Buffer;
+/// # use tui::layout::Rect;
+/// let styles = [
+///     Style::default().fg(Color::Blue).add_modifier(Modifier::BOLD | Modifier::ITALIC),
+///     Style::reset().fg(Color::Yellow),
+/// ];
+/// let mut buffer = Buffer::empty(Rect::new(0, 0, 1, 1));
+/// for style in &styles {
+///   buffer.get_mut(0, 0).set_style(*style);
+/// }
+/// assert_eq!(
+///     Style {
+///         fg: Some(Color::Yellow),
+///         bg: Some(Color::Reset),
+///         add_modifier: Modifier::empty(),
+///         sub_modifier: Modifier::empty(),
+///     },
+///     buffer.get(0, 0).style(),
+/// );
+/// ```
 #[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::empty(),
+            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::empty();
+    /// Returns a `Style` resetting all properties.
+    pub fn reset() -> Style {
+        Style {
+            fg: Some(Color::Reset),
+            bg: Some(Color::Reset),
+            add_modifier: Modifier::empty(),
+            sub_modifier: Modifier::all(),
+        }
     }
 
+    /// 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 = color;
+        self.fg = Some(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,10 +1,41 @@
-use log::error;
+use crate::{
+    backend::Backend,
+    buffer::Buffer,
+    layout::Rect,
+    widgets::{StatefulWidget, Widget},
+};
 use std::io;
 
-use crate::backend::Backend;
-use crate::buffer::Buffer;
-use crate::layout::Rect;
-use crate::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)]
@@ -20,8 +51,8 @@ where
     current: usize,
     /// Whether the cursor is currently hidden
     hidden_cursor: bool,
-    /// Terminal size used for rendering.
-    known_size: Rect,
+    /// Viewport
+    viewport: Viewport,
 }
 
 /// Represents a consistent terminal interface for rendering.
@@ -30,6 +61,12 @@ 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>
@@ -38,16 +75,85 @@ where
 {
     /// Terminal size, guaranteed not to change when rendering.
     pub fn size(&self) -> Rect {
-        self.terminal.known_size
+        self.terminal.viewport.area
     }
 
-    /// Calls the draw method of a given widget on the current buffer
-    pub fn render<W>(&mut self, widget: &mut W, area: Rect)
+    /// 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));
+    }
+}
+
+/// CompletedFrame represents the state of the terminal after all changes performed in the last
+/// [`Terminal::draw`] call have been applied. Therefore, it is only valid until the next call to
+/// [`Terminal::draw`].
+pub struct CompletedFrame<'a> {
+    pub buffer: &'a Buffer,
+    pub area: Rect,
 }
 
 impl<B> Drop for Terminal<B>
@@ -58,7 +164,7 @@ where
         // Attempt to restore the cursor state
         if self.hidden_cursor {
             if let Err(err) = self.show_cursor() {
-                error!("Failed to show the cursor: {}", err);
+                eprintln!("Failed to show the cursor: {}", err);
             }
         }
     }
@@ -68,22 +174,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) -> 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,
-            known_size: size,
+            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 {
@@ -112,43 +237,60 @@ where
     /// This leads to a full clear of the screen.
     pub fn resize(&mut self, area: Rect) -> io::Result<()> {
         self.buffers[self.current].resize(area);
-        self.buffers[1 - self.current].reset();
         self.buffers[1 - self.current].resize(area);
-        self.known_size = area;
-        self.backend.clear()
+        self.viewport.area = area;
+        self.clear()
     }
 
     /// Queries the backend for size and resizes if it doesn't match the previous size.
     pub fn autoresize(&mut self) -> io::Result<()> {
-        let size = self.size()?;
-        if self.known_size != size {
-            self.resize(size)?;
-        }
+        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<()>
+    pub fn draw<F>(&mut self, f: F) -> io::Result<CompletedFrame>
     where
-        F: FnOnce(Frame<B>),
+        F: FnOnce(&mut Frame<B>),
     {
         // Autoresize - otherwise we get glitches if shrinking or potential desync between widgets
         // and the terminal (if growing), which may OOB.
         self.autoresize()?;
 
-        f(self.get_frame());
+        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;
 
         // Flush
         self.backend.flush()?;
-        Ok(())
+        Ok(CompletedFrame {
+            buffer: &self.buffers[1 - self.current],
+            area: self.viewport.area,
+        })
     }
 
     pub fn hide_cursor(&mut self) -> io::Result<()> {
@@ -156,20 +298,29 @@ where
         self.hidden_cursor = true;
         Ok(())
     }
+
     pub fn show_cursor(&mut self) -> io::Result<()> {
         self.backend.show_cursor()?;
         self.hidden_cursor = false;
         Ok(())
     }
+
     pub fn get_cursor(&mut self) -> io::Result<(u16, u16)> {
         self.backend.get_cursor()
     }
+
     pub fn set_cursor(&mut self, x: u16, y: u16) -> io::Result<()> {
         self.backend.set_cursor(x, y)
     }
+
+    /// Clear the terminal and force a full redraw on the next draw call.
     pub fn clear(&mut self) -> io::Result<()> {
-        self.backend.clear()
+        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,434 @@
+//! 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;
+
+/// 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")
+    }
+}
+
+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
+        })
+    }
+}
+
+/// 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);
+    }
+}

src/widgets/barchart.rs

@@ -1,13 +1,13 @@
-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 crate::buffer::Buffer;
-use crate::layout::Rect;
-use crate::style::Style;
-use crate::symbols::bar;
-use crate::widgets::{Block, Widget};
-
 /// Display multiple bars in a single widgets
 ///
 /// # Examples
@@ -15,18 +15,17 @@ use crate::widgets::{Block, Widget};
 /// ```
 /// # 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>>,
@@ -34,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
@@ -56,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(),
@@ -79,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
@@ -107,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,
         };
@@ -120,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(),
@@ -133,20 +154,25 @@ 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 {
@@ -155,7 +181,7 @@ impl<'a> Widget for BarChart<'a> {
                         chart_area.top() + j,
                     )
                     .set_symbol(symbol)
-                    .set_style(self.style);
+                    .set_style(self.bar_style);
                 }
 
                 if d.1 > 8 {

src/widgets/block.rs

@@ -1,8 +1,30 @@
-use crate::buffer::Buffer;
-use crate::layout::Rect;
-use crate::style::Style;
-use crate::symbols::line;
-use crate::widgets::{Borders, Widget};
+use crate::{
+    buffer::Buffer,
+    layout::Rect,
+    style::Style,
+    symbols::line,
+    text::{Span, Spans},
+    widgets::{Borders, Widget},
+};
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+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,27 +32,26 @@ use crate::widgets::{Borders, Widget};
 /// # Examples
 ///
 /// ```
-/// # 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, PartialEq)]
 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,
 }
@@ -39,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
     }
 
@@ -73,50 +104,52 @@ 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 {
-            return Rect::default();
-        }
         let mut inner = area;
         if self.borders.intersects(Borders::LEFT) {
-            inner.x += 1;
-            inner.width -= 1;
+            inner.x = inner.x.saturating_add(1).min(inner.right());
+            inner.width = inner.width.saturating_sub(1);
         }
         if self.borders.intersects(Borders::TOP) || self.title.is_some() {
-            inner.y += 1;
-            inner.height -= 1;
+            inner.y = inner.y.saturating_add(1).min(inner.bottom());
+            inner.height = inner.height.saturating_sub(1);
         }
         if self.borders.intersects(Borders::RIGHT) {
-            inner.width -= 1;
+            inner.width = inner.width.saturating_sub(1);
         }
         if self.borders.intersects(Borders::BOTTOM) {
-            inner.height -= 1;
+            inner.height = inner.height.saturating_sub(1);
         }
         inner
     }
 }
 
 impl<'a> Widget for Block<'a> {
-    fn draw(&mut self, area: Rect, buf: &mut Buffer) {
-        if area.width < 2 || area.height < 2 {
+    fn render(self, area: Rect, buf: &mut Buffer) {
+        if area.area() == 0 {
             return;
         }
-
-        self.background(area, buf, self.style.bg);
+        buf.set_style(area, self.style);
+        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);
             }
         }
@@ -124,7 +157,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);
             }
         }
@@ -132,54 +165,347 @@ 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);
             }
         }
 
         // Corners
-        if self.borders.contains(Borders::LEFT | Borders::TOP) {
-            buf.get_mut(area.left(), area.top())
-                .set_symbol(line::TOP_LEFT)
+        if self.borders.contains(Borders::RIGHT | Borders::BOTTOM) {
+            buf.get_mut(area.right() - 1, area.bottom() - 1)
+                .set_symbol(symbols.bottom_right)
                 .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)
+        if self.borders.contains(Borders::LEFT | Borders::TOP) {
+            buf.get_mut(area.left(), area.top())
+                .set_symbol(symbols.top_left)
                 .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.saturating_sub(lx).saturating_sub(rx);
+            buf.set_spans(area.left() + lx, area.top(), &title, width);
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::layout::Rect;
+
+    #[test]
+    fn inner_takes_into_account_the_borders() {
+        // No borders
+        assert_eq!(
+            Block::default().inner(Rect::default()),
+            Rect {
+                x: 0,
+                y: 0,
+                width: 0,
+                height: 0
+            },
+            "no borders, width=0, height=0"
+        );
+        assert_eq!(
+            Block::default().inner(Rect {
+                x: 0,
+                y: 0,
+                width: 1,
+                height: 1
+            }),
+            Rect {
+                x: 0,
+                y: 0,
+                width: 1,
+                height: 1
+            },
+            "no borders, width=1, height=1"
+        );
+
+        // Left border
+        assert_eq!(
+            Block::default().borders(Borders::LEFT).inner(Rect {
+                x: 0,
+                y: 0,
+                width: 0,
+                height: 1
+            }),
+            Rect {
+                x: 0,
+                y: 0,
+                width: 0,
+                height: 1
+            },
+            "left, width=0"
+        );
+        assert_eq!(
+            Block::default().borders(Borders::LEFT).inner(Rect {
+                x: 0,
+                y: 0,
+                width: 1,
+                height: 1
+            }),
+            Rect {
+                x: 1,
+                y: 0,
+                width: 0,
+                height: 1
+            },
+            "left, width=1"
+        );
+        assert_eq!(
+            Block::default().borders(Borders::LEFT).inner(Rect {
+                x: 0,
+                y: 0,
+                width: 2,
+                height: 1
+            }),
+            Rect {
+                x: 1,
+                y: 0,
+                width: 1,
+                height: 1
+            },
+            "left, width=2"
+        );
+
+        // Top border
+        assert_eq!(
+            Block::default().borders(Borders::TOP).inner(Rect {
+                x: 0,
+                y: 0,
+                width: 1,
+                height: 0
+            }),
+            Rect {
+                x: 0,
+                y: 0,
+                width: 1,
+                height: 0
+            },
+            "top, height=0"
+        );
+        assert_eq!(
+            Block::default().borders(Borders::TOP).inner(Rect {
+                x: 0,
+                y: 0,
+                width: 1,
+                height: 1
+            }),
+            Rect {
+                x: 0,
+                y: 1,
+                width: 1,
+                height: 0
+            },
+            "top, height=1"
+        );
+        assert_eq!(
+            Block::default().borders(Borders::TOP).inner(Rect {
+                x: 0,
+                y: 0,
+                width: 1,
+                height: 2
+            }),
+            Rect {
+                x: 0,
+                y: 1,
+                width: 1,
+                height: 1
+            },
+            "top, height=2"
+        );
+
+        // Right border
+        assert_eq!(
+            Block::default().borders(Borders::RIGHT).inner(Rect {
+                x: 0,
+                y: 0,
+                width: 0,
+                height: 1
+            }),
+            Rect {
+                x: 0,
+                y: 0,
+                width: 0,
+                height: 1
+            },
+            "right, width=0"
+        );
+        assert_eq!(
+            Block::default().borders(Borders::RIGHT).inner(Rect {
+                x: 0,
+                y: 0,
+                width: 1,
+                height: 1
+            }),
+            Rect {
+                x: 0,
+                y: 0,
+                width: 0,
+                height: 1
+            },
+            "right, width=1"
+        );
+        assert_eq!(
+            Block::default().borders(Borders::RIGHT).inner(Rect {
+                x: 0,
+                y: 0,
+                width: 2,
+                height: 1
+            }),
+            Rect {
+                x: 0,
+                y: 0,
+                width: 1,
+                height: 1
+            },
+            "right, width=2"
+        );
+
+        // Bottom border
+        assert_eq!(
+            Block::default().borders(Borders::BOTTOM).inner(Rect {
+                x: 0,
+                y: 0,
+                width: 1,
+                height: 0
+            }),
+            Rect {
+                x: 0,
+                y: 0,
+                width: 1,
+                height: 0
+            },
+            "bottom, height=0"
+        );
+        assert_eq!(
+            Block::default().borders(Borders::BOTTOM).inner(Rect {
+                x: 0,
+                y: 0,
+                width: 1,
+                height: 1
+            }),
+            Rect {
+                x: 0,
+                y: 0,
+                width: 1,
+                height: 0
+            },
+            "bottom, height=1"
+        );
+        assert_eq!(
+            Block::default().borders(Borders::BOTTOM).inner(Rect {
+                x: 0,
+                y: 0,
+                width: 1,
+                height: 2
+            }),
+            Rect {
+                x: 0,
+                y: 0,
+                width: 1,
+                height: 1
+            },
+            "bottom, height=2"
+        );
+
+        // All borders
+        assert_eq!(
+            Block::default()
+                .borders(Borders::ALL)
+                .inner(Rect::default()),
+            Rect {
+                x: 0,
+                y: 0,
+                width: 0,
+                height: 0
+            },
+            "all borders, width=0, height=0"
+        );
+        assert_eq!(
+            Block::default().borders(Borders::ALL).inner(Rect {
+                x: 0,
+                y: 0,
+                width: 1,
+                height: 1
+            }),
+            Rect {
+                x: 1,
+                y: 1,
+                width: 0,
+                height: 0,
+            },
+            "all borders, width=1, height=1"
+        );
+        assert_eq!(
+            Block::default().borders(Borders::ALL).inner(Rect {
+                x: 0,
+                y: 0,
+                width: 2,
+                height: 2,
+            }),
+            Rect {
+                x: 1,
+                y: 1,
+                width: 0,
+                height: 0,
+            },
+            "all borders, width=2, height=2"
+        );
+        assert_eq!(
+            Block::default().borders(Borders::ALL).inner(Rect {
+                x: 0,
+                y: 0,
+                width: 3,
+                height: 3,
+            }),
+            Rect {
+                x: 1,
+                y: 1,
+                width: 1,
+                height: 1,
+            },
+            "all borders, width=3, height=3"
+        );
+    }
+
+    #[test]
+    fn inner_takes_into_account_the_title() {
+        assert_eq!(
+            Block::default().title("Test").inner(Rect {
+                x: 0,
+                y: 0,
+                width: 0,
+                height: 1,
+            }),
+            Rect {
+                x: 0,
+                y: 1,
+                width: 0,
+                height: 0,
+            },
+        );
+    }
+}

src/widgets/canvas/line.rs

@@ -1,7 +1,10 @@
-use super::Shape;
-use crate::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,63 +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 crate::style::Color;
-use crate::widgets::canvas::points::PointsIterator;
-use crate::widgets::canvas::world::{WORLD_HIGH_RESOLUTION, WORLD_LOW_RESOLUTION};
-use crate::widgets::canvas::Shape;
+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

@@ -9,29 +9,22 @@ pub use self::map::{Map, MapResolution};
 pub use self::points::Points;
 pub use self::rectangle::Rectangle;
 
-use crate::buffer::Buffer;
-use crate::layout::Rect;
-use crate::style::{Color, Style};
-use crate::widgets::{Block, Widget};
-
-pub const DOTS: [[u16; 2]; 4] = [
-    [0x0001, 0x0008],
-    [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,
@@ -39,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 {
@@ -66,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.
@@ -138,7 +314,6 @@ impl<'a> Context<'a> {
 /// # 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])
@@ -157,16 +332,13 @@ impl<'a> Context<'a> {
 ///             color: Color::White,
 ///         });
 ///         ctx.draw(&Rectangle {
-///             rect: Rect {
-///                 x: 10,
-///                 y: 20,
-///                 width: 10,
-///                 height: 10,
-///             },
+///             x: 10.0,
+///             y: 20.0,
+///             width: 10.0,
+///             height: 10.0,
 ///             color: Color::Red
 ///         });
 ///     });
-/// # }
 /// ```
 pub struct Canvas<'a, F>
 where
@@ -177,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>
@@ -190,6 +363,7 @@ where
             y_bounds: [0.0, 0.0],
             painter: None,
             background_color: Color::Reset,
+            marker: symbols::Marker::Braille,
         }
     }
 }
@@ -202,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
@@ -221,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 crate::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

@@ -1,54 +1,52 @@
-use crate::layout::Rect;
-use crate::style::Color;
-use crate::widgets::canvas::{Line, Shape};
-use itertools::Itertools;
+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 rect: Rect,
+    pub x: f64,
+    pub y: f64,
+    pub width: f64,
+    pub height: f64,
     pub color: Color,
 }
 
-impl<'a> Shape<'a> for Rectangle {
-    fn color(&self) -> Color {
-        self.color
-    }
-
-    fn points(&'a self) -> Box<Iterator<Item = (f64, f64)> + 'a> {
-        let left_line = Line {
-            x1: f64::from(self.rect.x),
-            y1: f64::from(self.rect.y),
-            x2: f64::from(self.rect.x),
-            y2: f64::from(self.rect.y + self.rect.height),
-            color: self.color,
-        };
-        let top_line = Line {
-            x1: f64::from(self.rect.x),
-            y1: f64::from(self.rect.y + self.rect.height),
-            x2: f64::from(self.rect.x + self.rect.width),
-            y2: f64::from(self.rect.y + self.rect.height),
-            color: self.color,
-        };
-        let right_line = Line {
-            x1: f64::from(self.rect.x + self.rect.width),
-            y1: f64::from(self.rect.y),
-            x2: f64::from(self.rect.x + self.rect.width),
-            y2: f64::from(self.rect.y + self.rect.height),
-            color: self.color,
-        };
-        let bottom_line = Line {
-            x1: f64::from(self.rect.x),
-            y1: f64::from(self.rect.y),
-            x2: f64::from(self.rect.x + self.rect.width),
-            y2: f64::from(self.rect.y),
-            color: self.color,
-        };
-        Box::new(
-            left_line.into_iter().merge(
-                top_line
-                    .into_iter()
-                    .merge(right_line.into_iter().merge(bottom_line.into_iter())),
-            ),
-        )
+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 crate::buffer::Buffer;
-use crate::layout::Rect;
-use crate::style::Style;
-use crate::symbols;
-use crate::widgets::canvas::{Canvas, Points};
-use crate::widgets::{Block, Borders, Widget};
-
 /// An X or Y axis for the chart widget
-pub struct Axis<'a, L>
-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,95 +181,103 @@ impl Default for ChartLayout {
 /// # Examples
 ///
 /// ```
-/// # 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))
+///         .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))
+///         .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
     }
 
@@ -273,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() {
@@ -303,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,
@@ -336,16 +364,22 @@ 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) {
+        if area.area() == 0 {
+            return;
+        }
+        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,
         };
@@ -356,30 +390,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,
                     );
                 }
             }
@@ -391,12 +413,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);
                 }
             }
         }
@@ -425,56 +442,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);
+        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),
+                            })
+                        }
                     }
-                }
-                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);
-                }
-            }
+                })
+                .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,9 +1,11 @@
-use unicode_width::UnicodeWidthStr;
-
-use crate::buffer::Buffer;
-use crate::layout::Rect;
-use crate::style::{Color, Style};
-use crate::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.
 ///
@@ -12,18 +14,19 @@ use crate::widgets::{Block, Widget};
 /// ```
 /// # 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>>,
     ratio: f64,
-    label: Option<&'a str>,
+    label: Option<Span<'a>>,
+    use_unicode: bool,
     style: Style,
+    gauge_style: Style,
 }
 
 impl<'a> Default for Gauge<'a> {
@@ -32,7 +35,9 @@ impl<'a> Default for Gauge<'a> {
             block: None,
             ratio: 0.0,
             label: None,
-            style: Default::default(),
+            use_unicode: false,
+            style: Style::default(),
+            gauge_style: Style::default(),
         }
     }
 }
@@ -62,8 +67,11 @@ impl<'a> Gauge<'a> {
         self
     }
 
-    pub fn label(mut self, string: &'a str) -> Gauge<'a> {
-        self.label = Some(string);
+    pub fn label<T>(mut self, label: T) -> Gauge<'a>
+    where
+        T: Into<Span<'a>>,
+    {
+        self.label = Some(label.into());
         self
     }
 
@@ -71,53 +79,227 @@ impl<'a> Gauge<'a> {
         self.style = style;
         self
     }
+
+    pub fn gauge_style(mut self, style: Style) -> Gauge<'a> {
+        self.gauge_style = style;
+        self
+    }
+
+    pub fn use_unicode(mut self, unicode: bool) -> Gauge<'a> {
+        self.use_unicode = unicode;
+        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 = (f64::from(gauge_area.width) * self.ratio).round() as u16;
-        let end = gauge_area.left() + width;
+        let width = f64::from(gauge_area.width) * self.ratio;
+        //go to regular rounding behavior if we're not using unicode blocks
+        let end = gauge_area.left()
+            + if self.use_unicode {
+                width.floor() as u16
+            } else {
+                width.round() as u16
+            };
+        // 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 {
                 buf.get_mut(x, y).set_symbol(" ");
             }
 
+            //set unicode block
+            if self.use_unicode && self.ratio < 1.0 {
+                buf.get_mut(end, y)
+                    .set_symbol(get_unicode_block(width % 1.0));
+            }
+
+            let mut color_end = end;
+
             if y == center {
-                // Label
-                let precent_label = format!("{}%", (self.ratio * 100.0).round());
-                let label = self.label.unwrap_or(&precent_label);
                 let label_width = label.width() as u16;
                 let middle = (gauge_area.width - label_width) / 2 + gauge_area.left();
-                buf.set_string(middle, y, label, self.style);
+                buf.set_span(middle, y, &label, gauge_area.right() - middle);
+                if self.use_unicode && end >= middle && end < middle + label_width {
+                    color_end = gauge_area.left() + (width.round() as u16); //set color on the label to the rounded gauge level
+                }
             }
 
             // Fix colors
-            for x in gauge_area.left()..end {
+            for x in gauge_area.left()..color_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));
             }
         }
     }
 }
 
+fn get_unicode_block<'a>(frac: f64) -> &'a str {
+    match (frac * 8.0).round() as u16 {
+        //get how many eighths the fraction is closest to
+        1 => symbols::block::ONE_EIGHTH,
+        2 => symbols::block::ONE_QUARTER,
+        3 => symbols::block::THREE_EIGHTHS,
+        4 => symbols::block::HALF,
+        5 => symbols::block::FIVE_EIGHTHS,
+        6 => symbols::block::THREE_QUARTERS,
+        7 => symbols::block::SEVEN_EIGHTHS,
+        8 => symbols::block::FULL,
+        _ => " ",
+    }
+}
+
+/// 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::*;

src/widgets/list.rs

@@ -1,114 +1,65 @@
-use std::convert::AsRef;
+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 crate::buffer::Buffer;
-use crate::layout::{Corner, Rect};
-use crate::style::Style;
-use crate::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, PartialEq)]
+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,129 +68,182 @@ where
 /// # Examples
 ///
 /// ```
-/// # 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(AsRef::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,36 +1,49 @@
-use bitflags::bitflags;
-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;
+pub 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::{Cell, Row, Table, TableState};
 pub use self::tabs::Tabs;
 
-use crate::backend::Backend;
-use crate::buffer::Buffer;
-use crate::layout::Rect;
-use crate::style::{Color, Style};
-use crate::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;
@@ -47,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,13 +1,16 @@
-use either::Either;
-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 crate::buffer::Buffer;
-use crate::layout::{Alignment, Rect};
-use crate::style::Style;
-use crate::widgets::reflow::{LineComposer, LineTruncator, Styled, WordWrapper};
-use crate::widgets::{Block, Text, Widget};
-
 fn get_line_offset(line_width: u16, text_area_width: u16, alignment: Alignment) -> u16 {
     match alignment {
         Alignment::Center => (text_area_width / 2).saturating_sub(line_width / 2),
@@ -21,97 +24,122 @@ fn get_line_offset(line_width: u16, text_area_width: u16, alignment: Alignment)
 /// # Examples
 ///
 /// ```
-/// # 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, 'b, 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,
         };
@@ -120,38 +148,48 @@ where
             return;
         }
 
-        self.background(text_area, buf, self.style.bg);
-
         let style = self.style;
-        let mut styled = self.text.by_ref().flat_map(|t| match *t {
-            Text::Raw(ref d) => {
-                let data: &'t str = d; // coerce to &str
-                Either::Left(UnicodeSegmentation::graphemes(data, true).map(|g| Styled(g, style)))
-            }
-            Text::Styled(ref d, s) => {
-                let data: &'t str = d; // coerce to &str
-                Either::Right(UnicodeSegmentation::graphemes(data, true).map(move |g| Styled(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 line_composer: Box<dyn LineComposer> = if self.wrapping {
-            Box::new(WordWrapper::new(&mut styled, text_area.width))
+        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 {
-            Box::new(LineTruncator::new(&mut styled, text_area.width))
+            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_composer
         };
         let mut y = 0;
         while let Some((current_line, current_line_width)) = line_composer.next_line() {
-            if y >= self.scroll {
+            if y >= self.scroll.0 {
                 let mut x = get_line_offset(current_line_width, text_area.width, self.alignment);
-                for Styled(symbol, style) in current_line {
-                    buf.get_mut(text_area.left() + x, text_area.top() + y - self.scroll)
-                        .set_symbol(symbol)
+                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;
                 }
             }
             y += 1;
-            if y >= text_area.height + self.scroll {
+            if y >= text_area.height + self.scroll.0 {
                 break;
             }
         }

src/widgets/reflow.rs

@@ -1,42 +1,44 @@
-use crate::style::Style;
+use crate::text::StyledGrapheme;
+use unicode_segmentation::UnicodeSegmentation;
 use unicode_width::UnicodeWidthStr;
 
 const NBSP: &str = "\u{00a0}";
 
-#[derive(Copy, Clone, Debug)]
-pub struct Styled<'a>(pub &'a str, pub Style);
-
 /// A state machine to pack styled symbols into lines.
 /// Cannot implement it as Iterator since it yields slices of the internal buffer (need streaming
 /// iterators for that).
 pub trait LineComposer<'a> {
-    fn next_line(&mut self) -> Option<(&[Styled<'a>], u16)>;
+    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 Iterator<Item = Styled<'a>>,
+    symbols: &'b mut dyn Iterator<Item = StyledGrapheme<'a>>,
     max_line_width: u16,
-    current_line: Vec<Styled<'a>>,
-    next_line: Vec<Styled<'a>>,
+    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 Iterator<Item = Styled<'a>>,
+        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<(&[Styled<'a>], u16)> {
+    fn next_line(&mut self) -> Option<(&[StyledGrapheme<'a>], u16)> {
         if self.max_line_width == 0 {
             return None;
         }
@@ -46,21 +48,21 @@ impl<'a, 'b> LineComposer<'a> for WordWrapper<'a, 'b> {
         let mut current_line_width = self
             .current_line
             .iter()
-            .map(|Styled(c, _)| c.width() as u16)
+            .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 Styled(symbol, style) in &mut self.symbols {
+        for StyledGrapheme { symbol, style } in &mut self.symbols {
             symbols_exhausted = false;
-            let symbol_whitespace = symbol.chars().all(&char::is_whitespace);
+            let symbol_whitespace = symbol.chars().all(&char::is_whitespace) && symbol != NBSP;
 
             // Ignore characters wider that the total max width.
             if symbol.width() as u16 > self.max_line_width
-                // Skip leading whitespace.
-                || symbol_whitespace && symbol != "\n" && current_line_width == 0
+                // Skip leading whitespace when trim is enabled.
+                || self.trim && symbol_whitespace && symbol != "\n" && current_line_width == 0
             {
                 continue;
             }
@@ -75,12 +77,12 @@ impl<'a, 'b> LineComposer<'a> for WordWrapper<'a, 'b> {
             }
 
             // Mark the previous symbol as word end.
-            if symbol_whitespace && !prev_whitespace && symbol != NBSP {
+            if symbol_whitespace && !prev_whitespace {
                 symbols_to_last_word_end = self.current_line.len();
                 width_to_last_word_end = current_line_width;
             }
 
-            self.current_line.push(Styled(symbol, style));
+            self.current_line.push(StyledGrapheme { symbol, style });
             current_line_width += symbol.width() as u16;
 
             if current_line_width > self.max_line_width {
@@ -94,9 +96,10 @@ impl<'a, 'b> LineComposer<'a> for WordWrapper<'a, 'b> {
                 // Push the remainder to the next line but strip leading whitespace:
                 {
                     let remainder = &self.current_line[truncate_at..];
-                    if let Some(remainder_nonwhite) = remainder
-                        .iter()
-                        .position(|Styled(c, _)| !c.chars().all(&char::is_whitespace))
+                    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..]);
@@ -121,26 +124,33 @@ impl<'a, 'b> LineComposer<'a> for WordWrapper<'a, 'b> {
 
 /// A state machine that truncates overhanging lines.
 pub struct LineTruncator<'a, 'b> {
-    symbols: &'b mut Iterator<Item = Styled<'a>>,
+    symbols: &'b mut dyn Iterator<Item = StyledGrapheme<'a>>,
     max_line_width: u16,
-    current_line: Vec<Styled<'a>>,
+    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 Iterator<Item = Styled<'a>>,
+        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<(&[Styled<'a>], u16)> {
+    fn next_line(&mut self) -> Option<(&[StyledGrapheme<'a>], u16)> {
         if self.max_line_width == 0 {
             return None;
         }
@@ -150,7 +160,8 @@ impl<'a, 'b> LineComposer<'a> for LineTruncator<'a, 'b> {
 
         let mut skip_rest = false;
         let mut symbols_exhausted = true;
-        for Styled(symbol, style) in &mut self.symbols {
+        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.
@@ -169,12 +180,25 @@ impl<'a, 'b> LineComposer<'a> for LineTruncator<'a, 'b> {
                 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(Styled(symbol, style));
+            self.current_line.push(StyledGrapheme { symbol, style });
         }
 
         if skip_rest {
-            for Styled(symbol, _) in &mut self.symbols {
+            for StyledGrapheme { symbol, .. } in &mut self.symbols {
                 if symbol == "\n" {
                     break;
                 }
@@ -189,21 +213,40 @@ impl<'a, 'b> LineComposer<'a> for LineTruncator<'a, 'b> {
     }
 }
 
+/// 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,
+        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| Styled(g, style));
+        let mut styled =
+            UnicodeSegmentation::graphemes(text, true).map(|g| StyledGrapheme { symbol: g, style });
         let mut composer: Box<dyn LineComposer> = match which {
-            Composer::WordWrapper => Box::new(WordWrapper::new(&mut styled, text_area_width)),
+            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![];
@@ -211,7 +254,7 @@ mod test {
         while let Some((styled, width)) = composer.next_line() {
             let line = styled
                 .iter()
-                .map(|Styled(g, _style)| *g)
+                .map(|StyledGrapheme { symbol, .. }| *symbol)
                 .collect::<String>();
             assert!(width <= text_area_width);
             lines.push(line);
@@ -225,7 +268,8 @@ mod test {
         let width = 40;
         for i in 1..width {
             let text = "a".repeat(i);
-            let (word_wrapper, _) = run_composer(Composer::WordWrapper, &text, width as u16);
+            let (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);
@@ -238,7 +282,7 @@ mod test {
         let width = 20;
         let text =
             "abcdefg\nhijklmno\npabcdefg\nhijklmn\nopabcdefghijk\nlmnopabcd\n\n\nefghijklmno";
-        let (word_wrapper, _) = run_composer(Composer::WordWrapper, text, width);
+        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();
@@ -250,7 +294,8 @@ mod test {
     fn line_composer_long_word() {
         let width = 20;
         let text = "abcdefghijklmnopabcdefghijklmnopabcdefghijklmnopabcdefghijklmno";
-        let (word_wrapper, _) = run_composer(Composer::WordWrapper, text, width as u16);
+        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![
@@ -261,7 +306,7 @@ mod test {
         ];
         assert_eq!(
             word_wrapper, wrapped,
-            "WordWrapper should deect the line cannot be broken on word boundary and \
+            "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]]);
@@ -276,9 +321,12 @@ mod test {
             "abcd efghij    klmnopabcd efgh     ijklmnopabcdefg hijkl mnopab c d e f g h i j k l \
              m n o";
         let (word_wrapper_single_space, _) =
-            run_composer(Composer::WordWrapper, text, width as u16);
-        let (word_wrapper_multi_space, _) =
-            run_composer(Composer::WordWrapper, text_multi_space, width as u16);
+            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![
@@ -298,7 +346,7 @@ mod test {
     fn line_composer_zero_width() {
         let width = 0;
         let text = "abcd efghij klmnopabcd efgh ijklmnopabcdefg hijkl mnopab ";
-        let (word_wrapper, _) = run_composer(Composer::WordWrapper, text, width);
+        let (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();
@@ -310,7 +358,7 @@ mod test {
     fn line_composer_max_line_width_of_1() {
         let width = 1;
         let text = "abcd efghij klmnopabcd efgh ijklmnopabcdefg hijkl mnopab ";
-        let (word_wrapper, _) = run_composer(Composer::WordWrapper, text, width);
+        let (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)
@@ -325,7 +373,7 @@ mod test {
         let width = 1;
         let text = "コンピュータ上で文字を扱う場合、典型的には文字\naaaによる通信を行う場合にその\
                     両端点では、";
-        let (word_wrapper, _) = run_composer(Composer::WordWrapper, text, width);
+        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"]);
@@ -336,7 +384,7 @@ mod test {
     fn line_composer_word_wrapper_mixed_length() {
         let width = 20;
         let text = "abcd efghij klmnopabcdefghijklmnopabcdefghijkl mnopab cdefghi j klmno";
-        let (word_wrapper, _) = run_composer(Composer::WordWrapper, text, width);
+        let (word_wrapper, _) = run_composer(Composer::WordWrapper { trim: true }, text, width);
         assert_eq!(
             word_wrapper,
             vec![
@@ -354,7 +402,8 @@ mod test {
         let width = 20;
         let text = "コンピュータ上で文字を扱う場合、典型的には文字による通信を行う場合にその両端点\
                     では、";
-        let (word_wrapper, word_wrapper_width) = run_composer(Composer::WordWrapper, &text, width);
+        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![
@@ -372,7 +421,7 @@ mod test {
     fn line_composer_leading_whitespace_removal() {
         let width = 20;
         let text = "AAAAAAAAAAAAAAAAAAAA    AAA";
-        let (word_wrapper, _) = run_composer(Composer::WordWrapper, text, width);
+        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"]);
@@ -383,7 +432,7 @@ mod test {
     fn line_composer_lots_of_spaces() {
         let width = 20;
         let text = "                                                                     ";
-        let (word_wrapper, _) = run_composer(Composer::WordWrapper, text, width);
+        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!["                    "]);
@@ -395,7 +444,7 @@ mod test {
     fn line_composer_char_plus_lots_of_spaces() {
         let width = 20;
         let text = "a                                                                     ";
-        let (word_wrapper, _) = run_composer(Composer::WordWrapper, text, width);
+        let (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
@@ -414,7 +463,8 @@ mod test {
         // hiragana and katakana...
         // This happens to also be a test case for mixed width because regular spaces are single width.
         let text = "コンピュ ータ上で文字を扱う場合、 典型的には文 字による 通信を行 う場合にその両端点では、";
-        let (word_wrapper, word_wrapper_width) = run_composer(Composer::WordWrapper, text, width);
+        let (word_wrapper, word_wrapper_width) =
+            run_composer(Composer::WordWrapper { trim: true }, text, width);
         assert_eq!(
             word_wrapper,
             vec![
@@ -435,12 +485,50 @@ mod test {
     fn line_composer_word_wrapper_nbsp() {
         let width = 20;
         let text = "AAAAAAAAAAAAAAA AAAA\u{00a0}AAA";
-        let (word_wrapper, _) = run_composer(Composer::WordWrapper, text, width);
+        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, &text_space, width);
+        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,11 +1,12 @@
+use crate::{
+    buffer::Buffer,
+    layout::Rect,
+    style::Style,
+    symbols,
+    widgets::{Block, Widget},
+};
 use std::cmp::min;
 
-use crate::buffer::Buffer;
-use crate::layout::Rect;
-use crate::style::Style;
-use crate::symbols::bar;
-use crate::widgets::{Block, Widget};
-
 /// Widget to render a sparkline over one or more lines.
 ///
 /// # Examples
@@ -13,14 +14,13 @@ use crate::widgets::{Block, Widget};
 /// ```
 /// # 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>>,
@@ -31,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> {
@@ -40,6 +42,7 @@ impl<'a> Default for Sparkline<'a> {
             style: Default::default(),
             data: &[],
             max: None,
+            bar_set: symbols::bar::NINE_LEVELS,
         }
     }
 }
@@ -64,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,
         };
@@ -100,20 +109,19 @@ impl<'a> Widget for Sparkline<'a> {
         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;
@@ -131,17 +139,17 @@ mod tests {
 
     #[test]
     fn it_does_not_panic_if_max_is_zero() {
-        let mut widget = Sparkline::default().data(&[0, 0, 0]);
+        let widget = Sparkline::default().data(&[0, 0, 0]);
         let area = Rect::new(0, 0, 3, 1);
         let mut buffer = Buffer::empty(area);
-        widget.draw(area, &mut buffer);
+        widget.render(area, &mut buffer);
     }
 
     #[test]
     fn it_does_not_panic_if_max_is_set_to_zero() {
-        let mut widget = Sparkline::default().data(&[0, 1, 2]).max(0);
+        let widget = Sparkline::default().data(&[0, 1, 2]).max(0);
         let area = Rect::new(0, 0, 3, 1);
         let mut buffer = Buffer::empty(area);
-        widget.draw(area, &mut buffer);
+        widget.render(area, &mut buffer);
     }
 }

src/widgets/table.rs

@@ -1,211 +1,538 @@
-use std::fmt::Display;
-use std::iter::Iterator;
+use crate::{
+    buffer::Buffer,
+    layout::{Constraint, Rect},
+    style::Style,
+    text::Text,
+    widgets::{Block, StatefulWidget, Widget},
+};
+use cassowary::{
+    strength::{MEDIUM, REQUIRED, WEAK},
+    WeightedRelation::*,
+    {Expression, Solver},
+};
+use std::{
+    collections::HashMap,
+    iter::{self, Iterator},
+};
+use unicode_width::UnicodeWidthStr;
 
-use crate::buffer::Buffer;
-use crate::layout::Rect;
-use crate::style::Style;
-use crate::widgets::{Block, Widget};
-
-/// Holds data to be displayed in a Table widget
-pub enum Row<D, I>
-where
-    D: Iterator<Item = I>,
-    I: Display,
-{
-    Data(D),
-    StyledData(D, Style),
-}
-
-/// A widget to display data in formatted columns
+/// A [`Cell`] contains the [`Text`] to be displayed in a [`Row`] of a [`Table`].
 ///
-/// # Examples
+/// It can be created from anything that can be converted to a [`Text`].
+/// ```rust
+/// # use tui::widgets::Cell;
+/// # use tui::style::{Style, Modifier};
+/// # use tui::text::{Span, Spans, Text};
+/// Cell::from("simple string");
 ///
+/// Cell::from(Span::from("span"));
+///
+/// Cell::from(Spans::from(vec![
+///     Span::raw("a vec of "),
+///     Span::styled("spans", Style::default().add_modifier(Modifier::BOLD))
+/// ]));
+///
+/// Cell::from(Text::from("a text"));
 /// ```
-/// # use tui::widgets::{Block, Borders, Table, Row};
-/// # use tui::style::{Style, Color};
-/// # fn main() {
-/// let row_style = Style::default().fg(Color::White);
-/// Table::new(
-///         ["Col1", "Col2", "Col3"].into_iter(),
-///         vec![
-///             Row::StyledData(["Row11", "Row12", "Row13"].into_iter(), row_style),
-///             Row::StyledData(["Row21", "Row22", "Row23"].into_iter(), row_style),
-///             Row::StyledData(["Row31", "Row32", "Row33"].into_iter(), row_style),
-///             Row::Data(["Row41", "Row42", "Row43"].into_iter())
-///         ].into_iter()
-///     )
-///     .block(Block::default().title("Table"))
-///     .header_style(Style::default().fg(Color::Yellow))
-///     .widths(&[5, 5, 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>>,
-{
-    /// A block to wrap the widget in
-    block: Option<Block<'a>>,
-    /// Base style for the widget
+///
+/// You can apply a [`Style`] on the entire [`Cell`] using [`Cell::style`] or rely on the styling
+/// capabilities of [`Text`].
+#[derive(Debug, Clone, PartialEq, Default)]
+pub struct Cell<'a> {
+    content: Text<'a>,
     style: Style,
-    /// Header row for all columns
-    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],
-    /// Space between each column
-    column_spacing: u16,
-    /// 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> Cell<'a> {
+    /// Set the `Style` of this cell.
+    pub fn style(mut self, style: Style) -> Self {
+        self.style = style;
+        self
+    }
+}
+
+impl<'a, T> From<T> for Cell<'a>
 where
-    T: Display,
-    H: Iterator<Item = T> + Default,
-    I: Display,
-    D: Iterator<Item = I>,
-    R: Iterator<Item = Row<D, I>> + Default,
+    T: Into<Text<'a>>,
 {
-    fn default() -> Table<'a, T, H, I, D, R> {
-        Table {
-            block: None,
+    fn from(content: T) -> Cell<'a> {
+        Cell {
+            content: content.into(),
             style: Style::default(),
-            header: H::default(),
-            header_style: Style::default(),
-            widths: &[],
-            rows: R::default(),
-            column_spacing: 1,
         }
     }
 }
 
-impl<'a, T, H, I, D, R> 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>>,
-{
-    pub fn new(header: H, rows: R) -> Table<'a, T, H, I, D, R> {
-        Table {
-            block: None,
+/// Holds data to be displayed in a [`Table`] widget.
+///
+/// A [`Row`] is a collection of cells. It can be created from simple strings:
+/// ```rust
+/// # use tui::widgets::Row;
+/// Row::new(vec!["Cell1", "Cell2", "Cell3"]);
+/// ```
+///
+/// But if you need a bit more control over individual cells, you can explicity create [`Cell`]s:
+/// ```rust
+/// # use tui::widgets::{Row, Cell};
+/// # use tui::style::{Style, Color};
+/// Row::new(vec![
+///     Cell::from("Cell1"),
+///     Cell::from("Cell2").style(Style::default().fg(Color::Yellow)),
+/// ]);
+/// ```
+///
+/// By default, a row has a height of 1 but you can change this using [`Row::height`].
+#[derive(Debug, Clone, PartialEq, Default)]
+pub struct Row<'a> {
+    cells: Vec<Cell<'a>>,
+    height: u16,
+    style: Style,
+    bottom_margin: u16,
+}
+
+impl<'a> Row<'a> {
+    /// Creates a new [`Row`] from an iterator where items can be converted to a [`Cell`].
+    pub fn new<T>(cells: T) -> Self
+    where
+        T: IntoIterator,
+        T::Item: Into<Cell<'a>>,
+    {
+        Self {
+            height: 1,
+            cells: cells.into_iter().map(|c| c.into()).collect(),
             style: Style::default(),
-            header,
-            header_style: Style::default(),
-            widths: &[],
-            rows,
-            column_spacing: 1,
+            bottom_margin: 0,
         }
     }
-    pub fn block(mut self, block: Block<'a>) -> Table<'a, T, H, I, D, R> {
-        self.block = Some(block);
+
+    /// Set the fixed height of the [`Row`]. Any [`Cell`] whose content has more lines than this
+    /// height will see its content truncated.
+    pub fn height(mut self, height: u16) -> Self {
+        self.height = height;
         self
     }
 
-    pub fn header<II>(mut self, header: II) -> Table<'a, T, H, I, D, R>
-    where
-        II: IntoIterator<Item = T, IntoIter = H>,
-    {
-        self.header = header.into_iter();
-        self
-    }
-
-    pub fn header_style(mut self, style: Style) -> Table<'a, T, H, I, D, R> {
-        self.header_style = style;
-        self
-    }
-
-    pub fn widths(mut self, widths: &'a [u16]) -> Table<'a, T, H, I, D, R> {
-        self.widths = widths;
-        self
-    }
-
-    pub fn rows<II>(mut self, rows: II) -> Table<'a, T, H, I, D, R>
-    where
-        II: IntoIterator<Item = Row<D, I>, IntoIter = R>,
-    {
-        self.rows = rows.into_iter();
-        self
-    }
-
-    pub fn style(mut self, style: Style) -> Table<'a, T, H, I, D, R> {
+    /// Set the [`Style`] of the entire row. This [`Style`] can be overriden by the [`Style`] of a
+    /// any individual [`Cell`] or event by their [`Text`] content.
+    pub fn style(mut self, style: Style) -> Self {
         self.style = style;
         self
     }
 
-    pub fn column_spacing(mut self, spacing: u16) -> Table<'a, T, H, I, D, R> {
-        self.column_spacing = spacing;
+    /// Set the bottom margin. By default, the bottom margin is `0`.
+    pub fn bottom_margin(mut self, margin: u16) -> Self {
+        self.bottom_margin = margin;
         self
     }
+
+    /// Returns the total height of the row.
+    fn total_height(&self) -> u16 {
+        self.height.saturating_add(self.bottom_margin)
+    }
 }
 
-impl<'a, T, H, I, D, R> Widget for 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>>,
-{
-    fn draw(&mut self, area: Rect, buf: &mut Buffer) {
-        // 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)
+/// A widget to display data in formatted columns.
+///
+/// It is a collection of [`Row`]s, themselves composed of [`Cell`]s:
+/// ```rust
+/// # use tui::widgets::{Block, Borders, Table, Row, Cell};
+/// # use tui::layout::Constraint;
+/// # use tui::style::{Style, Color, Modifier};
+/// # use tui::text::{Text, Spans, Span};
+/// Table::new(vec![
+///     // Row can be created from simple strings.
+///     Row::new(vec!["Row11", "Row12", "Row13"]),
+///     // You can style the entire row.
+///     Row::new(vec!["Row21", "Row22", "Row23"]).style(Style::default().fg(Color::Blue)),
+///     // If you need more control over the styling you may need to create Cells directly
+///     Row::new(vec![
+///         Cell::from("Row31"),
+///         Cell::from("Row32").style(Style::default().fg(Color::Yellow)),
+///         Cell::from(Spans::from(vec![
+///             Span::raw("Row"),
+///             Span::styled("33", Style::default().fg(Color::Green))
+///         ])),
+///     ]),
+///     // If a Row need to display some content over multiple lines, you just have to change
+///     // its height.
+///     Row::new(vec![
+///         Cell::from("Row\n41"),
+///         Cell::from("Row\n42"),
+///         Cell::from("Row\n43"),
+///     ]).height(2),
+/// ])
+/// // You can set the style of the entire Table.
+/// .style(Style::default().fg(Color::White))
+/// // It has an optional header, which is simply a Row always visible at the top.
+/// .header(
+///     Row::new(vec!["Col1", "Col2", "Col3"])
+///         .style(Style::default().fg(Color::Yellow))
+///         // If you want some space between the header and the rest of the rows, you can always
+///         // specify some margin at the bottom.
+///         .bottom_margin(1)
+/// )
+/// // As any other widget, a Table can be wrapped in a Block.
+/// .block(Block::default().title("Table"))
+/// // Columns widths are constrained in the same way as Layout...
+/// .widths(&[Constraint::Length(5), Constraint::Length(5), Constraint::Length(10)])
+/// // ...and they can be separated by a fixed spacing.
+/// .column_spacing(1)
+/// // If you wish to highlight a row in any specific way when it is selected...
+/// .highlight_style(Style::default().add_modifier(Modifier::BOLD))
+/// // ...and potentially show a symbol in front of the selection.
+/// .highlight_symbol(">>");
+/// ```
+#[derive(Debug, Clone, PartialEq)]
+pub struct Table<'a> {
+    /// A block to wrap the widget in
+    block: Option<Block<'a>>,
+    /// Base style for the widget
+    style: Style,
+    /// Width constraints for each column
+    widths: &'a [Constraint],
+    /// Space between each column
+    column_spacing: u16,
+    /// Style used to render the selected row
+    highlight_style: Style,
+    /// Symbol in front of the selected rom
+    highlight_symbol: Option<&'a str>,
+    /// Optional header
+    header: Option<Row<'a>>,
+    /// Data to display in each row
+    rows: Vec<Row<'a>>,
+}
+
+impl<'a> Table<'a> {
+    pub fn new<T>(rows: T) -> Self
+    where
+        T: IntoIterator<Item = Row<'a>>,
+    {
+        Self {
+            block: None,
+            style: Style::default(),
+            widths: &[],
+            column_spacing: 1,
+            highlight_style: Style::default(),
+            highlight_symbol: None,
+            header: None,
+            rows: rows.into_iter().collect(),
+        }
+    }
+
+    pub fn block(mut self, block: Block<'a>) -> Self {
+        self.block = Some(block);
+        self
+    }
+
+    pub fn header(mut self, header: Row<'a>) -> Self {
+        self.header = Some(header);
+        self
+    }
+
+    pub fn widths(mut self, widths: &'a [Constraint]) -> Self {
+        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 style(mut self, style: Style) -> Self {
+        self.style = style;
+        self
+    }
+
+    pub fn highlight_symbol(mut self, highlight_symbol: &'a str) -> Self {
+        self.highlight_symbol = Some(highlight_symbol);
+        self
+    }
+
+    pub fn highlight_style(mut self, highlight_style: Style) -> Self {
+        self.highlight_style = highlight_style;
+        self
+    }
+
+    pub fn column_spacing(mut self, spacing: u16) -> Self {
+        self.column_spacing = spacing;
+        self
+    }
+
+    fn get_columns_widths(&self, max_width: u16, has_selection: bool) -> Vec<u16> {
+        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);
+        }
+        let spacing_width = (variables.len() as u16).saturating_sub(1) * self.column_spacing;
+        let mut available_width = max_width.saturating_sub(spacing_width);
+        if has_selection {
+            let highlight_symbol_width =
+                self.highlight_symbol.map(|s| s.width() as u16).unwrap_or(0);
+            available_width = available_width.saturating_sub(highlight_symbol_width);
+        }
+        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 * available_width) / 100.0)
+                }
+                Constraint::Ratio(n, d) => {
+                    variables[i]
+                        | EQ(WEAK)
+                        | (f64::from(available_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(available_width),
+            )
+            .unwrap();
+        solver.add_constraints(&ccs).unwrap();
+        let mut 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.round() as u16
+            };
+            widths[index] = value;
+        }
+        // Cassowary could still return columns widths greater than the max width when there are
+        // fixed length constraints that cannot be satisfied. Therefore, we clamp the widths from
+        // left to right.
+        let mut available_width = max_width;
+        for w in &mut widths {
+            *w = available_width.min(*w);
+            available_width = available_width
+                .saturating_sub(*w)
+                .saturating_sub(self.column_spacing);
+        }
+        widths
+    }
+
+    fn get_row_bounds(
+        &self,
+        selected: Option<usize>,
+        offset: usize,
+        max_height: u16,
+    ) -> (usize, usize) {
+        let mut start = offset;
+        let mut end = offset;
+        let mut height = 0;
+        for item in self.rows.iter().skip(offset) {
+            if height + item.height > max_height {
+                break;
+            }
+            height += item.total_height();
+            end += 1;
+        }
+
+        let selected = selected.unwrap_or(0).min(self.rows.len() - 1);
+        while selected >= end {
+            height = height.saturating_add(self.rows[end].total_height());
+            end += 1;
+            while height > max_height {
+                height = height.saturating_sub(self.rows[start].total_height());
+                start += 1;
+            }
+        }
+        while selected < start {
+            start -= 1;
+            height = height.saturating_add(self.rows[start].total_height());
+            while height > max_height {
+                end -= 1;
+                height = height.saturating_sub(self.rows[end].total_height());
+            }
+        }
+        (start, end)
+    }
+}
+
+#[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;
+        }
+    }
+}
+
+impl<'a> StatefulWidget for Table<'a> {
+    type State = TableState;
+
+    fn render(mut self, area: Rect, buf: &mut Buffer, state: &mut Self::State) {
+        if area.area() == 0 {
+            return;
+        }
+        buf.set_style(area, self.style);
+        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 y = table_area.top();
+        let has_selection = state.selected.is_some();
+        let columns_widths = self.get_columns_widths(table_area.width, has_selection);
+        let highlight_symbol = self.highlight_symbol.unwrap_or("");
+        let blank_symbol = iter::repeat(" ")
+            .take(highlight_symbol.width())
+            .collect::<String>();
+        let mut current_height = 0;
+        let mut rows_height = table_area.height;
 
         // 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);
-                x += *w + self.column_spacing;
+        if let Some(ref header) = self.header {
+            let max_header_height = table_area.height.min(header.total_height());
+            buf.set_style(
+                Rect {
+                    x: table_area.left(),
+                    y: table_area.top(),
+                    width: table_area.width,
+                    height: table_area.height.min(header.height),
+                },
+                header.style,
+            );
+            let mut col = table_area.left();
+            if has_selection {
+                col += (highlight_symbol.width() as u16).min(table_area.width);
             }
+            for (width, cell) in columns_widths.iter().zip(header.cells.iter()) {
+                render_cell(
+                    buf,
+                    cell,
+                    Rect {
+                        x: col,
+                        y: table_area.top(),
+                        width: *width,
+                        height: max_header_height,
+                    },
+                );
+                col += *width + self.column_spacing;
+            }
+            current_height += max_header_height;
+            rows_height = rows_height.saturating_sub(max_header_height);
         }
-        y += 2;
 
         // 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),
+        if self.rows.is_empty() {
+            return;
+        }
+        let (start, end) = self.get_row_bounds(state.selected, state.offset, rows_height);
+        state.offset = start;
+        for (i, table_row) in self
+            .rows
+            .iter_mut()
+            .enumerate()
+            .skip(state.offset)
+            .take(end - start)
+        {
+            let (row, col) = (table_area.top() + current_height, table_area.left());
+            current_height += table_row.total_height();
+            let table_row_area = Rect {
+                x: col,
+                y: row,
+                width: table_area.width,
+                height: table_row.height,
+            };
+            buf.set_style(table_row_area, table_row.style);
+            let is_selected = state.selected.map(|s| s == i).unwrap_or(false);
+            let table_row_start_col = if has_selection {
+                let symbol = if is_selected {
+                    highlight_symbol
+                } else {
+                    &blank_symbol
                 };
-                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);
-                    x += *w + self.column_spacing;
-                }
+                let (col, _) =
+                    buf.set_stringn(col, row, symbol, table_area.width as usize, table_row.style);
+                col
+            } else {
+                col
+            };
+            let mut col = table_row_start_col;
+            for (width, cell) in columns_widths.iter().zip(table_row.cells.iter()) {
+                render_cell(
+                    buf,
+                    cell,
+                    Rect {
+                        x: col,
+                        y: row,
+                        width: *width,
+                        height: table_row.height,
+                    },
+                );
+                col += *width + self.column_spacing;
+            }
+            if is_selected {
+                buf.set_style(table_row_area, self.highlight_style);
             }
         }
     }
 }
+
+fn render_cell(buf: &mut Buffer, cell: &Cell, area: Rect) {
+    buf.set_style(area, cell.style);
+    for (i, spans) in cell.content.lines.iter().enumerate() {
+        if i as u16 >= area.height {
+            break;
+        }
+        buf.set_spans(area.x, area.y + i as u16, spans, area.width);
+    }
+}
+
+impl<'a> Widget for Table<'a> {
+    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(vec![]).widths(&[Constraint::Percentage(110)]);
+    }
+}

src/widgets/tabs.rs

@@ -1,10 +1,11 @@
-use unicode_width::UnicodeWidthStr;
-
-use crate::buffer::Buffer;
-use crate::layout::Rect;
-use crate::style::Style;
-use crate::symbols::line;
-use crate::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.
 ///
@@ -13,94 +14,80 @@ use crate::widgets::{Block, Widget};
 /// ```
 /// # use tui::widgets::{Block, Borders, Tabs};
 /// # use tui::style::{Style, Color};
+/// # use tui::text::{Spans};
 /// # use tui::symbols::{DOT};
-/// # fn main() {
-/// Tabs::default()
+/// 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))
 ///     .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: &'a str,
+    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: line::VERTICAL,
+            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(mut self, divider: &'a str) -> Tabs<'a, T> {
-        self.divider = divider;
+    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,
         };
@@ -109,32 +96,34 @@ where
             return;
         }
 
-        self.background(tabs_area, buf, self.style.bg);
-
         let mut x = tabs_area.left();
         let titles_length = self.titles.len();
-        let divider_width = self.divider.width() as u16;
-        for (title, style, last_title) in self.titles.iter().enumerate().map(|(i, t)| {
-            let lt = i + 1 == titles_length;
-            if i == self.selected {
-                (t, self.highlight_style, lt)
-            } else {
-                (t, self.style, lt)
-            }
-        }) {
-            x += 1;
-            if x > tabs_area.right() {
+        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() || last_title {
-                    break;
-                } else {
-                    buf.set_string(x, tabs_area.top(), self.divider, style);
-                    x += divider_width;
-                }
             }
+            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('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('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('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/block.rs

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

tests/gauge.rs

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

tests/paragraph.rs

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

tests/size.rs

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

tests/terminal.rs

@@ -0,0 +1,36 @@
+use std::error::Error;
+use tui::{
+    backend::{Backend, TestBackend},
+    layout::Rect,
+    widgets::Paragraph,
+    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);
+}
+
+#[test]
+fn terminal_draw_returns_the_completed_frame() -> Result<(), Box<dyn Error>> {
+    let backend = TestBackend::new(10, 10);
+    let mut terminal = Terminal::new(backend)?;
+    let frame = terminal.draw(|f| {
+        let paragrah = Paragraph::new("Test");
+        f.render_widget(paragrah, f.size());
+    })?;
+    assert_eq!(frame.buffer.get(0, 0).symbol, "T");
+    assert_eq!(frame.area, Rect::new(0, 0, 10, 10));
+    terminal.backend_mut().resize(8, 8);
+    let frame = terminal.draw(|f| {
+        let paragrah = Paragraph::new("test");
+        f.render_widget(paragrah, f.size());
+    })?;
+    assert_eq!(frame.buffer.get(0, 0).symbol, "t");
+    assert_eq!(frame.area, Rect::new(0, 0, 8, 8));
+    Ok(())
+}

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,213 @@
+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);
+}
+
+#[test]
+fn widgets_block_renders_on_small_areas() {
+    let test_case = |block, area: Rect, expected| {
+        let backend = TestBackend::new(area.width, area.height);
+        let mut terminal = Terminal::new(backend).unwrap();
+        terminal
+            .draw(|f| {
+                f.render_widget(block, area);
+            })
+            .unwrap();
+        terminal.backend().assert_buffer(&expected);
+    };
+
+    let one_cell_test_cases = [
+        (Borders::NONE, "T"),
+        (Borders::LEFT, "│"),
+        (Borders::TOP, "T"),
+        (Borders::RIGHT, "│"),
+        (Borders::BOTTOM, "T"),
+        (Borders::ALL, "┌"),
+    ];
+    for (borders, symbol) in one_cell_test_cases.iter().cloned() {
+        test_case(
+            Block::default().title("Test").borders(borders),
+            Rect {
+                x: 0,
+                y: 0,
+                width: 0,
+                height: 0,
+            },
+            Buffer::empty(Rect {
+                x: 0,
+                y: 0,
+                width: 0,
+                height: 0,
+            }),
+        );
+        test_case(
+            Block::default().title("Test").borders(borders),
+            Rect {
+                x: 0,
+                y: 0,
+                width: 1,
+                height: 0,
+            },
+            Buffer::empty(Rect {
+                x: 0,
+                y: 0,
+                width: 1,
+                height: 0,
+            }),
+        );
+        test_case(
+            Block::default().title("Test").borders(borders),
+            Rect {
+                x: 0,
+                y: 0,
+                width: 0,
+                height: 1,
+            },
+            Buffer::empty(Rect {
+                x: 0,
+                y: 0,
+                width: 0,
+                height: 1,
+            }),
+        );
+        test_case(
+            Block::default().title("Test").borders(borders),
+            Rect {
+                x: 0,
+                y: 0,
+                width: 1,
+                height: 1,
+            },
+            Buffer::with_lines(vec![symbol]),
+        );
+    }
+    test_case(
+        Block::default().title("Test").borders(Borders::LEFT),
+        Rect {
+            x: 0,
+            y: 0,
+            width: 4,
+            height: 1,
+        },
+        Buffer::with_lines(vec!["│Tes"]),
+    );
+    test_case(
+        Block::default().title("Test").borders(Borders::RIGHT),
+        Rect {
+            x: 0,
+            y: 0,
+            width: 4,
+            height: 1,
+        },
+        Buffer::with_lines(vec!["Tes│"]),
+    );
+    test_case(
+        Block::default().title("Test").borders(Borders::RIGHT),
+        Rect {
+            x: 0,
+            y: 0,
+            width: 4,
+            height: 1,
+        },
+        Buffer::with_lines(vec!["Tes│"]),
+    );
+    test_case(
+        Block::default()
+            .title("Test")
+            .borders(Borders::LEFT | Borders::RIGHT),
+        Rect {
+            x: 0,
+            y: 0,
+            width: 4,
+            height: 1,
+        },
+        Buffer::with_lines(vec!["│Te│"]),
+    );
+    test_case(
+        Block::default().title("Test").borders(Borders::TOP),
+        Rect {
+            x: 0,
+            y: 0,
+            width: 4,
+            height: 1,
+        },
+        Buffer::with_lines(vec!["Test"]),
+    );
+    test_case(
+        Block::default().title("Test").borders(Borders::TOP),
+        Rect {
+            x: 0,
+            y: 0,
+            width: 5,
+            height: 1,
+        },
+        Buffer::with_lines(vec!["Test─"]),
+    );
+    test_case(
+        Block::default()
+            .title("Test")
+            .borders(Borders::LEFT | Borders::TOP),
+        Rect {
+            x: 0,
+            y: 0,
+            width: 5,
+            height: 1,
+        },
+        Buffer::with_lines(vec!["┌Test"]),
+    );
+    test_case(
+        Block::default()
+            .title("Test")
+            .borders(Borders::LEFT | Borders::TOP),
+        Rect {
+            x: 0,
+            y: 0,
+            width: 6,
+            height: 1,
+        },
+        Buffer::with_lines(vec!["┌Test─"]),
+    );
+}

tests/widgets_chart.rs

@@ -0,0 +1,413 @@
+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_render_on_small_areas() {
+    let test_case = |width, height| {
+        let backend = TestBackend::new(width, height);
+        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, f.size());
+            })
+            .unwrap();
+    };
+    test_case(0, 0);
+    test_case(0, 1);
+    test_case(1, 0);
+    test_case(1, 1);
+    test_case(2, 2);
+}
+
+#[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,169 @@
+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))
+                .gauge_style(Style::default().bg(Color::Blue).fg(Color::Red))
+                .use_unicode(true)
+                .percent(43);
+            f.render_widget(gauge, chunks[0]);
+            let gauge = Gauge::default()
+                .block(Block::default().title("Ratio").borders(Borders::ALL))
+                .gauge_style(Style::default().bg(Color::Blue).fg(Color::Red))
+                .use_unicode(true)
+                .ratio(0.511_313_934_313_1);
+            f.render_widget(gauge, chunks[1]);
+        })
+        .unwrap();
+    let mut expected = Buffer::with_lines(vec![
+        "                                        ",
+        "                                        ",
+        "  ┌Percentage────────────────────────┐  ",
+        "  │              ▋43%                │  ",
+        "  └──────────────────────────────────┘  ",
+        "  ┌Ratio─────────────────────────────┐  ",
+        "  │               51%                │  ",
+        "  └──────────────────────────────────┘  ",
+        "                                        ",
+        "                                        ",
+    ]);
+
+    for i in 3..17 {
+        expected
+            .get_mut(i, 3)
+            .set_bg(Color::Red)
+            .set_fg(Color::Blue);
+    }
+    for i in 17..37 {
+        expected
+            .get_mut(i, 3)
+            .set_bg(Color::Blue)
+            .set_fg(Color::Red);
+    }
+
+    for i in 3..20 {
+        expected
+            .get_mut(i, 6)
+            .set_bg(Color::Red)
+            .set_fg(Color::Blue);
+    }
+    for i in 20..37 {
+        expected
+            .get_mut(i, 6)
+            .set_bg(Color::Blue)
+            .set_fg(Color::Red);
+    }
+
+    terminal.backend().assert_buffer(&expected);
+}
+
+#[test]
+fn widgets_gauge_renders_no_unicode() {
+    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)
+                .use_unicode(false);
+            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)
+                .use_unicode(false);
+            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,220 @@
+use tui::{
+    backend::TestBackend,
+    buffer::Buffer,
+    layout::Alignment,
+    text::{Span, 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_wrap_with_a_trailing_nbsp() {
+    let nbsp: &str = "\u{00a0}";
+    let line = Spans::from(vec![Span::raw("NBSP"), Span::raw(nbsp)]);
+    let backend = TestBackend::new(20, 3);
+    let mut terminal = Terminal::new(backend).unwrap();
+    let expected = Buffer::with_lines(vec![
+        "┌──────────────────┐",
+        "│NBSP\u{00a0}             │",
+        "└──────────────────┘",
+    ]);
+    terminal
+        .draw(|f| {
+            let size = f.size();
+
+            let paragraph = Paragraph::new(line).block(Block::default().borders(Borders::ALL));
+            f.render_widget(paragraph, size);
+        })
+        .unwrap();
+    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,717 @@
+use tui::{
+    backend::TestBackend,
+    buffer::Buffer,
+    layout::Constraint,
+    style::{Color, Modifier, Style},
+    text::{Span, Spans},
+    widgets::{Block, Borders, Cell, Row, Table, TableState},
+    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(vec![
+                    Row::new(vec!["Row11", "Row12", "Row13"]),
+                    Row::new(vec!["Row21", "Row22", "Row23"]),
+                    Row::new(vec!["Row31", "Row32", "Row33"]),
+                    Row::new(vec!["Row41", "Row42", "Row43"]),
+                ])
+                .header(Row::new(vec!["Head1", "Head2", "Head3"]).bottom_margin(1))
+                .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(vec![
+                    Row::new(vec!["Row11", "Row12", "Row13"]),
+                    Row::new(vec!["Row21", "Row22", "Row23"]),
+                    Row::new(vec!["Row31", "Row32", "Row33"]),
+                    Row::new(vec!["Row41", "Row42", "Row43"]),
+                ])
+                .header(Row::new(vec!["Head1", "Head2", "Head3"]).bottom_margin(1))
+                .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(vec![
+                    Row::new(vec!["Row11", "Row12", "Row13"]),
+                    Row::new(vec!["Row21", "Row22", "Row23"]),
+                    Row::new(vec!["Row31", "Row32", "Row33"]),
+                    Row::new(vec!["Row41", "Row42", "Row43"]),
+                ])
+                .header(Row::new(vec!["Head1", "Head2", "Head3"]).bottom_margin(1))
+                .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(11),
+            Constraint::Percentage(11),
+            Constraint::Percentage(11),
+        ],
+        Buffer::with_lines(vec![
+            "┌────────────────────────────┐",
+            "│HeaHeaHea                   │",
+            "│                            │",
+            "│RowRowRow                   │",
+            "│RowRowRow                   │",
+            "│RowRowRow                   │",
+            "│RowRowRow                   │",
+            "│                            │",
+            "│                            │",
+            "└────────────────────────────┘",
+        ]),
+    );
+
+    // columns of large width just before pushing a column off
+    test_case(
+        &[
+            Constraint::Percentage(33),
+            Constraint::Percentage(33),
+            Constraint::Percentage(33),
+        ],
+        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(vec![
+                    Row::new(vec!["Row11", "Row12", "Row13"]),
+                    Row::new(vec!["Row21", "Row22", "Row23"]),
+                    Row::new(vec!["Row31", "Row32", "Row33"]),
+                    Row::new(vec!["Row41", "Row42", "Row43"]),
+                ])
+                .header(Row::new(vec!["Head1", "Head2", "Head3"]).bottom_margin(1))
+                .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(11),
+            Constraint::Length(20),
+            Constraint::Percentage(11),
+        ],
+        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(33),
+            Constraint::Length(10),
+            Constraint::Percentage(33),
+        ],
+        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      │",
+            "│                            │",
+            "│                            │",
+            "└────────────────────────────┘",
+        ]),
+    );
+}
+
+#[test]
+fn widgets_table_columns_widths_can_use_ratio_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(vec![
+                    Row::new(vec!["Row11", "Row12", "Row13"]),
+                    Row::new(vec!["Row21", "Row22", "Row23"]),
+                    Row::new(vec!["Row31", "Row32", "Row33"]),
+                    Row::new(vec!["Row41", "Row42", "Row43"]),
+                ])
+                .header(Row::new(vec!["Head1", "Head2", "Head3"]).bottom_margin(1))
+                .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::Ratio(0, 1),
+            Constraint::Ratio(0, 1),
+            Constraint::Ratio(0, 1),
+        ],
+        Buffer::with_lines(vec![
+            "┌────────────────────────────┐",
+            "│                            │",
+            "│                            │",
+            "│                            │",
+            "│                            │",
+            "│                            │",
+            "│                            │",
+            "│                            │",
+            "│                            │",
+            "└────────────────────────────┘",
+        ]),
+    );
+
+    // columns of not enough width trims the data
+    test_case(
+        &[
+            Constraint::Ratio(1, 9),
+            Constraint::Ratio(1, 9),
+            Constraint::Ratio(1, 9),
+        ],
+        Buffer::with_lines(vec![
+            "┌────────────────────────────┐",
+            "│HeaHeaHea                   │",
+            "│                            │",
+            "│RowRowRow                   │",
+            "│RowRowRow                   │",
+            "│RowRowRow                   │",
+            "│RowRowRow                   │",
+            "│                            │",
+            "│                            │",
+            "└────────────────────────────┘",
+        ]),
+    );
+
+    // columns of large width just before pushing a column off
+    test_case(
+        &[
+            Constraint::Ratio(1, 3),
+            Constraint::Ratio(1, 3),
+            Constraint::Ratio(1, 3),
+        ],
+        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::Ratio(1, 2), Constraint::Ratio(1, 2)],
+        Buffer::with_lines(vec![
+            "┌────────────────────────────┐",
+            "│Head1         Head2         │",
+            "│                            │",
+            "│Row11         Row12         │",
+            "│Row21         Row22         │",
+            "│Row31         Row32         │",
+            "│Row41         Row42         │",
+            "│                            │",
+            "│                            │",
+            "└────────────────────────────┘",
+        ]),
+    );
+}
+
+#[test]
+fn widgets_table_can_have_rows_with_multi_lines() {
+    let test_case = |state: &mut TableState, expected: Buffer| {
+        let backend = TestBackend::new(30, 8);
+        let mut terminal = Terminal::new(backend).unwrap();
+        terminal
+            .draw(|f| {
+                let size = f.size();
+                let table = Table::new(vec![
+                    Row::new(vec!["Row11", "Row12", "Row13"]),
+                    Row::new(vec!["Row21", "Row22", "Row23"]).height(2),
+                    Row::new(vec!["Row31", "Row32", "Row33"]),
+                    Row::new(vec!["Row41", "Row42", "Row43"]).height(2),
+                ])
+                .header(Row::new(vec!["Head1", "Head2", "Head3"]).bottom_margin(1))
+                .block(Block::default().borders(Borders::ALL))
+                .highlight_symbol(">> ")
+                .widths(&[
+                    Constraint::Length(5),
+                    Constraint::Length(5),
+                    Constraint::Length(5),
+                ])
+                .column_spacing(1);
+                f.render_stateful_widget(table, size, state);
+            })
+            .unwrap();
+        terminal.backend().assert_buffer(&expected);
+    };
+
+    let mut state = TableState::default();
+    // no selection
+    test_case(
+        &mut state,
+        Buffer::with_lines(vec![
+            "┌────────────────────────────┐",
+            "│Head1 Head2 Head3           │",
+            "│                            │",
+            "│Row11 Row12 Row13           │",
+            "│Row21 Row22 Row23           │",
+            "│                            │",
+            "│Row31 Row32 Row33           │",
+            "└────────────────────────────┘",
+        ]),
+    );
+
+    // select first
+    state.select(Some(0));
+    test_case(
+        &mut state,
+        Buffer::with_lines(vec![
+            "┌────────────────────────────┐",
+            "│   Head1 Head2 Head3        │",
+            "│                            │",
+            "│>> Row11 Row12 Row13        │",
+            "│   Row21 Row22 Row23        │",
+            "│                            │",
+            "│   Row31 Row32 Row33        │",
+            "└────────────────────────────┘",
+        ]),
+    );
+
+    // select second (we don't show partially the 4th row)
+    state.select(Some(1));
+    test_case(
+        &mut state,
+        Buffer::with_lines(vec![
+            "┌────────────────────────────┐",
+            "│   Head1 Head2 Head3        │",
+            "│                            │",
+            "│   Row11 Row12 Row13        │",
+            "│>> Row21 Row22 Row23        │",
+            "│                            │",
+            "│   Row31 Row32 Row33        │",
+            "└────────────────────────────┘",
+        ]),
+    );
+
+    // select 4th (we don't show partially the 1st row)
+    state.select(Some(3));
+    test_case(
+        &mut state,
+        Buffer::with_lines(vec![
+            "┌────────────────────────────┐",
+            "│   Head1 Head2 Head3        │",
+            "│                            │",
+            "│   Row31 Row32 Row33        │",
+            "│>> Row41 Row42 Row43        │",
+            "│                            │",
+            "│                            │",
+            "└────────────────────────────┘",
+        ]),
+    );
+}
+
+#[test]
+fn widgets_table_can_have_elements_styled_individually() {
+    let backend = TestBackend::new(30, 4);
+    let mut terminal = Terminal::new(backend).unwrap();
+    let mut state = TableState::default();
+    state.select(Some(0));
+    terminal
+        .draw(|f| {
+            let size = f.size();
+            let table = Table::new(vec![
+                Row::new(vec!["Row11", "Row12", "Row13"]).style(Style::default().fg(Color::Green)),
+                Row::new(vec![
+                    Cell::from("Row21"),
+                    Cell::from("Row22").style(Style::default().fg(Color::Yellow)),
+                    Cell::from(Spans::from(vec![
+                        Span::raw("Row"),
+                        Span::styled("23", Style::default().fg(Color::Blue)),
+                    ]))
+                    .style(Style::default().fg(Color::Red)),
+                ])
+                .style(Style::default().fg(Color::LightGreen)),
+            ])
+            .header(Row::new(vec!["Head1", "Head2", "Head3"]).bottom_margin(1))
+            .block(Block::default().borders(Borders::LEFT | Borders::RIGHT))
+            .highlight_symbol(">> ")
+            .highlight_style(Style::default().add_modifier(Modifier::BOLD))
+            .widths(&[
+                Constraint::Length(6),
+                Constraint::Length(6),
+                Constraint::Length(6),
+            ])
+            .column_spacing(1);
+            f.render_stateful_widget(table, size, &mut state);
+        })
+        .unwrap();
+
+    let mut expected = Buffer::with_lines(vec![
+        "│   Head1  Head2  Head3      │",
+        "│                            │",
+        "│>> Row11  Row12  Row13      │",
+        "│   Row21  Row22  Row23      │",
+    ]);
+    // First row = row color + highlight style
+    for col in 1..=28 {
+        expected.get_mut(col, 2).set_style(
+            Style::default()
+                .fg(Color::Green)
+                .add_modifier(Modifier::BOLD),
+        );
+    }
+    // Second row:
+    // 1. row color
+    for col in 1..=28 {
+        expected
+            .get_mut(col, 3)
+            .set_style(Style::default().fg(Color::LightGreen));
+    }
+    // 2. cell color
+    for col in 11..=16 {
+        expected
+            .get_mut(col, 3)
+            .set_style(Style::default().fg(Color::Yellow));
+    }
+    for col in 18..=23 {
+        expected
+            .get_mut(col, 3)
+            .set_style(Style::default().fg(Color::Red));
+    }
+    // 3. text color
+    for col in 21..=22 {
+        expected
+            .get_mut(col, 3)
+            .set_style(Style::default().fg(Color::Blue));
+    }
+    terminal.backend().assert_buffer(&expected);
+}
+
+#[test]
+fn widgets_table_should_render_even_if_empty() {
+    let backend = TestBackend::new(30, 4);
+    let mut terminal = Terminal::new(backend).unwrap();
+    terminal
+        .draw(|f| {
+            let size = f.size();
+            let table = Table::new(vec![])
+                .header(Row::new(vec!["Head1", "Head2", "Head3"]))
+                .block(Block::default().borders(Borders::LEFT | Borders::RIGHT))
+                .widths(&[
+                    Constraint::Length(6),
+                    Constraint::Length(6),
+                    Constraint::Length(6),
+                ])
+                .column_spacing(1);
+            f.render_widget(table, size);
+        })
+        .unwrap();
+
+    let expected = Buffer::with_lines(vec![
+        "│Head1  Head2  Head3         │",
+        "│                            │",
+        "│                            │",
+        "│                            │",
+    ]);
+
+    terminal.backend().assert_buffer(&expected);
+}

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);
+}