chore(release): configure git-cliff

.github/CODEOWNERS

@@ -5,4 +5,4 @@
 # https://git-scm.com/docs/gitignore#_pattern_format
 
 # Maintainers
-* @orhun @mindoodoo @sayanarijit @joshka @kdheepak
+* @orhun @mindoodoo @sayanarijit @sophacles @joshka @kdheepak

.github/ISSUE_TEMPLATE/config.yml

@@ -1,8 +1 @@
 blank_issues_enabled: false
-contact_links:
-  - name: Discord Chat
-    url: https://discord.gg/pMCEU9hNEj
-    about: Ask questions about ratatui on Discord
-  - name: Matrix Chat
-    url: https://matrix.to/#/#ratatui:matrix.org
-    about: Ask questions about ratatui on Matrix

.github/dependabot.yml

@@ -1,18 +0,0 @@
-# To get started with Dependabot version updates, you'll need to specify which
-# package ecosystems to update and where the package manifests are located.
-# Please see the documentation for all configuration options:
-# https://docs.github.com/github/administering-a-repository/configuration-options-for-dependency-updates
-
-version: 2
-updates:
-  # Maintain dependencies for Cargo
-  - package-ecosystem: "cargo"
-    directory: "/" # Location of package manifests
-    schedule:
-      interval: "weekly"
-  # Maintain dependencies for GitHub Actions
-  - package-ecosystem: github-actions
-    directory: "/"
-    schedule:
-      interval: weekly
-    open-pull-requests-limit: 10

.github/workflows/cd.yml

@@ -15,52 +15,46 @@ defaults:
     shell: bash
 
 jobs:
-  publish-alpha:
-    name: Create an alpha release
+  publish-nightly:
+    name: Create a nightly release
     runs-on: ubuntu-latest
-    permissions:
-      contents: write
     if: ${{ !startsWith(github.event.ref, 'refs/tags/v') }}
     steps:
       - name: Checkout the repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
         with:
           fetch-depth: 0
 
       - name: Calculate the next release
         run: |
-          suffix="alpha"
-          last_tag="$(git tag --sort=committerdate | tail -1)"
-          if [[ "${last_tag}" = *"-${suffix}"* ]]; then
+          suffix="-alpha"
+          last_tag="$(git describe --abbrev=0 --tags `git rev-list --tags --max-count=1`)"
+          if [[ "${last_tag}" = *"${suffix}"* ]]; then
             # increment the alpha version
-            # e.g. v0.22.1-alpha.12 -> v0.22.1-alpha.13
-            alpha="${last_tag##*-${suffix}.}"
-            next_alpha="$((alpha + 1))"
-            next_tag="${last_tag/%${alpha}/${next_alpha}}"
+            alpha=$(echo "${last_tag}" | grep -oE '([0-9]+)$')
+            next_alpha=$((alpha + 1))
+            next_tag=$(echo "${last_tag}" | sed "s/\.[0-9]\+$/\.${next_alpha}/")
           else
-            # increment the patch and start the alpha version from 0
-            # e.g. v0.22.0 -> v0.22.1-alpha.0
-            patch="${last_tag##*.}"
-            next_patch="$((patch + 1))"
-            next_tag="${last_tag/%${patch}/${next_patch}}-${suffix}.0"
+            # start the alpha version from 0
+            next_tag="${last_tag}${suffix}.0"
           fi
           # update the crate version
           msg="# crate version"
           sed -E -i "s/^version = .* ${msg}$/version = \"${next_tag#v}\" ${msg}/" Cargo.toml
           echo "NEXT_TAG=${next_tag}" >> $GITHUB_ENV
-          echo "Next alpha release: ${next_tag} 🐭"
+          echo "Next nightly release: ${next_tag} 🐭"
 
       - name: Publish on crates.io
         uses: actions-rs/cargo@v1
         with:
           command: publish
-          args: --allow-dirty --token ${{ secrets.CARGO_TOKEN }}
+          args: --dry-run --allow-dirty
 
       - name: Generate a changelog
         uses: orhun/git-cliff-action@v2
         with:
           config: cliff.toml
-          args: --unreleased --tag ${{ env.NEXT_TAG }} --strip header
+          args: --unreleased --strip header
         env:
           OUTPUT: BODY.md
 
@@ -77,10 +71,10 @@ jobs:
     if: ${{ startsWith(github.event.ref, 'refs/tags/v') }}
     steps:
       - name: Checkout the repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
 
       - name: Publish on crates.io
         uses: actions-rs/cargo@v1
         with:
           command: publish
-          args: --token ${{ secrets.CARGO_TOKEN }}
+          args: --dry-run

.github/workflows/check-pr.yml

@@ -1,83 +0,0 @@
-name: Check Pull Requests
-
-on:
-  pull_request_target:
-    types:
-      - opened
-      - edited
-      - synchronize
-      - labeled
-      - unlabeled
-  merge_group:
-
-permissions:
-  pull-requests: write
-
-jobs:
-  check-title:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Check PR title
-        if: github.event_name == 'pull_request_target'
-        uses: amannn/action-semantic-pull-request@v5
-        id: check_pr_title
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-      # Add comment indicating we require pull request titles to follow conventional commits specification
-      - uses: marocchino/sticky-pull-request-comment@v2
-        if: always() && (steps.check_pr_title.outputs.error_message != null)
-        with:
-          header: pr-title-lint-error
-          message: |
-            Thank you for opening this pull request!
-
-            We require pull request titles to follow the [Conventional Commits specification](https://www.conventionalcommits.org/en/v1.0.0/) and it looks like your proposed title needs to be adjusted.
-
-            Details:
-
-            > ${{ steps.check_pr_title.outputs.error_message }}
-
-      # Delete a previous comment when the issue has been resolved
-      - if: ${{ steps.check_pr_title.outputs.error_message == null }}
-        uses: marocchino/sticky-pull-request-comment@v2
-        with:
-          header: pr-title-lint-error
-          delete: true
-
-  check-breaking-change-label:
-    runs-on: ubuntu-latest
-    steps:
-    - name: Check breaking change label
-      id: check_breaking_change
-      run: |
-        pattern='^(build|chore|ci|docs|feat|fix|perf|refactor|revert|style|test)(\(\w+\))?!:'
-        # Check if pattern matches
-        if echo "${{ github.event.pull_request.title }}" | grep -qE "$pattern"; then
-          echo "breaking_change=true" >> $GITHUB_OUTPUT
-        else
-          echo "breaking_change=false" >> $GITHUB_OUTPUT
-        fi
-    - name: Add label
-      if: steps.check_breaking_change.outputs.breaking_change == 'true'
-      uses: actions/github-script@v6
-      with:
-        github-token: ${{ secrets.GITHUB_TOKEN }}
-        script: |
-          github.rest.issues.addLabels({
-            issue_number: context.issue.number,
-            owner: context.repo.owner,
-            repo: context.repo.repo,
-            labels: ['breaking change']
-          })
-
-  do-not-merge:
-    if: ${{ contains(github.event.*.labels.*.name, 'do not merge') }}
-    name: Prevent Merging
-    runs-on: ubuntu-latest
-    steps:
-      - name: Check for label
-        run: |
-          echo "Pull request is labeled as 'do not merge'"
-          echo "This workflow fails so that the pull request cannot be merged"
-          exit 1
-

.github/workflows/ci.yml

@@ -1,4 +1,4 @@
-name: Continuous Integration
+name: CI
 
 on:
   # Allows you to run this workflow manually from the Actions tab
@@ -30,22 +30,12 @@ jobs:
     steps:
       - name: Checkout
         if: github.event_name != 'pull_request'
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
       - name: Checkout
         if: github.event_name == 'pull_request'
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
         with:
           ref: ${{ github.event.pull_request.head.sha }}
-      - name: Install Rust nightly
-        uses: dtolnay/rust-toolchain@nightly
-        with:
-          components: rustfmt
-      - name: Install cargo-make
-        uses: taiki-e/install-action@cargo-make
-      - name: Check formatting
-        run: cargo make lint-format
-      - name: Check documentation
-        run: cargo make lint-docs
       - name: Check conventional commits
         uses: crate-ci/committed@master
         with:
@@ -55,12 +45,20 @@ jobs:
         uses: crate-ci/typos@master
       - name: Lint dependencies
         uses: EmbarkStudios/cargo-deny-action@v1
+      - name: Install Rust nightly
+        uses: dtolnay/rust-toolchain@nightly
+        with:
+          components: rustfmt
+      - name: Install cargo-make
+        uses: taiki-e/install-action@cargo-make
+      - name: Check formatting
+        run: cargo make fmt
 
   clippy:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
       - name: Install Rust stable
         uses: dtolnay/rust-toolchain@stable
         with:
@@ -74,7 +72,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
       - name: Install Rust stable
         uses: dtolnay/rust-toolchain@stable
         with:
@@ -93,14 +91,13 @@ jobs:
 
   check:
     strategy:
-      fail-fast: false
       matrix:
         os: [ ubuntu-latest, windows-latest, macos-latest ]
-        toolchain: [ "1.70.0", "stable" ]
+        toolchain: [ "1.65.0", "stable" ]
     runs-on: ${{ matrix.os }}
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
       - name: Install Rust {{ matrix.toolchain }}
         uses: dtolnay/rust-toolchain@master
         with:
@@ -114,13 +111,12 @@ jobs:
 
   test-doc:
     strategy:
-      fail-fast: false
       matrix:
         os: [ ubuntu-latest, windows-latest, macos-latest ]
     runs-on: ${{ matrix.os }}
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
       - name: Install Rust stable
         uses: dtolnay/rust-toolchain@stable
       - name: Install cargo-make
@@ -132,10 +128,9 @@ jobs:
 
   test:
     strategy:
-      fail-fast: false
       matrix:
         os: [ ubuntu-latest, windows-latest, macos-latest ]
-        toolchain: [ "1.70.0", "stable" ]
+        toolchain: [ "1.65.0", "stable" ]
         backend: [ crossterm, termion, termwiz ]
         exclude:
           # termion is not supported on windows
@@ -144,7 +139,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
       - name: Install Rust ${{ matrix.toolchain }}}
         uses: dtolnay/rust-toolchain@master
         with:

.markdownlint.yaml

@@ -1,15 +1,9 @@
 # configuration for https://github.com/DavidAnson/markdownlint
 
-first-line-heading: false
 no-inline-html:
   allowed_elements:
     - img
     - details
     - summary
-    - div
-    - br
 line-length:
   line_length: 100
-
-# to support repeated headers in the changelog
-no-duplicate-heading: false

BREAKING-CHANGES.md

@@ -1,247 +0,0 @@
-# Breaking Changes
-
-This document contains a list of breaking changes in each version and some notes to help migrate
-between versions. It is compile manually from the commit history and changelog. We also tag PRs on
-github with a [breaking change] label.
-
-[breaking change]: (https://github.com/ratatui-org/ratatui/issues?q=label%3A%22breaking+change%22)
-
-## Summary
-
-This is a quick summary of the sections below:
-
-- Unreleased (0.24.1)
-  -
-
-- [v0.24.0](#v0240)
-  - MSRV is now 1.70.0
-  - `ScrollbarState`: `position`, `content_length`, and `viewport_content_length` are now `usize`
-  - `BorderType`: `line_symbols` is now `border_symbols` and returns `symbols::border::set`
-  - `Frame<'a, B: Backend>` is now `Frame<'a>`
-  - `Stylize` shorthands for `String` now consume the value and return `Span<'static>`
-  - `Spans` is removed
-- [v0.23.0](#v0230)
-  - `Scrollbar`: `track_symbol` now takes `Option<&str>`
-  - `Scrollbar`: symbols moved to `symbols` module
-  - MSRV is now 1.67.0
-- [v0.22.0](#v0220)
-  - serde representation of `Borders` and `Modifiers` has changed
-- [v0.21.0](#v0210)
-  - MSRV is now 1.65.0
-  - `terminal::ViewPort` is now an enum
-  - `"".as_ref()` must be annotated to implement `Into<Text<'a>>`
-  - `Marker::Block` renders as a block char instead of a bar char
-- [v0.20.0](#v0200)
-  - MSRV is now 1.63.0
-  - `List` no longer ignores empty strings
-
-## Unreleased (v0.24.1)
-
-### `Table::widths()` now accepts `AsRef<[Constraint]>` ([#628])
-
-Previously `Table::widths()` took a slice (`&'a [Constraint]`). This change will introduce clippy
-`needless_borrow` warnings for places where slices are passed to this method. To fix these, remove
-the `&`.
-
-E.g.
-
-```rust
-let table = Table::new(rows).widths(&[Constraint::Length(1)]);
-// becomes
-let table = Table::new(rows).widths([Constraint::Length(1)]);
-```
-
-[#628]: https://github.com/ratatui-org/ratatui/pull/628
-
-## [v0.24.0](https://github.com/ratatui-org/ratatui/releases/tag/v0.24.0)
-
-### ScrollbarState field type changed from `u16` to `usize` ([#456])
-
-[#456]: https://github.com/ratatui-org/ratatui/pull/456
-
-In order to support larger content lengths, the `position`, `content_length` and
-`viewport_content_length` methods on `ScrollbarState` now take `usize` instead of `u16`
-
-### `BorderType::line_symbols` renamed to `border_symbols` ([#529])
-
-[#529]: https://github.com/ratatui-org/ratatui/issues/529
-
-Applications can now set custom borders on a `Block` by calling `border_set()`. The
-`BorderType::line_symbols()` is renamed to `border_symbols()` and now returns a new struct
-`symbols::border::Set`. E.g.:
-
-```rust
-let line_set: symbols::line::Set = BorderType::line_symbols(BorderType::Plain);
-// becomes
-let border_set: symbols::border::Set = BorderType::border_symbols(BorderType::Plain);
-```
-
-### Generic `Backend` parameter removed from `Frame` ([#530])
-
-[#530]: https://github.com/ratatui-org/ratatui/issues/530
-
-`Frame` is no longer generic over Backend. Code that accepted `Frame<Backend>` will now need to
-accept `Frame`. To migrate existing code, remove any generic parameters from code that uses an
-instance of a Frame. E.g.:
-
-```rust
-fn ui<B: Backend>(frame: &mut Frame<B>) { ... }
-// becomes
-fn ui(frame: Frame) { ... }
-```
-
-### `Stylize` shorthands now consume rather than borrow `String` ([#466])
-
-[#466]: https://github.com/ratatui-org/ratatui/issues/466
-
-In order to support using `Stylize` shorthands (e.g. `"foo".red()`) on temporary `String` values, a
-new implementation of `Stylize` was added that returns a `Span<'static>`. This causes the value to
-be consumed rather than borrowed. Existing code that expects to use the string after a call will no
-longer compile. E.g.
-
-```rust
-let s = String::new("foo");
-let span1 = s.red();
-let span2 = s.blue(); // will no longer compile as s is consumed by the previous line
-// becomes
-let span1 = s.clone().red();
-let span2 = s.blue();
-```
-
-### Deprecated `Spans` type removed (replaced with `Line`) ([#426])
-
-[#426]: https://github.com/ratatui-org/ratatui/issues/426
-
-`Spans` was replaced with `Line` in 0.21.0. `Buffer::set_spans` was replaced with
-`Buffer::set_line`.
-
-```rust
-let spans = Spans::from(some_string_str_span_or_vec_span);
-buffer.set_spans(0, 0, spans, 10);
-// becomes
-let line - Line::from(some_string_str_span_or_vec_span);
-buffer.set_line(0, 0, line, 10);
-```
-
-## [v0.23.0](https://github.com/ratatui-org/ratatui/releases/tag/v0.23.0)
-
-### `Scrollbar::track_symbol()` now takes an `Option<&str>` instead of `&str` ([#360])
-
-[#360]: https://github.com/ratatui-org/ratatui/issues/360
-
-The track symbol of `Scrollbar` is now optional, this method now takes an optional value.
-
-```rust
-let scrollbar = Scrollbar::default().track_symbol("|");
-// becomes
-let scrollbar = Scrollbar::default().track_symbol(Some("|"));
-```
-
-### `Scrollbar` symbols moved to `symbols::scrollbar` and `widgets::scrollbar` module is private ([#330])
-
-[#330]: https://github.com/ratatui-org/ratatui/issues/330
-
-The symbols for defining scrollbars have been moved to the `symbols` module from the
-`widgets::scrollbar` module which is no longer public. To update your code update any imports to the
-new module locations. E.g.:
-
-```rust
-use ratatui::{widgets::scrollbar::{Scrollbar, Set}};
-// becomes
-use ratatui::{widgets::Scrollbar, symbols::scrollbar::Set} 
-```
-
-### MSRV updated to 1.67 ([#361])
-
-[#361]: https://github.com/ratatui-org/ratatui/issues/361
-
-The MSRV of ratatui is now 1.67 due to an MSRV update in a dependency (`time`).
-
-## [v0.22.0](https://github.com/ratatui-org/ratatui/releases/tag/v0.22.0)
-
-### bitflags updated to 2.3 ([#205])
-
-[#205]: https://github.com/ratatui-org/ratatui/issues/205
-
-The serde representation of bitflags has changed. Any existing serialized types that have Borders or
-Modifiers will need to be re-serialized. This is documented in the [bitflags
-changelog](https://github.com/bitflags/bitflags/blob/main/CHANGELOG.md#200-rc2)..
-
-## [v0.21.0](https://github.com/ratatui-org/ratatui/releases/tag/v0.21.0)
-
-### MSRV is 1.65.0  ([#171])
-
-[#171]: https://github.com/ratatui-org/ratatui/issues/171
-
-The minimum supported rust version is now 1.65.0.
-
-### `Terminal::with_options()` stabilized to allow configuring the viewport ([#114])
-
-[#114]: https://github.com/ratatui-org/ratatui/issues/114
-
-In order to support inline viewports, the unstable method `Terminal::with_options()` was stabilized
-and  `ViewPort` was changed from a struct to an enum.
-
-```rust
-let terminal = Terminal::with_options(backend, TerminalOptions {
-    viewport: Viewport::fixed(area),
-});
-// becomes
-let terminal = Terminal::with_options(backend, TerminalOptions {
-    viewport: Viewport::Fixed(area),
-});
-```
-
-### Code that binds `Into<Text<'a>>` now requires type annotations ([#168])
-
-[#168]: https://github.com/ratatui-org/ratatui/issues/168
-
-A new type `Masked` was introduced that implements `From<Text<'a>>`. This causes any code that did
-previously did not need to use type annotations to fail to compile.  To fix this, annotate or call
-to_string() / to_owned() / as_str() on the value. E.g.:
-
-```rust
-let paragraph = Paragraph::new("".as_ref());
-// becomes
-let paragraph = Paragraph::new("".as_str());
-```
-
-### `Marker::Block` now renders as a block rather than a bar character ([#133])
-
-[#133]: https://github.com/ratatui-org/ratatui/issues/133
-
-Code using the `Block` marker that previously rendered using a half block character (`'▀'``) now
-renders using the full block character (`'█'`). A new marker variant`Bar` is introduced to replace
-the existing code.
-
-```rust
-let canvas = Canvas::default().marker(Marker::Block);
-// becomes
-let canvas = Canvas::default().marker(Marker::Bar);
-```
-
-## [v0.20.0](https://github.com/ratatui-org/ratatui/releases/tag/v0.20.0)
-
-v0.20.0 was the first release of Ratatui - versions prior to this were release as tui-rs. See the
-[Changelog](./CHANGELOG.md) for more details.
-
-### MSRV is update to 1.63.0 ([#80])
-
-[#80]: https://github.com/ratatui-org/ratatui/issues/80
-
-The minimum supported rust version is 1.63.0
-
-### List no longer ignores empty string in items ([#42])
-
-[#42]: https://github.com/ratatui-org/ratatui/issues/42
-
-The following code now renders 3 items instead of 2. Code which relies on the previous behavior will
-need to manually filter empty items prior to display.
-
-```rust
-let items = vec![
-    ListItem::new("line one"),
-    ListItem::new(""),
-    ListItem::new("line four"),
-];
-```

CONTRIBUTING.md

@@ -29,11 +29,6 @@ change becomes a place where a bug may have been introduced. Consider splitting
 reformatting changes into a separate PR from those that make a behavioral change, as the tests help
 guarantee that the behavior is unchanged.
 
-### Code formatting
-
-Run `cargo make format` before committing to ensure that code is consistently formatted with
-rustfmt. Configuration is in [rustfmt.toml](./rustfmt.toml).
-
 ### Search `tui-rs` for similar work
 
 The original fork of Ratatui, [`tui-rs`](https://github.com/fdehau/tui-rs/), has a large amount of
@@ -118,59 +113,6 @@ exist to show coverage directly in your editor. E.g.:
 - <https://marketplace.visualstudio.com/items?itemName=ryanluker.vscode-coverage-gutters>
 - <https://github.com/alepez/vim-llvmcov>
 
-### Documentation
-
-Here are some guidelines for writing documentation in Ratatui.  
-Every public API **must** be documented.
-
-Keep in mind that Ratatui tends to attract beginner Rust users that may not be familiar with Rust
-concepts.
-
-#### Content
-
-The main doc comment should talk about the general features that the widget supports and introduce
-the concepts pointing to the various methods. Focus on interaction with various features and giving
-enough information that helps understand why you might want something.
-
-Examples should help users understand a particular usage, not test a feature. They should be as
-simple as possible.  
-Prefer hiding imports and using wildcards to keep things concise. Some imports may still be shown
-to demonstrate a particular non-obvious import (e.g. `Stylize` trait to use style methods).  
-Speaking of `Stylize`, you should use it over the more verbose style setters:
-
-```rust
-let style = Style::new().red().bold();
-// not
-let style = Style::default().fg(Color::Red).add_modifier(Modifiers::BOLD);
-```
-
-#### Format
-
-- First line is summary, second is blank, third onward is more detail  
-
-```rust
-/// Summary
-///
-/// A detailed description
-/// with examples.
-fn foo() {}
-```
-
-- Max line length is 100 characters  
-See [vscode rewrap extension](https://marketplace.visualstudio.com/items?itemName=stkb.rewrap)
-
-- Doc comments are above macros  
-i.e.
-
-```rust
-/// doc comment
-#[derive(Debug)]
-struct Foo {}
-```
-
-- Code items should be between backticks  
-i.e. ``[`Block`]``, **NOT** ``[Block]``
-
 ### Use of unsafe for optimization purposes
 
 We don't currently use any unsafe code in Ratatui, and would like to keep it that way. However there

Cargo.toml

@@ -1,8 +1,8 @@
 [package]
 name = "ratatui"
-version = "0.24.0" # crate version
+version = "0.22.0" # crate version
 authors = ["Florian Dehau <work@fdehau.com>", "The Ratatui Developers"]
-description = "A library that's all about cooking up terminal user interfaces"
+description = "A library to build rich terminal user interfaces or dashboards"
 documentation = "https://docs.rs/ratatui/latest/ratatui/"
 keywords = ["tui", "terminal", "dashboard"]
 repository = "https://github.com/ratatui-org/ratatui"
@@ -18,76 +18,16 @@ exclude = [
 ]
 autoexamples = true
 edition = "2021"
-rust-version = "1.70.0"
+rust-version = "1.65.0"
 
 [badges]
 
-[dependencies]
-crossterm = { version = "0.27", optional = true }
-termion = { version = "2.0", optional = true }
-termwiz = { version = "0.20.0", optional = true }
-
-serde = { version = "1", optional = true, features = ["derive"] }
-bitflags = "2.3"
-cassowary = "0.3"
-indoc = "2.0"
-itertools = "0.11"
-paste = "1.0.2"
-strum = { version = "0.25", features = ["derive"] }
-time = { version = "0.3.11", optional = true, features = ["local-offset"] }
-unicode-segmentation = "1.10"
-unicode-width = "0.1"
-document-features = { version = "0.2.7", optional = true }
-lru = "0.12.0"
-
-[dev-dependencies]
-anyhow = "1.0.71"
-argh = "0.1.12"
-better-panic = "0.3.0"
-cargo-husky = { version = "1.5.0", default-features = false, features = [
-  "user-hooks",
-] }
-criterion = { version = "0.5.1", features = ["html_reports"] }
-fakeit = "1.1"
-rand = "0.8.5"
-palette = "0.7.3"
-pretty_assertions = "1.4.0"
-
 [features]
-#! The crate provides a set of optional features that can be enabled in your `cargo.toml` file.
-#!
-## By default, we enable the crossterm backend as this is a reasonable choice for most applications
-## as it is supported on Linux/Mac/Windows systems. We also enable the `underline-color` feature
-## which allows you to set the underline color of text.
-default = ["crossterm", "underline-color"]
-#! Generally an application will only use one backend, so you should only enable one of the following features:
-## enables the [`CrosstermBackend`] backend and adds a dependency on the [Crossterm crate].
-crossterm = ["dep:crossterm"]
-## enables the [`TermionBackend`] backend and adds a dependency on the [Termion crate].
-termion = ["dep:termion"]
-## enables the [`TermwizBackend`] backend and adds a dependency on the [Termwiz crate].
-termwiz = ["dep:termwiz"]
-
-#! The following optional features are available for all backends:
-## enables serialization and deserialization of style and color types using the [Serde crate].
-## This is useful if you want to save themes to a file.
-serde = ["dep:serde", "bitflags/serde"]
-
-## enables the [`border!`] macro.
-macros = []
-
-## enables all widgets.
+default = ["crossterm"]
 all-widgets = ["widget-calendar"]
-
-#! Widgets that add dependencies are gated behind feature flags to prevent unused transitive
-#! dependencies. The available features are:
-## enables the [`calendar`] widget module and adds a dependency on the [Time crate].
-widget-calendar = ["dep:time"]
-
-#! Underline color is only supported by the [`CrosstermBackend`] backend, and is not supported
-#! on Windows 7.
-## enables the backend code that sets the underline color.
-underline-color = ["dep:crossterm"]
+widget-calendar = ["time"]
+macros = []
+serde = ["dep:serde", "bitflags/serde"]
 
 [package.metadata.docs.rs]
 all-features = true
@@ -95,27 +35,32 @@ all-features = true
 cargo-args = ["-Zunstable-options", "-Zrustdoc-scrape-examples"]
 rustdoc-args = ["--cfg", "docsrs"]
 
-[[bench]]
-name = "barchart"
-harness = false
+[dependencies]
+bitflags = "2.3"
+cassowary = "0.3"
+crossterm = { version = "0.26", optional = true }
+indoc = "2.0"
+paste = "1.0.2"
+serde = { version = "1", optional = true, features = ["derive"] }
+termion = { version = "2.0", optional = true }
+termwiz = { version = "0.20.0", optional = true }
+time = { version = "0.3.11", optional = true, features = ["local-offset"] }
+unicode-segmentation = "1.10"
+unicode-width = "0.1"
 
-[[bench]]
-name = "block"
-harness = false
-
-[[bench]]
-name = "list"
-harness = false
+[dev-dependencies]
+anyhow = "1.0.71"
+argh = "0.1"
+cargo-husky = { version = "1.5.0", default-features = false, features = ["user-hooks"] }
+criterion = { version = "0.5", features = ["html_reports"] }
+fakeit = "1.1"
+itertools = "0.10"
+rand = "0.8"
 
 [[bench]]
 name = "paragraph"
 harness = false
 
-[[bench]]
-name = "sparkline"
-harness = false
-
-
 [[example]]
 name = "barchart"
 required-features = ["crossterm"]
@@ -141,17 +86,6 @@ name = "chart"
 required-features = ["crossterm"]
 doc-scrape-examples = true
 
-[[example]]
-name = "colors"
-required-features = ["crossterm"]
-# this example is a bit verbose, so we don't want to include it in the docs
-doc-scrape-examples = false
-
-[[example]]
-name = "colors_rgb"
-required-features = ["crossterm"]
-doc-scrape-examples = true
-
 [[example]]
 name = "custom_widget"
 required-features = ["crossterm"]
@@ -162,16 +96,6 @@ name = "demo"
 # this runs for all of the terminal backends, so it can't be built using --all-features or scraped
 doc-scrape-examples = false
 
-[[example]]
-name = "demo2"
-required-features = ["crossterm", "widget-calendar"]
-doc-scrape-examples = true
-
-[[example]]
-name = "docsrs"
-required-features = ["crossterm"]
-doc-scrape-examples = false
-
 [[example]]
 name = "gauge"
 required-features = ["crossterm"]
@@ -192,12 +116,6 @@ name = "list"
 required-features = ["crossterm"]
 doc-scrape-examples = true
 
-[[example]]
-name = "modifiers"
-required-features = ["crossterm"]
-# this example is a bit verbose, so we don't want to include it in the docs
-doc-scrape-examples = false
-
 [[example]]
 name = "panic"
 required-features = ["crossterm"]

Makefile.toml

@@ -7,149 +7,159 @@ skip_core_tasks = true
 # all features except the backend ones
 ALL_FEATURES = "all-widgets,macros,serde"
 
-# Windows does not support building termion, so this avoids the build failure by providing two
-# sets of flags, one for Windows and one for other platforms.
-# Windows: --features=all-widgets,macros,serde,crossterm,termwiz,underline-color
-# Other: --features=all-widgets,macros,serde,crossterm,termion,termwiz,underline-color
-ALL_FEATURES_FLAG = { source = "${CARGO_MAKE_RUST_TARGET_OS}", default_value = "--features=all-widgets,macros,serde,crossterm,termion,termwiz", mapping = { "windows" = "--features=all-widgets,macros,serde,crossterm,termwiz" } }
-
 [tasks.default]
 alias = "ci"
 
 [tasks.ci]
-description = "Run continuous integration tasks"
-dependencies = ["lint-style", "clippy", "check", "test"]
+dependencies = [
+  "style-check",
+  "clippy",
+  "check",
+  "test",
+]
 
-[tasks.lint-style]
-description = "Lint code style (formatting, typos, docs)"
-dependencies = ["lint-format", "lint-typos", "lint-docs"]
+[tasks.style-check]
+dependencies = ["fmt", "typos"]
 
-[tasks.lint-format]
-description = "Lint code formatting"
+[tasks.fmt]
 toolchain = "nightly"
 command = "cargo"
 args = ["fmt", "--all", "--check"]
 
-[tasks.format]
-description = "Fix code formatting"
-toolchain = "nightly"
-command = "cargo"
-args = ["fmt", "--all"]
-
-[tasks.lint-typos]
-description = "Run typo checks"
+[tasks.typos]
 install_crate = { crate_name = "typos-cli", binary = "typos", test_arg = "--version" }
 command = "typos"
 
-[tasks.lint-docs]
-description = "Check documentation for errors and warnings"
-toolchain = "nightly"
-command = "cargo"
-args = [
-  "rustdoc",
-  "--no-default-features",
-  "${ALL_FEATURES_FLAG}",
-  "--",
-  "-Zunstable-options",
-  "--check",
-  "-Dwarnings",
-]
-
 [tasks.check]
-description = "Check code for errors and warnings"
 command = "cargo"
 args = [
   "check",
   "--all-targets",
-  "--no-default-features",
-  "${ALL_FEATURES_FLAG}",
+  "--all-features"
+]
+
+[tasks.check.windows]
+args = [
+  "check",
+  "--all-targets",
+  "--no-default-features", "--features", "${ALL_FEATURES},crossterm,termwiz"
 ]
 
 [tasks.build]
-description = "Compile the project"
 command = "cargo"
 args = [
   "build",
   "--all-targets",
-  "--no-default-features",
-  "${ALL_FEATURES_FLAG}",
+  "--all-features",
+]
+
+[tasks.build.windows]
+args = [
+  "build",
+  "--all-targets",
+  "--no-default-features", "--features", "${ALL_FEATURES},crossterm,termwiz"
 ]
 
 [tasks.clippy]
-description = "Run Clippy for linting"
 command = "cargo"
 args = [
   "clippy",
   "--all-targets",
   "--tests",
   "--benches",
-  "--no-default-features",
-  "${ALL_FEATURES_FLAG}",
+  "--all-features",
+  "--",
+  "-D",
+  "warnings",
+]
+
+[tasks.clippy.windows]
+args = [
+  "clippy",
+  "--all-targets",
+  "--tests",
+  "--benches",
+  "--no-default-features", "--features", "${ALL_FEATURES},crossterm,termwiz",
   "--",
   "-D",
   "warnings",
 ]
 
 [tasks.test]
-description = "Run tests"
-dependencies = ["test-doc"]
+dependencies = [
+  "test-doc",
+]
 command = "cargo"
 args = [
   "test",
   "--all-targets",
-  "--no-default-features",
-  "${ALL_FEATURES_FLAG}",
+  "--all-features",
+]
+
+
+[tasks.test-windows]
+dependencies = [
+  "test-doc",
+]
+args = [
+  "test",
+  "--all-targets",
+  "--no-default-features", "--features", "${ALL_FEATURES},crossterm,termwiz"
 ]
 
 [tasks.test-doc]
-description = "Run documentation tests"
 command = "cargo"
-args = ["test", "--doc", "--no-default-features", "${ALL_FEATURES_FLAG}"]
+args = [
+  "test", "--doc",
+  "--all-features",
+]
+
+[tasks.test-doc.windows]
+args = [
+  "test", "--doc",
+  "--no-default-features", "--features", "${ALL_FEATURES},crossterm,termwiz"
+]
 
 [tasks.test-backend]
 # takes a command line parameter to specify the backend to test (e.g. "crossterm")
-description = "Run backend-specific tests"
 command = "cargo"
 args = [
   "test",
   "--all-targets",
-  "--no-default-features",
-  "--features",
-  "${ALL_FEATURES},${@}",
+  "--no-default-features", "--features", "${ALL_FEATURES},${@}"
 ]
 
+
 [tasks.coverage]
-description = "Generate code coverage report"
 command = "cargo"
 args = [
   "llvm-cov",
   "--lcov",
-  "--output-path",
-  "target/lcov.info",
+  "--output-path", "target/lcov.info",
+  "--all-features",
+]
+
+[tasks.coverage.windows]
+command = "cargo"
+args = [
+  "llvm-cov",
+  "--lcov",
+  "--output-path", "target/lcov.info",
   "--no-default-features",
-  "${ALL_FEATURES_FLAG}",
+  "--features", "${ALL_FEATURES},crossterm,termwiz",
 ]
 
 [tasks.run-example]
 private = true
 condition = { env_set = ["TUI_EXAMPLE_NAME"] }
 command = "cargo"
-args = [
-  "run",
-  "--release",
-  "--example",
-  "${TUI_EXAMPLE_NAME}",
-  "--features",
-  "all-widgets",
-]
+args = ["run", "--release", "--example", "${TUI_EXAMPLE_NAME}", "--features", "all-widgets"]
 
 [tasks.build-examples]
-description = "Compile project examples"
 command = "cargo"
 args = ["build", "--examples", "--release", "--features", "all-widgets"]
 
 [tasks.run-examples]
-description = "Run project examples"
 dependencies = ["build-examples"]
 script = '''
 #!@duckscript

README.md

@@ -1,347 +1,137 @@
+# Ratatui
+
+<img align="left" src="https://avatars.githubusercontent.com/u/125200832?s=128&v=4">
+
+`ratatui` is a [Rust](https://www.rust-lang.org) library to build rich terminal user interfaces and
+dashboards. It is a community fork of the original [tui-rs](https://github.com/fdehau/tui-rs)
+project.
+
+[![Crates.io](https://img.shields.io/crates/v/ratatui?logo=rust&style=flat-square)](https://crates.io/crates/ratatui)
+[![License](https://img.shields.io/crates/l/ratatui?style=flat-square)](./LICENSE) [![GitHub CI
+Status](https://img.shields.io/github/actions/workflow/status/ratatui-org/ratatui/ci.yml?style=flat-square&logo=github)](https://github.com/ratatui-org/ratatui/actions?query=workflow%3ACI+)
+[![Docs.rs](https://img.shields.io/docsrs/ratatui?logo=rust&style=flat-square)](https://docs.rs/crate/ratatui/)  
+[![Dependency
+Status](https://deps.rs/repo/github/ratatui-org/ratatui/status.svg?style=flat-square)](https://deps.rs/repo/github/ratatui-org/ratatui)
+[![Codecov](https://img.shields.io/codecov/c/github/ratatui-org/ratatui?logo=codecov&style=flat-square&token=BAQ8SOKEST)](https://app.codecov.io/gh/ratatui-org/ratatui)
+[![Discord](https://img.shields.io/discord/1070692720437383208?label=discord&logo=discord&style=flat-square)](https://discord.gg/pMCEU9hNEj)
+
+<!-- See RELEASE.md for instructions on creating the demo gif --->
+![Demo of Ratatui](https://github.com/ratatui-org/ratatui/assets/24392180/93ab0e38-93e0-4ae0-a31b-91ae6c393185)
+
 <details>
 <summary>Table of Contents</summary>
 
-- [Ratatui](#ratatui)
-  - [Installation](#installation)
-  - [Introduction](#introduction)
-  - [Other Documentation](#other-documentation)
-  - [Quickstart](#quickstart)
-  - [Status of this fork](#status-of-this-fork)
-  - [Rust version requirements](#rust-version-requirements)
-  - [Widgets](#widgets)
-    - [Built in](#built-in)
-    - [Third\-party libraries, bootstrapping templates and
+* [Ratatui](#ratatui)
+  * [Installation](#installation)
+  * [Introduction](#introduction)
+  * [Quickstart](#quickstart)
+  * [Status of this fork](#status-of-this-fork)
+  * [Rust version requirements](#rust-version-requirements)
+  * [Documentation](#documentation)
+  * [Examples](#examples)
+  * [Widgets](#widgets)
+    * [Built in](#built-in)
+    * [Third\-party libraries, bootstrapping templates and
       widgets](#third-party-libraries-bootstrapping-templates-and-widgets)
-  - [Apps](#apps)
-  - [Alternatives](#alternatives)
-  - [Acknowledgments](#acknowledgments)
-  - [License](#license)
+  * [Apps](#apps)
+  * [Alternatives](#alternatives)
+  * [Contributors](#contributors)
+  * [Acknowledgments](#acknowledgments)
+  * [License](#license)
 
 </details>
 
-<!-- cargo-rdme start -->
-
-![Demo](https://raw.githubusercontent.com/ratatui-org/ratatui/b33c878808c4c40591d7a2d9f9d94d6fee95a96f/examples/demo2.gif)
-
-<div align="center">
-
-[![Crate Badge]](https://crates.io/crates/ratatui) [![License Badge]](./LICENSE) [![CI
-Badge]](https://github.com/ratatui-org/ratatui/actions?query=workflow%3ACI+) [![Docs
-Badge]](https://docs.rs/crate/ratatui/)<br>
-[![Dependencies Badge]](https://deps.rs/repo/github/ratatui-org/ratatui) [![Codecov
-Badge]](https://app.codecov.io/gh/ratatui-org/ratatui) [![Discord
-Badge]](https://discord.gg/pMCEU9hNEj) [![Matrix
-Badge]](https://matrix.to/#/#ratatui:matrix.org)<br>
-[Documentation](https://docs.rs/ratatui) · [Ratatui Book](https://ratatui.rs) ·
-[Examples](https://github.com/ratatui-org/ratatui/tree/main/examples) · [Report a
-bug](https://github.com/ratatui-org/ratatui/issues/new?labels=bug&projects=&template=bug_report.md)
-· [Request a
-Feature](https://github.com/ratatui-org/ratatui/issues/new?labels=enhancement&projects=&template=feature_request.md)
-· [Send a Pull Request](https://github.com/ratatui-org/ratatui/compare)
-
-</div>
-
-# Ratatui
-
-[Ratatui] is a crate for cooking up terminal user interfaces in rust. It is a lightweight
-library that provides a set of widgets and utilities to build complex rust TUIs. Ratatui was
-forked from the [Tui-rs crate] in 2023 in order to continue its development.
-
 ## Installation
 
-Add `ratatui` and `crossterm` as dependencies to your cargo.toml:
-
 ```shell
-cargo add ratatui crossterm
+cargo add ratatui --features all-widgets
 ```
 
-Ratatui uses [Crossterm] by default as it works on most platforms. See the [Installation]
-section of the [Ratatui Book] for more details on how to use other backends ([Termion] /
-[Termwiz]).
+Or modify your `Cargo.toml`
+
+```toml
+[dependencies]
+ratatui = { version = "0.22.0", features = ["all-widgets"]}
+```
+
+Ratatui is mostly backwards compatible with `tui-rs`. To migrate an existing project, it may be
+easier to rename the ratatui dependency to `tui` rather than updating every usage of the crate.
+E.g.:
+
+```toml
+[dependencies]
+tui = { package = "ratatui", version = "0.22.0", features = ["all-widgets"]}
+```
 
 ## Introduction
 
-Ratatui is based on the principle of immediate rendering with intermediate buffers. This means
-that for each frame, your app must render all widgets that are supposed to be part of the UI.
-This is in contrast to the retained mode style of rendering where widgets are updated and then
-automatically redrawn on the next frame. See the [Rendering] section of the [Ratatui Book] for
-more info.
+`ratatui` is a terminal UI library that supports multiple backends:
 
-## Other documentation
+* [crossterm](https://github.com/crossterm-rs/crossterm) [default]
+* [termion](https://github.com/ticki/termion)
+* [termwiz](https://github.com/wez/wezterm/tree/master/termwiz)
 
-- [Ratatui Book] - explains the library's concepts and provides step-by-step tutorials
-- [Examples] - a collection of examples that demonstrate how to use the library.
-- [API Documentation] - the full API documentation for the library on docs.rs.
-- [Changelog] - generated by [git-cliff] utilizing [Conventional Commits].
-- [Contributing] - Please read this if you are interested in contributing to the project.
-- [Breaking Changes] - a list of breaking changes in the library.
+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. So, the implementation try to minimize the number of ansi escapes sequences
+generated to draw the updated UI. In practice, given the speed of `Rust` the overhead rather 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.
+
+We keep a [CHANGELOG](./CHANGELOG.md) generated by [git-cliff](https://github.com/orhun/git-cliff)
+utilizing [Conventional Commits](https://www.conventionalcommits.org/).
 
 ## Quickstart
 
 The following example demonstrates the minimal amount of code necessary to setup a terminal and
 render "Hello World!". The full code for this example which contains a little more detail is in
-[hello_world.rs]. For more guidance on different ways to structure your application see the
-[Application Patterns] and [Hello World tutorial] sections in the [Ratatui Book] and the various
-[Examples]. There are also several starter templates available:
-
-- [rust-tui-template]
-- [ratatui-async-template] (book and template)
-- [simple-tui-rs]
-
-Every application built with `ratatui` needs to implement the following steps:
-
-- Initialize the terminal
-- A main loop to:
-  - Handle input events
-  - Draw the UI
-- Restore the terminal state
-
-The library contains a [`prelude`] module that re-exports the most commonly used traits and
-types for convenience. Most examples in the documentation will use this instead of showing the
-full path of each type.
-
-### Initialize and restore the terminal
-
-The [`Terminal`] type is the main entry point for any Ratatui application. It is a light
-abstraction over a choice of [`Backend`] implementations that provides functionality to draw
-each frame, clear the screen, hide the cursor, etc. It is parametrized over any type that
-implements the [`Backend`] trait which has implementations for [Crossterm], [Termion] and
-[Termwiz].
-
-Most applications should enter the Alternate Screen when starting and leave it when exiting and
-also enable raw mode to disable line buffering and enable reading key events. See the [`backend`
-module] and the [Backends] section of the [Ratatui Book] for more info.
-
-### Drawing the UI
-
-The drawing logic is delegated to a closure that takes a [`Frame`] instance as argument. The
-[`Frame`] provides the size of the area to draw to and allows the app to render any [`Widget`]
-using the provided [`render_widget`] method. See the [Widgets] section of the [Ratatui Book] for
-more info.
-
-### Handling events
-
-Ratatui does not include any input handling. Instead event handling can be implemented by
-calling backend library methods directly. See the [Handling Events] section of the [Ratatui
-Book] for more info. For example, if you are using [Crossterm], you can use the
-[`crossterm::event`] module to handle events.
-
-### Example
+[hello_world.rs](./examples/hello_world.rs). For more guidance on how to create Ratatui apps, see
+the [Docs](https://docs.rs/ratatui) and [Examples](#examples). There is also a starter template
+available at [rust-tui-template](https://github.com/ratatui-org/rust-tui-template).
 
 ```rust
-use std::io::{self, stdout};
-use crossterm::{
-    event::{self, Event, KeyCode},
-    ExecutableCommand,
-    terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen}
-};
-use ratatui::{prelude::*, widgets::*};
-
-fn main() -> io::Result<()> {
-    enable_raw_mode()?;
-    stdout().execute(EnterAlternateScreen)?;
-    let mut terminal = Terminal::new(CrosstermBackend::new(stdout()))?;
-
-    let mut should_quit = false;
-    while !should_quit {
-        terminal.draw(ui)?;
-        should_quit = handle_events()?;
-    }
-
-    disable_raw_mode()?;
-    stdout().execute(LeaveAlternateScreen)?;
+fn main() -> Result<(), Box<dyn Error>> {
+    let mut terminal = setup_terminal()?;
+    run(&mut terminal)?;
+    restore_terminal(&mut terminal)?;
     Ok(())
 }
 
-fn handle_events() -> io::Result<bool> {
-    if event::poll(std::time::Duration::from_millis(50))? {
-        if let Event::Key(key) = event::read()? {
-            if key.kind == event::KeyEventKind::Press && key.code == KeyCode::Char('q') {
-                return Ok(true);
+fn setup_terminal() -> Result<Terminal<CrosstermBackend<Stdout>>, Box<dyn Error>> {
+    let mut stdout = io::stdout();
+    enable_raw_mode()?;
+    execute!(stdout, EnterAlternateScreen)?;
+    Ok(Terminal::new(CrosstermBackend::new(stdout))?)
+}
+
+fn restore_terminal(
+    terminal: &mut Terminal<CrosstermBackend<Stdout>>,
+) -> Result<(), Box<dyn Error>> {
+    disable_raw_mode()?;
+    execute!(terminal.backend_mut(), LeaveAlternateScreen,)?;
+    Ok(terminal.show_cursor()?)
+}
+
+fn run(terminal: &mut Terminal<CrosstermBackend<Stdout>>) -> Result<(), Box<dyn Error>> {
+    Ok(loop {
+        terminal.draw(|frame| {
+            let greeting = Paragraph::new("Hello World!");
+            frame.render_widget(greeting, frame.size());
+        })?;
+        if event::poll(Duration::from_millis(250))? {
+            if let Event::Key(key) = event::read()? {
+                if KeyCode::Char('q') == key.code {
+                    break;
+                }
             }
-       }
-    }
-    Ok(false)
-}
-
-fn ui(frame: &mut Frame) {
-    frame.render_widget(
-        Paragraph::new("Hello World!")
-            .block(Block::default().title("Greeting").borders(Borders::ALL)),
-        frame.size(),
-    );
+        }
+    })
 }
 ```
 
-Running this example produces the following output:
-
-![docsrs-hello]
-
-## Layout
-
-The library comes with a basic yet useful layout management object called [`Layout`] which
-allows you to split the available space into multiple areas and then render widgets in each
-area. This lets you describe a responsive terminal UI by nesting layouts. See the [Layout]
-section of the [Ratatui Book] for more info.
-
-```rust
-use ratatui::{prelude::*, widgets::*};
-
-fn ui(frame: &mut Frame) {
-    let main_layout = Layout::default()
-        .direction(Direction::Vertical)
-        .constraints([
-            Constraint::Length(1),
-            Constraint::Min(0),
-            Constraint::Length(1),
-        ])
-        .split(frame.size());
-    frame.render_widget(
-        Block::new().borders(Borders::TOP).title("Title Bar"),
-        main_layout[0],
-    );
-    frame.render_widget(
-        Block::new().borders(Borders::TOP).title("Status Bar"),
-        main_layout[2],
-    );
-
-    let inner_layout = Layout::default()
-        .direction(Direction::Horizontal)
-        .constraints([Constraint::Percentage(50), Constraint::Percentage(50)])
-        .split(main_layout[1]);
-    frame.render_widget(
-        Block::default().borders(Borders::ALL).title("Left"),
-        inner_layout[0],
-    );
-    frame.render_widget(
-        Block::default().borders(Borders::ALL).title("Right"),
-        inner_layout[1],
-    );
-}
-```
-
-Running this example produces the following output:
-
-![docsrs-layout]
-
-## Text and styling
-
-The [`Text`], [`Line`] and [`Span`] types are the building blocks of the library and are used in
-many places. [`Text`] is a list of [`Line`]s and a [`Line`] is a list of [`Span`]s. A [`Span`]
-is a string with a specific style.
-
-The [`style` module] provides types that represent the various styling options. The most
-important one is [`Style`] which represents the foreground and background colors and the text
-attributes of a [`Span`]. The [`style` module] also provides a [`Stylize`] trait that allows
-short-hand syntax to apply a style to widgets and text. See the [Styling Text] section of the
-[Ratatui Book] for more info.
-
-```rust
-use ratatui::{prelude::*, widgets::*};
-
-fn ui(frame: &mut Frame) {
-    let areas = Layout::default()
-        .direction(Direction::Vertical)
-        .constraints([
-            Constraint::Length(1),
-            Constraint::Length(1),
-            Constraint::Length(1),
-            Constraint::Length(1),
-            Constraint::Min(0),
-        ])
-        .split(frame.size());
-
-    let span1 = Span::raw("Hello ");
-    let span2 = Span::styled(
-        "World",
-        Style::new()
-            .fg(Color::Green)
-            .bg(Color::White)
-            .add_modifier(Modifier::BOLD),
-    );
-    let span3 = "!".red().on_light_yellow().italic();
-
-    let line = Line::from(vec![span1, span2, span3]);
-    let text: Text = Text::from(vec![line]);
-
-    frame.render_widget(Paragraph::new(text), areas[0]);
-    // or using the short-hand syntax and implicit conversions
-    frame.render_widget(
-        Paragraph::new("Hello World!".red().on_white().bold()),
-        areas[1],
-    );
-
-    // to style the whole widget instead of just the text
-    frame.render_widget(
-        Paragraph::new("Hello World!").style(Style::new().red().on_white()),
-        areas[2],
-    );
-    // or using the short-hand syntax
-    frame.render_widget(Paragraph::new("Hello World!").blue().on_yellow(), areas[3]);
-}
-```
-
-Running this example produces the following output:
-
-![docsrs-styling]
-
-[Ratatui Book]: https://ratatui.rs
-[Installation]: https://ratatui.rs/installation.html
-[Rendering]: https://ratatui.rs/concepts/rendering/index.html
-[Application Patterns]: https://ratatui.rs/concepts/application_patterns/index.html
-[Hello World tutorial]: https://ratatui.rs/tutorial/hello_world.html
-[Backends]: https://ratatui.rs/concepts/backends/index.html
-[Widgets]: https://ratatui.rs/how-to/widgets/index.html
-[Handling Events]: https://ratatui.rs/concepts/event_handling.html
-[Layout]: https://ratatui.rs/how-to/layout/index.html
-[Styling Text]: https://ratatui.rs/how-to/render/style-text.html
-[rust-tui-template]: https://github.com/ratatui-org/rust-tui-template
-[ratatui-async-template]: https://ratatui-org.github.io/ratatui-async-template/
-[simple-tui-rs]: https://github.com/pmsanford/simple-tui-rs
-[Examples]: https://github.com/ratatui-org/ratatui/tree/main/examples
-[git-cliff]: https://github.com/orhun/git-cliff
-[Conventional Commits]: https://www.conventionalcommits.org
-[API Documentation]: https://docs.rs/ratatui
-[Changelog]: https://github.com/ratatui-org/ratatui/blob/main/CHANGELOG.md
-[Contributing]: https://github.com/ratatui-org/ratatui/blob/main/CONTRIBUTING.md
-[Breaking Changes]: https://github.com/ratatui-org/ratatui/blob/main/BREAKING-CHANGES.md
-[docsrs-hello]: https://github.com/ratatui-org/ratatui/blob/c3c3c289b1eb8d562afb1931adb4dc719cd48490/examples/docsrs-hello.png?raw=true
-[docsrs-layout]: https://github.com/ratatui-org/ratatui/blob/c3c3c289b1eb8d562afb1931adb4dc719cd48490/examples/docsrs-layout.png?raw=true
-[docsrs-styling]: https://github.com/ratatui-org/ratatui/blob/c3c3c289b1eb8d562afb1931adb4dc719cd48490/examples/docsrs-styling.png?raw=true
-[`Frame`]: terminal::Frame
-[`render_widget`]: terminal::Frame::render_widget
-[`Widget`]: widgets::Widget
-[`Layout`]: layout::Layout
-[`Text`]: text::Text
-[`Line`]: text::Line
-[`Span`]: text::Span
-[`Style`]: style::Style
-[`style` module]: style
-[`Stylize`]: style::Stylize
-[`Backend`]: backend::Backend
-[`backend` module]: backend
-[`crossterm::event`]: https://docs.rs/crossterm/latest/crossterm/event/index.html
-[Ratatui]: https://ratatui.rs
-[Crossterm]: https://crates.io/crates/crossterm
-[Termion]: https://crates.io/crates/termion
-[Termwiz]: https://crates.io/crates/termwiz
-[Tui-rs crate]: https://crates.io/crates/tui
-[hello_world.rs]: https://github.com/ratatui-org/ratatui/blob/main/examples/hello_world.rs
-[Crate Badge]: https://img.shields.io/crates/v/ratatui?logo=rust&style=flat-square
-[CI Badge]:
-    https://img.shields.io/github/actions/workflow/status/ratatui-org/ratatui/ci.yml?style=flat-square&logo=github
-[Codecov Badge]:
-    https://img.shields.io/codecov/c/github/ratatui-org/ratatui?logo=codecov&style=flat-square&token=BAQ8SOKEST
-[Dependencies Badge]: https://deps.rs/repo/github/ratatui-org/ratatui/status.svg?style=flat-square
-[Discord Badge]:
-    https://img.shields.io/discord/1070692720437383208?label=discord&logo=discord&style=flat-square
-[Docs Badge]: https://img.shields.io/docsrs/ratatui?logo=rust&style=flat-square
-[License Badge]: https://img.shields.io/crates/l/ratatui?style=flat-square
-[Matrix Badge]:
-    https://img.shields.io/matrix/ratatui-general%3Amatrix.org?style=flat-square&logo=matrix&label=Matrix
-
-<!-- cargo-rdme end -->
-
 ## Status of this fork
 
 In response to the original maintainer [**Florian Dehau**](https://github.com/fdehau)'s issue
@@ -350,19 +140,46 @@ the community forked the project and created this crate. We look forward to cont
 started by Florian 🚀
 
 In order to organize ourselves, we currently use a [Discord server](https://discord.gg/pMCEU9hNEj),
-feel free to join and come chat! There is also a [Matrix](https://matrix.org/) bridge available at
-[#ratatui:matrix.org](https://matrix.to/#/#ratatui:matrix.org).
-
-While we do utilize Discord for coordinating, it's not essential for contributing.
-Our primary open-source workflow is centered around GitHub.
-For significant discussions, we rely on GitHub — please open an issue, a discussion or a PR.
+feel free to join and come chat! There are also plans to implement a [Matrix](https://matrix.org/)
+bridge in the near future. **Discord is not a MUST to contribute**. We follow a pretty standard
+github centered open source workflow keeping the most important conversations on GitHub, open an
+issue or PR and it will be addressed. 😄
 
 Please make sure you read the updated [contributing](./CONTRIBUTING.md) guidelines, especially if
 you are interested in working on a PR or issue opened in the previous repository.
 
 ## Rust version requirements
 
-Since version 0.23.0, The Minimum Supported Rust Version (MSRV) of `ratatui` is 1.67.0.
+Since version 0.21.0, The Minimum Supported Rust Version (MSRV) of `ratatui` is 1.65.0.
+
+## Documentation
+
+The documentation can be found on [docs.rs.](https://docs.rs/ratatui)
+
+## Examples
+
+The demo shown in the gif above is available on all available backends.
+
+```shell
+# crossterm
+cargo run --example demo
+# termion
+cargo run --example demo --no-default-features --features=termion
+# termwiz
+cargo run --example demo --no-default-features --features=termwiz
+```
+
+The UI code for this is in [examples/demo/ui.rs](./examples/demo/ui.rs) while the application state
+is in [examples/demo/app.rs](./examples/demo/app.rs).
+
+If the user interface contains glyphs that are not displayed correctly by your terminal, you may
+want to run the demo without those symbols:
+
+```shell
+cargo run --example demo --release -- --tick-rate 200 --enhanced-graphics false
+```
+
+More examples are available in the [examples](./examples/) folder.
 
 ## Widgets
 
@@ -371,21 +188,21 @@ Since version 0.23.0, The Minimum Supported Rust Version (MSRV) of `ratatui` is
 The library comes with the following
 [widgets](https://docs.rs/ratatui/latest/ratatui/widgets/index.html):
 
-- [BarChart](https://docs.rs/ratatui/latest/ratatui/widgets/struct.BarChart.html)
-- [Block](https://docs.rs/ratatui/latest/ratatui/widgets/block/struct.Block.html)
-- [Calendar](https://docs.rs/ratatui/latest/ratatui/widgets/calendar/index.html)
-- [Canvas](https://docs.rs/ratatui/latest/ratatui/widgets/canvas/struct.Canvas.html) which allows
+* [BarChart](https://docs.rs/ratatui/latest/ratatui/widgets/struct.BarChart.html)
+* [Block](https://docs.rs/ratatui/latest/ratatui/widgets/block/struct.Block.html)
+* [Calendar](https://docs.rs/ratatui/latest/ratatui/widgets/calendar/index.html)
+* [Canvas](https://docs.rs/ratatui/latest/ratatui/widgets/canvas/struct.Canvas.html) which allows
   rendering [points, lines, shapes and a world
   map](https://docs.rs/ratatui/latest/ratatui/widgets/canvas/index.html)
-- [Chart](https://docs.rs/ratatui/latest/ratatui/widgets/struct.Chart.html)
-- [Clear](https://docs.rs/ratatui/latest/ratatui/widgets/struct.Clear.html)
-- [Gauge](https://docs.rs/ratatui/latest/ratatui/widgets/struct.Gauge.html)
-- [List](https://docs.rs/ratatui/latest/ratatui/widgets/struct.List.html)
-- [Paragraph](https://docs.rs/ratatui/latest/ratatui/widgets/struct.Paragraph.html)
-- [Scrollbar](https://docs.rs/ratatui/latest/ratatui/widgets/scrollbar/struct.Scrollbar.html)
-- [Sparkline](https://docs.rs/ratatui/latest/ratatui/widgets/struct.Sparkline.html)
-- [Table](https://docs.rs/ratatui/latest/ratatui/widgets/struct.Table.html)
-- [Tabs](https://docs.rs/ratatui/latest/ratatui/widgets/struct.Tabs.html)
+* [Chart](https://docs.rs/ratatui/latest/ratatui/widgets/struct.Chart.html)
+* [Clear](https://docs.rs/ratatui/latest/ratatui/widgets/struct.Clear.html)
+* [Gauge](https://docs.rs/ratatui/latest/ratatui/widgets/struct.Gauge.html)
+* [List](https://docs.rs/ratatui/latest/ratatui/widgets/struct.List.html)
+* [Paragraph](https://docs.rs/ratatui/latest/ratatui/widgets/struct.Paragraph.html)
+* [Scrollbar](https://docs.rs/ratatui/latest/ratatui/widgets/scrollbar/struct.Scrollbar.html)
+* [Sparkline](https://docs.rs/ratatui/latest/ratatui/widgets/struct.Sparkline.html)
+* [Table](https://docs.rs/ratatui/latest/ratatui/widgets/struct.Table.html)
+* [Tabs](https://docs.rs/ratatui/latest/ratatui/widgets/struct.Tabs.html)
 
 Each widget has an associated example which can be found in the [examples](./examples/) folder. Run
 each examples with cargo (e.g. to run the gauge example `cargo run --example gauge`), and quit by
@@ -396,31 +213,31 @@ be installed with `cargo install cargo-make`).
 
 ### Third-party libraries, bootstrapping templates and widgets
 
-- [ansi-to-tui](https://github.com/uttarayan21/ansi-to-tui) — Convert ansi colored text to
-  `ratatui::text::Text`
-- [color-to-tui](https://github.com/uttarayan21/color-to-tui) — Parse hex colors to
-  `ratatui::style::Color`
-- [rust-tui-template](https://github.com/ratatui-org/rust-tui-template) — A template for
-  bootstrapping a Rust TUI application with Tui-rs & crossterm
-- [simple-tui-rs](https://github.com/pmsanford/simple-tui-rs) — A simple example tui-rs app
-- [tui-builder](https://github.com/jkelleyrtp/tui-builder) — Batteries-included MVC framework for
+* [ansi-to-tui](https://github.com/uttarayan21/ansi-to-tui) — Convert ansi colored text to
+  `tui::text::Text`
+* [color-to-tui](https://github.com/uttarayan21/color-to-tui) — Parse hex colors to
+  `tui::style::Color`
+* [rust-tui-template](https://github.com/ratatui-org/rust-tui-template) — A template for bootstrapping a
+  Rust TUI application with Tui-rs & crossterm
+* [simple-tui-rs](https://github.com/pmsanford/simple-tui-rs) — A simple example tui-rs app
+* [tui-builder](https://github.com/jkelleyrtp/tui-builder) — Batteries-included MVC framework for
   Tui-rs + Crossterm apps
-- [tui-clap](https://github.com/kegesch/tui-clap-rs) — Use clap-rs together with Tui-rs
-- [tui-log](https://github.com/kegesch/tui-log-rs) — Example of how to use logging with Tui-rs
-- [tui-logger](https://github.com/gin66/tui-logger) — Logger and Widget for Tui-rs
-- [tui-realm](https://github.com/veeso/tui-realm) — Tui-rs framework to build stateful applications
+* [tui-clap](https://github.com/kegesch/tui-clap-rs) — Use clap-rs together with Tui-rs
+* [tui-log](https://github.com/kegesch/tui-log-rs) — Example of how to use logging with Tui-rs
+* [tui-logger](https://github.com/gin66/tui-logger) — Logger and Widget for Tui-rs
+* [tui-realm](https://github.com/veeso/tui-realm) — Tui-rs framework to build stateful applications
   with a React/Elm inspired approach
-- [tui-realm-treeview](https://github.com/veeso/tui-realm-treeview) — Treeview component for
+* [tui-realm-treeview](https://github.com/veeso/tui-realm-treeview) — Treeview component for
   Tui-realm
-- [tui-rs-tree-widgets](https://github.com/EdJoPaTo/tui-rs-tree-widget) — Widget for tree data
+* [tui-rs-tree-widgets](https://github.com/EdJoPaTo/tui-rs-tree-widget): Widget for tree data
   structures.
-- [tui-windows](https://github.com/markatk/tui-windows-rs) — Tui-rs abstraction to handle multiple
+* [tui-windows](https://github.com/markatk/tui-windows-rs) — Tui-rs abstraction to handle multiple
   windows and their rendering
-- [tui-textarea](https://github.com/rhysd/tui-textarea) — Simple yet powerful multi-line text editor
+* [tui-textarea](https://github.com/rhysd/tui-textarea): Simple yet powerful multi-line text editor
   widget supporting several key shortcuts, undo/redo, text search, etc.
-- [tui-input](https://github.com/sayanarijit/tui-input) — TUI input library supporting multiple
+* [tui-input](https://github.com/sayanarijit/tui-input): TUI input library supporting multiple
   backends and tui-rs.
-- [tui-term](https://github.com/a-kenji/tui-term) — A pseudoterminal widget library
+* [tui-term](https://github.com/a-kenji/tui-term): A pseudoterminal widget library
   that enables the rendering of terminal applications as ratatui widgets.
 
 ## Apps
@@ -433,6 +250,11 @@ Check out the list of more than 50 [Apps using
 You might want to checkout [Cursive](https://github.com/gyscos/Cursive) for an alternative solution
 to build text user interfaces in Rust.
 
+## Contributors
+
+[![GitHub
+Contributors](https://contrib.rocks/image?repo=ratatui-org/ratatui)](https://github.com/ratatui-org/ratatui/graphs/contributors)
+
 ## Acknowledgments
 
 Special thanks to [**Pavel Fomchenkov**](https://github.com/nawok) for his work in designing **an

RELEASE.md

@@ -3,42 +3,28 @@
 [crates.io](https://crates.io/crates/ratatui) releases are automated via [GitHub
 actions](.github/workflows/cd.yml) and triggered by pushing a tag.
 
-1. Record a new demo gif if necessary. The preferred tool for this is
-[vhs](https://github.com/charmbracelet/vhs) (installation instructions in README).
+1. Record a new demo gif. The preferred tool for this is [ttyrec](http://0xcc.net/ttyrec/) and
+   [ttygif](https://github.com/icholy/ttygif). [Asciinema](https://asciinema.org/) handles block
+   character height poorly, [termanilizer](https://www.terminalizer.com/) takes forever to render,
+   [vhs](https://github.com/charmbracelet/vhs) handles braille
+   characters poorly (though if <https://github.com/charmbracelet/vhs/issues/322> is fixed, then
+   it's probably the best option).
 
    ```shell
-   cargo build --example demo2
-   vhs examples/demo2.tape
+   cargo build --example demo
+   ttyrec -e 'cargo --quiet run --release --example demo -- --tick-rate 100' demo.rec
+   ttygif demo.rec
    ```
 
-1. Switch branches to the images branch and copy demo2.gif to examples/, commit, and push.
-1. Grab the permalink from <https://github.com/ratatui-org/ratatui/blob/images/examples/demo2.gif> and
-   append `?raw=true` to redirect to the actual image url. Then update the link in the main README.
-   Avoid adding the gif to the git repo as binary files tend to bloat repositories.
+   Then upload it somewhere (e.g. use `vhs publish tty.gif` to publish it or upload it to a GitHub
+   wiki page as an attachment). Avoid adding the gif to the git repo as binary files tend to bloat
+   repositories.
 
 1. Bump the version in [Cargo.toml](Cargo.toml).
 1. Ensure [CHANGELOG.md](CHANGELOG.md) is updated. [git-cliff](https://github.com/orhun/git-cliff)
    can be used for generating the entries.
-1. Ensure that any breaking changes are documented in [BREAKING-CHANGES.md](./BREAKING-CHANGES.md)
 1. Commit and push the changes.
 1. Create a new tag: `git tag -a v[X.Y.Z]`
 1. Push the tag: `git push --tags`
 1. Wait for [Continuous Deployment](https://github.com/ratatui-org/ratatui/actions) workflow to
    finish.
-
-## Alpha Releases
-
-Alpha releases are automatically released every Saturday via [cd.yml](./.github/workflows/cd.yml)
-and can be manually be created when necessary by triggering the [Continuous
-Deployment](https://github.com/ratatui-org/ratatui/actions/workflows/cd.yml) workflow.
-
-We automatically release an alpha release with a patch level bump + alpha.num weekly (and when we
-need to manually). E.g. the last release was 0.22.0, and the most recent alpha release is
-0.22.1-alpha.1.
-
-These releases will have whatever happened to be in main at the time of release, so they're useful
-for apps that need to get releases from crates.io, but may contain more bugs and be generally less
-tested than normal releases.
-
-See [#147](https://github.com/ratatui-org/ratatui/issues/147) and
-[#359](https://github.com/ratatui-org/ratatui/pull/359) for more info on the alpha release process.

benches/barchart.rs

@@ -1,73 +0,0 @@
-use criterion::{criterion_group, criterion_main, Bencher, BenchmarkId, Criterion};
-use rand::Rng;
-use ratatui::{
-    buffer::Buffer,
-    layout::Rect,
-    prelude::Direction,
-    widgets::{Bar, BarChart, BarGroup, Widget},
-};
-
-/// Benchmark for rendering a barchart.
-pub fn barchart(c: &mut Criterion) {
-    let mut group = c.benchmark_group("barchart");
-    let mut rng = rand::thread_rng();
-
-    for data_count in [64, 256, 2048] {
-        let data: Vec<Bar> = (0..data_count)
-            .map(|i| {
-                Bar::default()
-                    .label(format!("B{i}").into())
-                    .value(rng.gen_range(0..data_count))
-            })
-            .collect();
-
-        let bargroup = BarGroup::default().bars(&data);
-
-        // Render a basic barchart
-        group.bench_with_input(
-            BenchmarkId::new("render", data_count),
-            &BarChart::default().data(bargroup.clone()),
-            render,
-        );
-
-        // Render an horizontal barchart
-        group.bench_with_input(
-            BenchmarkId::new("render_horizontal", data_count),
-            &BarChart::default()
-                .direction(Direction::Horizontal)
-                .data(bargroup.clone()),
-            render,
-        );
-
-        // Render a barchart with multiple groups
-        group.bench_with_input(
-            BenchmarkId::new("render_grouped", data_count),
-            &BarChart::default()
-                // We call `data` multiple time to add multiple groups.
-                // This is not a duplicated call.
-                .data(bargroup.clone())
-                .data(bargroup.clone())
-                .data(bargroup.clone()),
-            render,
-        );
-    }
-
-    group.finish();
-}
-
-/// Render the widget in a classical size buffer
-fn render(bencher: &mut Bencher, barchart: &BarChart) {
-    let mut buffer = Buffer::empty(Rect::new(0, 0, 200, 50));
-    // We use `iter_batched` to clone the value in the setup function.
-    // See https://github.com/ratatui-org/ratatui/pull/377.
-    bencher.iter_batched(
-        || barchart.clone(),
-        |bench_barchart| {
-            bench_barchart.render(buffer.area, &mut buffer);
-        },
-        criterion::BatchSize::LargeInput,
-    )
-}
-
-criterion_group!(benches, barchart);
-criterion_main!(benches);

benches/block.rs

@@ -1,64 +0,0 @@
-use criterion::{criterion_group, criterion_main, BatchSize, Bencher, BenchmarkId, Criterion};
-use ratatui::{
-    buffer::Buffer,
-    layout::Rect,
-    prelude::Alignment,
-    widgets::{
-        block::{Position, Title},
-        Block, Borders, Padding, Widget,
-    },
-};
-
-/// Benchmark for rendering a block.
-pub fn block(c: &mut Criterion) {
-    let mut group = c.benchmark_group("block");
-
-    for buffer_size in &[
-        Rect::new(0, 0, 100, 50),  // vertically split screen
-        Rect::new(0, 0, 200, 50),  // 1080p fullscreen with medium font
-        Rect::new(0, 0, 256, 256), // Max sized area
-    ] {
-        let buffer_area = buffer_size.area();
-
-        // Render an empty block
-        group.bench_with_input(
-            BenchmarkId::new("render_empty", buffer_area),
-            &Block::new(),
-            |b, block| render(b, block, buffer_size),
-        );
-
-        // Render with all features
-        group.bench_with_input(
-            BenchmarkId::new("render_all_feature", buffer_area),
-            &Block::new()
-                .borders(Borders::ALL)
-                .title("test title")
-                .title(
-                    Title::from("bottom left title")
-                        .alignment(Alignment::Right)
-                        .position(Position::Bottom),
-                )
-                .padding(Padding::new(5, 5, 2, 2)),
-            |b, block| render(b, block, buffer_size),
-        );
-    }
-
-    group.finish();
-}
-
-/// render the block into a buffer of the given `size`
-fn render(bencher: &mut Bencher, block: &Block, size: &Rect) {
-    let mut buffer = Buffer::empty(*size);
-    // We use `iter_batched` to clone the value in the setup function.
-    // See https://github.com/ratatui-org/ratatui/pull/377.
-    bencher.iter_batched(
-        || block.to_owned(),
-        |bench_block| {
-            bench_block.render(buffer.area, &mut buffer);
-        },
-        BatchSize::SmallInput,
-    )
-}
-
-criterion_group!(benches, block);
-criterion_main!(benches);

benches/list.rs

@@ -1,73 +0,0 @@
-use criterion::{criterion_group, criterion_main, BatchSize, Bencher, BenchmarkId, Criterion};
-use ratatui::{
-    buffer::Buffer,
-    layout::Rect,
-    widgets::{List, ListItem, ListState, StatefulWidget, Widget},
-};
-
-/// Benchmark for rendering a list.
-/// It only benchmarks the render with a different amount of items.
-pub fn list(c: &mut Criterion) {
-    let mut group = c.benchmark_group("list");
-
-    for line_count in [64, 2048, 16384] {
-        let lines: Vec<ListItem> = (0..line_count)
-            .map(|_| ListItem::new(fakeit::words::sentence(10)))
-            .collect();
-
-        // Render default list
-        group.bench_with_input(
-            BenchmarkId::new("render", line_count),
-            &List::new(lines.clone()),
-            render,
-        );
-
-        // Render with an offset to the middle of the list and a selected item
-        group.bench_with_input(
-            BenchmarkId::new("render_scroll_half", line_count),
-            &List::new(lines.clone()).highlight_symbol(">>"),
-            |b, list| {
-                render_stateful(
-                    b,
-                    list,
-                    ListState::default()
-                        .with_offset(line_count / 2)
-                        .with_selected(Some(line_count / 2)),
-                )
-            },
-        );
-    }
-
-    group.finish();
-}
-
-/// render the list into a common size buffer
-fn render(bencher: &mut Bencher, list: &List) {
-    let mut buffer = Buffer::empty(Rect::new(0, 0, 200, 50));
-    // We use `iter_batched` to clone the value in the setup function.
-    // See https://github.com/ratatui-org/ratatui/pull/377.
-    bencher.iter_batched(
-        || list.to_owned(),
-        |bench_list| {
-            Widget::render(bench_list, buffer.area, &mut buffer);
-        },
-        BatchSize::LargeInput,
-    )
-}
-
-/// render the list into a common size buffer with a state
-fn render_stateful(bencher: &mut Bencher, list: &List, mut state: ListState) {
-    let mut buffer = Buffer::empty(Rect::new(0, 0, 200, 50));
-    // We use `iter_batched` to clone the value in the setup function.
-    // See https://github.com/ratatui-org/ratatui/pull/377.
-    bencher.iter_batched(
-        || list.to_owned(),
-        |bench_list| {
-            StatefulWidget::render(bench_list, buffer.area, &mut buffer, &mut state);
-        },
-        BatchSize::LargeInput,
-    )
-}
-
-criterion_group!(benches, list);
-criterion_main!(benches);

benches/paragraph.rs

@@ -1,6 +1,4 @@
-use criterion::{
-    black_box, criterion_group, criterion_main, BatchSize, Bencher, BenchmarkId, Criterion,
-};
+use criterion::{black_box, criterion_group, criterion_main, Bencher, BenchmarkId, Criterion};
 use ratatui::{
     buffer::Buffer,
     layout::Rect,
@@ -71,15 +69,9 @@ pub fn paragraph(c: &mut Criterion) {
 /// render the paragraph into a buffer with the given width
 fn render(bencher: &mut Bencher, paragraph: &Paragraph, width: u16) {
     let mut buffer = Buffer::empty(Rect::new(0, 0, width, 50));
-    // We use `iter_batched` to clone the value in the setup function.
-    // See https://github.com/ratatui-org/ratatui/pull/377.
-    bencher.iter_batched(
-        || paragraph.to_owned(),
-        |bench_paragraph| {
-            bench_paragraph.render(buffer.area, &mut buffer);
-        },
-        BatchSize::LargeInput,
-    )
+    bencher.iter(|| {
+        paragraph.clone().render(buffer.area, &mut buffer);
+    })
 }
 
 /// Create a string with the given number of lines filled with nonsense words

benches/sparkline.rs

@@ -1,45 +0,0 @@
-use criterion::{criterion_group, criterion_main, Bencher, BenchmarkId, Criterion};
-use rand::Rng;
-use ratatui::{
-    buffer::Buffer,
-    layout::Rect,
-    widgets::{Sparkline, Widget},
-};
-
-/// Benchmark for rendering a sparkline.
-pub fn sparkline(c: &mut Criterion) {
-    let mut group = c.benchmark_group("sparkline");
-    let mut rng = rand::thread_rng();
-
-    for data_count in [64, 256, 2048] {
-        let data: Vec<u64> = (0..data_count)
-            .map(|_| rng.gen_range(0..data_count))
-            .collect();
-
-        // Render a basic sparkline
-        group.bench_with_input(
-            BenchmarkId::new("render", data_count),
-            &Sparkline::default().data(&data),
-            render,
-        );
-    }
-
-    group.finish();
-}
-
-/// render the block into a buffer of the given `size`
-fn render(bencher: &mut Bencher, sparkline: &Sparkline) {
-    let mut buffer = Buffer::empty(Rect::new(0, 0, 200, 50));
-    // We use `iter_batched` to clone the value in the setup function.
-    // See https://github.com/ratatui-org/ratatui/pull/377.
-    bencher.iter_batched(
-        || sparkline.clone(),
-        |bench_sparkline| {
-            bench_sparkline.render(buffer.area, &mut buffer);
-        },
-        criterion::BatchSize::LargeInput,
-    )
-}
-
-criterion_group!(benches, sparkline);
-criterion_main!(benches);

cliff.toml

@@ -3,51 +3,35 @@
 [changelog]
 # changelog header
 header = """
-# Changelog
-
-All notable changes to this project will be documented in this file.
+# Changelog\n
+All notable changes to this project will be documented in this file.\n
 """
 # template for the changelog body
-# https://keats.github.io/tera/docs/#introduction
-# note that the - before / after the % controls whether whitespace is rendered between each line.
-# Getting this right so that the markdown renders with the correct number of lines between headings
-# code fences and list items is pretty finicky. Note also that the 4 backticks in the commit macro
-# is intentional as this escapes any backticks in the commit body.
+# https://tera.netlify.app/docs/#introduction
 body = """
-{%- if not version %}
-## [unreleased]
-{% else -%}
-## [{{ version }}](https://github.com/ratatui-org/ratatui/releases/tag/{{ version }}) - {{ timestamp | date(format="%Y-%m-%d") }}
-{% endif -%}
-
-{% macro commit(commit) -%}
-- [{{ commit.id | truncate(length=7, end="") }}]({{ "https://github.com/ratatui-org/ratatui/commit/" ~ commit.id }})
-  *({{commit.scope | default(value = "uncategorized") | lower }})* {{ commit.message | upper_first }}
-{%- if commit.breaking %} [**breaking**]{% endif %}
-{%- if commit.body %}
-
-  ````text {#- 4 backticks escape any backticks in body #}
-  {{commit.body | indent(prefix="  ") }}
-  ````
-{%- endif %}
-{% endmacro -%}
-
+{% if version %}\
+    ## {{ version }} - {{ timestamp | date(format="%Y-%m-%d") }}
+{% else %}\
+    ## [unreleased]
+{% endif %}\
 {% for group, commits in commits | group_by(attribute="group") %}
-### {{ group | striptags | trim | upper_first }}
-{% for commit in commits | filter(attribute="scope") | sort(attribute="scope") %}
-{{ self::commit(commit=commit) }}
-{%- endfor -%}
-{% for commit in commits %}
-{%- if not commit.scope %}
-{{ self::commit(commit=commit) }}
-{%- endif -%}
-{%- endfor -%}
-{%- endfor %}
+    ### {{ group | striptags | trim | upper_first }}
+    {% for commit in commits
+    | filter(attribute="scope")
+    | sort(attribute="scope") %}
+        - *({{commit.scope}})* {{ commit.message | upper_first }}{% if commit.breaking %} [**breaking**]{% endif %}
+    {%- endfor -%}
+    {% raw %}\n{% endraw %}\
+    {%- for commit in commits %}
+        {%- if commit.scope -%}
+        {% else -%}
+            - *(uncategorized)* {{ commit.message | upper_first }}{% if commit.breaking %} [**breaking**]{% endif %}
+        {% endif -%}
+    {% endfor -%}
+{% endfor %}\n
 """
-
-
 # remove the leading and trailing whitespace from the template
-trim = false
+trim = true
 # changelog footer
 footer = """
 <!-- generated by git-cliff -->
@@ -62,34 +46,29 @@ filter_unconventional = true
 split_commits = false
 # regex for preprocessing the commit messages
 commit_preprocessors = [
-  { pattern = '\((\w+\s)?#([0-9]+)\)', replace = "([#${2}](https://github.com/ratatui-org/ratatui/issues/${2}))" },
-  { pattern = '(better safe shared layout cache)', replace = "perf(layout): ${1}" },
-  { pattern = '(Clarify README.md)', replace = "docs(readme): ${1}" },
-  { pattern = '(Update README.md)', replace = "docs(readme): ${1}" },
-  { pattern = '(fix typos|Fix typos)', replace = "fix: ${1}" },
+    { pattern = '\((\w+\s)?#([0-9]+)\)', replace = "([#${2}](https://github.com/ratatui-org/ratatui/issues/${2}))" },
+    { pattern = '(better safe shared layout cache)', replace = "perf(layout): ${1}" },
+    { pattern = '(Clarify README.md)', replace = "docs(readme): ${1}" },
+    { pattern = '(Update README.md)', replace = "docs(readme): ${1}" },
+    { pattern = '(fix typos|Fix typos)', replace = "fix: ${1}" },
 ]
 # regex for parsing and grouping commits
 commit_parsers = [
-  { message = "^feat", group = "<!-- 00 -->Features" },
-  { message = "^[fF]ix", group = "<!-- 01 -->Bug Fixes" },
-  { message = "^refactor", group = "<!-- 02 -->Refactor" },
-  { message = "^doc", group = "<!-- 03 -->Documentation" },
-  { message = "^perf", group = "<!-- 04 -->Performance" },
-  { message = "^style", group = "<!-- 05 -->Styling" },
-  { message = "^test", group = "<!-- 06 -->Testing" },
-  { message = "^chore\\(release\\): prepare for", skip = true },
-  { message = "^chore\\(pr\\)", skip = true },
-  { message = "^chore\\(pull\\)", skip = true },
-  { message = "^chore\\(deps\\)", skip = true },
-  { message = "^chore\\(changelog\\)", skip = true },
-  { message = "^[cC]hore", group = "<!-- 07 -->Miscellaneous Tasks" },
-  { body = ".*security", group = "<!-- 08 -->Security" },
-  { message = "^build", group = "<!-- 09 -->Build" },
-  { message = "^ci", group = "<!-- 10 -->Continuous Integration" },
-  { message = "^revert", group = "<!-- 11 -->Reverted Commits" },
-  # handle some old commits styles from pre 0.4
-  { message = "^(Buffer|buffer|Frame|frame|Gauge|gauge|Paragraph|paragraph):", group = "<!-- 07 -->Miscellaneous Tasks" },
-  { message = "^\\[", group = "<!-- 07 -->Miscellaneous Tasks" },
+    { message = "^feat", group = "<!-- 00 -->Features" },
+    { message = "^[fF]ix", group = "<!-- 01 -->Bug Fixes" },
+    { message = "^refactor", group = "<!-- 02 -->Refactor" },
+    { message = "^doc", group = "<!-- 03 -->Documentation" },
+    { message = "^perf", group = "<!-- 04 -->Performance" },
+    { message = "^style", group = "<!-- 05 -->Styling" },
+    { message = "^test", group = "<!-- 06 -->Testing" },
+    { message = "^chore\\(release\\): prepare for", skip = true },
+    { message = "^chore\\(pr\\)", skip = true },
+    { message = "^chore\\(pull\\)", skip = true },
+    { message = "^chore", group = "<!-- 07 -->Miscellaneous Tasks" },
+    { body = ".*security", group = "<!-- 08 -->Security" },
+    { message = "^build", group = "<!-- 09 -->Build" },
+    { message = "^ci", group = "<!-- 10 -->Continuous Integration" },
+    { message = "^revert", group = "<!-- 11 -->Reverted Commits" },
 ]
 # protect breaking changes from being skipped due to matching a skipping commit_parser
 protect_breaking_commits = false
@@ -100,7 +79,7 @@ tag_pattern = "v[0-9]*"
 # regex for skipping tags
 skip_tags = "v0.1.0-rc.1"
 # regex for ignoring tags
-ignore_tags = "alpha"
+ignore_tags = ""
 # sort the tags topologically
 topo_order = false
 # sort the commits inside sections by oldest/newest order

codecov.yml

@@ -1,14 +0,0 @@
-coverage: # https://docs.codecov.com/docs/codecovyml-reference#coverage
-  precision: 1 # e.g. 89.1%
-  round: down
-  range: 85..100 # https://docs.codecov.com/docs/coverage-configuration#section-range
-  status: # https://docs.codecov.com/docs/commit-status
-    project:
-      default:
-        threshold: 1% # Avoid false negatives
-ignore:
-  - "examples"
-  - "benches"
-comment: # https://docs.codecov.com/docs/pull-request-comments
-  # make the comments less noisy
-  require_changes: true

examples/README.md

@@ -1,47 +1,12 @@
 # Examples
 
-These gifs were created using [VHS](https://github.com/charmbracelet/vhs). Each example has a
-corresponding `.tape` file that holds instructions for how to generate the images. Note that the
-images themselves are stored in a separate git branch to avoid bloating the main repository.
+These gifs were created using [Charm VHS](https://github.com/charmbracelet/vhs).
 
-## Demo2
+VHS has a problem rendering some background color transitions, which shows up in several examples
+below. See <https://github.com/charmbracelet/vhs/issues/344> for more info. These problems don't
+occur in a terminal.
 
-This is the demo example from the main README and crate page. Source: [demo2](./demo2/).
-
-```shell
-cargo run --example=demo2 --features="crossterm widget-calendar"
-```
-
-![Demo2][demo2.gif]
-
-## Demo
-
-This is the previous demo example from the main README. It is available for each of the backends. Source:
-[demo.rs](./demo/).
-
-```shell
-cargo run --example=demo --features=crossterm
-cargo run --example=demo --no-default-features --features=termion
-cargo run --example=demo --no-default-features --features=termwiz
-```
-
-![Demo][demo.gif]
-
-## Hello World
-
-This is a pretty boring example, but it contains some good documentation
-on writing tui apps. Source: [hello_world.rs](./hello_world.rs).
-
-```shell
-cargo run --example=hello_world --features=crossterm
-```
-
-![Hello World][hello_world.gif]
-
-## Barchart
-
-Demonstrates the [`BarChart`](https://docs.rs/ratatui/latest/ratatui/widgets/struct.BarChart.html)
-widget. Source: [barchart.rs](./barchart.rs).
+## Barchart ([barchart.rs](./barchart.rs)
 
 ```shell
 cargo run --example=barchart --features=crossterm
@@ -49,10 +14,7 @@ cargo run --example=barchart --features=crossterm
 
 ![Barchart][barchart.gif]
 
-## Block
-
-Demonstrates the [`Block`](https://docs.rs/ratatui/latest/ratatui/widgets/block/struct.Block.html)
-widget. Source: [block.rs](./block.rs).
+## Block ([block.rs](./block.rs))
 
 ```shell
 cargo run --example=block --features=crossterm
@@ -60,23 +22,15 @@ cargo run --example=block --features=crossterm
 
 ![Block][block.gif]
 
-## Calendar
-
-Demonstrates the [`Calendar`](https://docs.rs/ratatui/latest/ratatui/widgets/calendar/index.html)
-widget. Source: [calendar.rs](./calendar.rs).
+## Calendar ([calendar.rs](./calendar.rs))
 
 ```shell
-cargo run --example=calendar --features="crossterm widget-calendar"
+cargo run --example=calendar --features=crossterm widget-calendar
 ```
 
 ![Calendar][calendar.gif]
 
-## Canvas
-
-Demonstrates the [`Canvas`](https://docs.rs/ratatui/latest/ratatui/widgets/canvas/index.html) widget
-and related shapes in the
-[`canvas`](https://docs.rs/ratatui/latest/ratatui/widgets/canvas/index.html) module. Source:
-[canvas.rs](./canvas.rs).
+## Canvas ([canvas.rs](./canvas.rs))
 
 ```shell
 cargo run --example=canvas --features=crossterm
@@ -84,10 +38,7 @@ cargo run --example=canvas --features=crossterm
 
 ![Canvas][canvas.gif]
 
-## Chart
-
-Demonstrates the [`Chart`](https://docs.rs/ratatui/latest/ratatui/widgets/struct.Chart.html) widget.
-Source: [chart.rs](./chart.rs).
+## Chart ([chart.rs](./chart.rs))
 
 ```shell
 cargo run --example=chart --features=crossterm
@@ -95,46 +46,21 @@ cargo run --example=chart --features=crossterm
 
 ![Chart][chart.gif]
 
-## Colors
-
-Demonstrates the available [`Color`](https://docs.rs/ratatui/latest/ratatui/style/enum.Color.html)
-options. These can be used in any style field. Source: [colors.rs](./colors.rs).
-
-```shell
-cargo run --example=colors --features=crossterm
-```
-
-![Colors][colors.gif]
-
-## Colors (RGB)
-
-Demonstrates the available RGB
-[`Color`](https://docs.rs/ratatui/latest/ratatui/style/enum.Color.html) options. These can be used
-in any style field. Source: [colors_rgb.rs](./colors_rgb.rs). Uses a half block technique to render
-two square-ish pixels in the space of a single rectangular terminal cell.
-
-```shell
-cargo run --example=colors_rgb --features=crossterm
-```
-
-![Colors RGB][colors_rgb.png]
-
-## Custom Widget
-
-Demonstrates how to implement the
-[`Widget`](https://docs.rs/ratatui/latest/ratatui/widgets/trait.Widget.html) trait. Also shows mouse
-interaction. Source: [custom_widget.rs](./custom_widget.rs).
+## Custom Widget ([custom_widget.rs](./custom_widget.rs))
 
 ```shell
 cargo run --example=custom_widget --features=crossterm
 ```
 
+This is not a particularly exciting example visually, but it demonstrates how to implement your own widget.
+
 ![Custom Widget][custom_widget.gif]
 
-## Gauge
+## Gauge ([gauge.rs](./gauge.rs))
 
-Demonstrates the [`Gauge`](https://docs.rs/ratatui/latest/ratatui/widgets/struct.Gauge.html) widget.
-Source: [gauge.rs](./gauge.rs).
+Please note: the background renders poorly when we generate this example using VHS.
+This problem doesn't generally happen during normal rendering in a terminal.
+See <https://github.com/charmbracelet/vhs/issues/344> for more details
 
 ```shell
 cargo run --example=gauge --features=crossterm
@@ -142,11 +68,18 @@ cargo run --example=gauge --features=crossterm
 
 ![Gauge][gauge.gif]
 
-## Inline
+## Hello World ([hello_world.rs](./hello_world.rs))
 
-Demonstrates how to use the
-[`Inline`](https://docs.rs/ratatui/latest/ratatui/terminal/enum.Viewport.html#variant.Inline)
-Viewport mode for ratatui apps. Source: [inline.rs](./inline.rs).
+```shell
+cargo run --example=hello_world --features=crossterm
+```
+
+This is a pretty boring example, but it contains some good comments of documentation on some of the
+standard approaches to writing tui apps.
+
+![Hello World][hello_world.gif]
+
+## Inline ([inline.rs](./inline.rs))
 
 ```shell
 cargo run --example=inline --features=crossterm
@@ -154,10 +87,7 @@ cargo run --example=inline --features=crossterm
 
 ![Inline][inline.gif]
 
-## Layout
-
-Demonstrates the [`Layout`](https://docs.rs/ratatui/latest/ratatui/layout/struct.Layout.html) and
-interaction between each constraint. Source:  [layout.rs](./layout.rs).
+## Layout ([layout.rs](./layout.rs))
 
 ```shell
 cargo run --example=layout --features=crossterm
@@ -165,10 +95,7 @@ cargo run --example=layout --features=crossterm
 
 ![Layout][layout.gif]
 
-## List
-
-Demonstrates the [`List`](https://docs.rs/ratatui/latest/ratatui/widgets/struct.List.html) widget.
-Source: [list.rs](./list.rs).
+## List ([list.rs](./list.rs))
 
 ```shell
 cargo run --example=list --features=crossterm
@@ -176,22 +103,7 @@ cargo run --example=list --features=crossterm
 
 ![List][list.gif]
 
-## Modifiers
-
-Demonstrates the style
-[`Modifiers`](https://docs.rs/ratatui/latest/ratatui/style/struct.Modifier.html). Source:
-[modifiers.rs](./modifiers.rs).
-
-```shell
-cargo run --example=modifiers --features=crossterm
-```
-
-![Modifiers][modifiers.gif]
-
-## Panic
-
-Demonstrates how to handle panics by ensuring that panic messages are written correctly to the
-screen. Source: [panic.rs](./panic.rs).
+## Panic ([panic.rs](./panic.rs))
 
 ```shell
 cargo run --example=panic --features=crossterm
@@ -199,10 +111,7 @@ cargo run --example=panic --features=crossterm
 
 ![Panic][panic.gif]
 
-## Paragraph
-
-Demonstrates the [`Paragraph`](https://docs.rs/ratatui/latest/ratatui/widgets/struct.Paragraph.html)
-widget. Source: [paragraph.rs](./paragraph.rs)
+## Paragraph ([paragraph.rs](./paragraph.rs))
 
 ```shell
 cargo run --example=paragraph --features=crossterm
@@ -210,23 +119,19 @@ cargo run --example=paragraph --features=crossterm
 
 ![Paragraph][paragraph.gif]
 
-## Popup
+## Popup ([popup.rs](./popup.rs))
 
-Demonstrates how to render a widget over the top of previously rendered widgets using the
-[`Clear`](https://docs.rs/ratatui/latest/ratatui/widgets/struct.Clear.html) widget. Source:
-[popup.rs](./popup.rs).
-
->
 ```shell
 cargo run --example=popup --features=crossterm
 ```
 
+Please note: the background renders poorly when we generate this example using VHS.
+This problem doesn't generally happen during normal rendering in a terminal.
+See <https://github.com/charmbracelet/vhs/issues/344> for more details
+
 ![Popup][popup.gif]
 
-## Scrollbar
-
-Demonstrates the [`Scrollbar`](https://docs.rs/ratatui/latest/ratatui/widgets/struct.Scrollbar.html)
-widget. Source: [scrollbar.rs](./scrollbar.rs).
+## Scrollbar ([scrollbar.rs](./scrollbar.rs))
 
 ```shell
 cargo run --example=scrollbar --features=crossterm
@@ -234,10 +139,7 @@ cargo run --example=scrollbar --features=crossterm
 
 ![Scrollbar][scrollbar.gif]
 
-## Sparkline
-
-Demonstrates the [`Sparkline`](https://docs.rs/ratatui/latest/ratatui/widgets/struct.Sparkline.html)
-widget. Source: [sparkline.rs](./sparkline.rs).
+## Sparkline ([sparkline.rs](./sparkline.rs))
 
 ```shell
 cargo run --example=sparkline --features=crossterm
@@ -245,10 +147,7 @@ cargo run --example=sparkline --features=crossterm
 
 ![Sparkline][sparkline.gif]
 
-## Table
-
-Demonstrates the [`Table`](https://docs.rs/ratatui/latest/ratatui/widgets/struct.Table.html) widget.
-Source: [table.rs](./table.rs).
+## Table ([table.rs](./table.rs))
 
 ```shell
 cargo run --example=table --features=crossterm
@@ -256,10 +155,7 @@ cargo run --example=table --features=crossterm
 
 ![Table][table.gif]
 
-## Tabs
-
-Demonstrates the [`Tabs`](https://docs.rs/ratatui/latest/ratatui/widgets/struct.Tabs.html) widget.
-Source: [tabs.rs](./tabs.rs).
+## Tabs ([tabs.rs](./tabs.rs))
 
 ```shell
 cargo run --example=tabs --features=crossterm
@@ -267,12 +163,7 @@ cargo run --example=tabs --features=crossterm
 
 ![Tabs][tabs.gif]
 
-## User Input
-
-Demonstrates one approach to accepting user input. Source [user_input.rs](./user_input.rs).
-
-> [!NOTE] Consider using [`tui-textarea`](https://crates.io/crates/tui-textarea) or
-> [`tui-input`](https://crates.io/crates/tui-input) crates for more functional text entry UIs.
+## User Input ([user_input.rs](./user_input.rs))
 
 ```shell
 cargo run --example=user_input --features=crossterm
@@ -286,31 +177,33 @@ These are generated with `vhs publish examples/xxx.gif`
 
 To update these examples in bulk:
 ```shell
-examples/generate.bash
+# build to ensure that running the examples doesn't have to wait so long
+cargo build --examples --features=crossterm,all-widgets
+for i in examples/*.tape
+do
+    echo -n "[${i:s:examples/:::s:.tape:.gif:}]: "
+    vhs $i --publish --quiet
+    # may need to adjust this depending on if you see rate limiting from VHS
+    sleep 1
+done
 ```
 -->
-
-[barchart.gif]: https://github.com/ratatui-org/ratatui/blob/images/examples/barchart.gif?raw=true
-[block.gif]: https://github.com/ratatui-org/ratatui/blob/images/examples/block.gif?raw=true
-[calendar.gif]: https://github.com/ratatui-org/ratatui/blob/images/examples/calendar.gif?raw=true
-[canvas.gif]: https://github.com/ratatui-org/ratatui/blob/images/examples/canvas.gif?raw=true
-[chart.gif]: https://github.com/ratatui-org/ratatui/blob/images/examples/chart.gif?raw=true
-[colors.gif]: https://github.com/ratatui-org/ratatui/blob/images/examples/colors.gif?raw=true
-[colors_rgb.png]: https://github.com/ratatui-org/ratatui/blob/images/examples/colors_rgb.png?raw=true
-[custom_widget.gif]: https://github.com/ratatui-org/ratatui/blob/images/examples/custom_widget.gif?raw=true
-[demo.gif]: https://github.com/ratatui-org/ratatui/blob/images/examples/demo.gif?raw=true
-[demo2.gif]: https://github.com/ratatui-org/ratatui/blob/images/examples/demo2.gif?raw=true
-[gauge.gif]: https://github.com/ratatui-org/ratatui/blob/images/examples/gauge.gif?raw=true
-[hello_world.gif]: https://github.com/ratatui-org/ratatui/blob/images/examples/hello_world.gif?raw=true
-[inline.gif]: https://github.com/ratatui-org/ratatui/blob/images/examples/inline.gif?raw=true
-[layout.gif]: https://github.com/ratatui-org/ratatui/blob/images/examples/layout.gif?raw=true
-[list.gif]: https://github.com/ratatui-org/ratatui/blob/images/examples/list.gif?raw=true
-[modifiers.gif]: https://github.com/ratatui-org/ratatui/blob/images/examples/modifiers.gif?raw=true
-[panic.gif]: https://github.com/ratatui-org/ratatui/blob/images/examples/panic.gif?raw=true
-[paragraph.gif]: https://github.com/ratatui-org/ratatui/blob/images/examples/paragraph.gif?raw=true
-[popup.gif]: https://github.com/ratatui-org/ratatui/blob/images/examples/popup.gif?raw=true
-[scrollbar.gif]: https://github.com/ratatui-org/ratatui/blob/images/examples/scrollbar.gif?raw=true
-[sparkline.gif]: https://github.com/ratatui-org/ratatui/blob/images/examples/sparkline.gif?raw=true
-[table.gif]: https://github.com/ratatui-org/ratatui/blob/images/examples/table.gif?raw=true
-[tabs.gif]: https://github.com/ratatui-org/ratatui/blob/images/examples/tabs.gif?raw=true
-[user_input.gif]: https://github.com/ratatui-org/ratatui/blob/images/examples/user_input.gif?raw=true
+[barchart.gif]: https://vhs.charm.sh/vhs-6ioxdeRBVkVpyXcjIEVaJU.gif
+[block.gif]: https://vhs.charm.sh/vhs-1sEo9vVkHRwFtu95MOXrTj.gif
+[calendar.gif]: https://vhs.charm.sh/vhs-1dBcpMSSP80WkBgm4lBhNo.gif
+[canvas.gif]: https://vhs.charm.sh/vhs-4zeWEPF6bLEFSHuJrvaHlN.gif
+[chart.gif]: https://vhs.charm.sh/vhs-zRzsE2AwRixQhcWMTAeF1.gif
+[custom_widget.gif]: https://vhs.charm.sh/vhs-32mW1TpkrovTcm79QXmBSu.gif
+[gauge.gif]: https://vhs.charm.sh/vhs-2rvSeP5r4lRkGTzNCKpm9a.gif
+[hello_world.gif]: https://vhs.charm.sh/vhs-3CKUwxFuQi8oKQMS5zkPfQ.gif
+[inline.gif]: https://vhs.charm.sh/vhs-miRl1mosKFoJV7LjjvF4T.gif
+[layout.gif]: https://vhs.charm.sh/vhs-5R8O3LQGQ5pQVWwlPVrdbQ.gif
+[list.gif]: https://vhs.charm.sh/vhs-4goo9reeUM9r0nYb54R7SP.gif
+[panic.gif]: https://vhs.charm.sh/vhs-HrvKCHV4yeN69fb1EadTH.gif
+[paragraph.gif]: https://vhs.charm.sh/vhs-2qIPDi79DUmtmeNDEeHVEF.gif
+[popup.gif]: https://vhs.charm.sh/vhs-2QnC682AUeNYNXcjNlKTyp.gif
+[scrollbar.gif]: https://vhs.charm.sh/vhs-2p13MMFreW7Gwt1xIonIWu.gif
+[sparkline.gif]: https://vhs.charm.sh/vhs-4t59Vxw5Za33Rtvt9QrftA.gif
+[table.gif]: https://vhs.charm.sh/vhs-6IrGHgT385DqA6xnwGF9oD.gif
+[tabs.gif]: https://vhs.charm.sh/vhs-61WkbfhyDk0kbkjncErdHT.gif
+[user_input.gif]: https://vhs.charm.sh/vhs-4fxUgkpEWcVyBRXuyYKODY.gif

examples/barchart.rs

@@ -62,7 +62,7 @@ impl<'a> App<'a> {
                 },
                 Company {
                     label: "Comp.B",
-                    revenue: [1500, 2500, 3000, 500],
+                    revenue: [1500, 2500, 3000, 4100],
                     bar_style: Style::default().fg(Color::Yellow),
                 },
                 Company {
@@ -119,7 +119,9 @@ fn run_app<B: Backend>(
     loop {
         terminal.draw(|f| ui(f, &app))?;
 
-        let timeout = tick_rate.saturating_sub(last_tick.elapsed());
+        let timeout = tick_rate
+            .checked_sub(last_tick.elapsed())
+            .unwrap_or_else(|| Duration::from_secs(0));
         if crossterm::event::poll(timeout)? {
             if let Event::Key(key) = event::read()? {
                 if let KeyCode::Char('q') = key.code {
@@ -134,10 +136,18 @@ fn run_app<B: Backend>(
     }
 }
 
-fn ui(f: &mut Frame, app: &App) {
+fn ui<B: Backend>(f: &mut Frame<B>, app: &App) {
     let chunks = Layout::default()
         .direction(Direction::Vertical)
-        .constraints([Constraint::Ratio(1, 3), Constraint::Ratio(2, 3)])
+        .margin(2)
+        .constraints(
+            [
+                Constraint::Ratio(1, 3),
+                Constraint::Ratio(1, 3),
+                Constraint::Ratio(1, 3),
+            ]
+            .as_ref(),
+        )
         .split(f.size());
 
     let barchart = BarChart::default()
@@ -148,17 +158,16 @@ fn ui(f: &mut Frame, app: &App) {
         .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)])
-        .split(chunks[1]);
-
-    draw_bar_with_group_labels(f, app, chunks[0]);
-    draw_horizontal_bars(f, app, chunks[1]);
+    draw_bar_with_group_labels(f, app, chunks[1], false);
+    draw_bar_with_group_labels(f, app, chunks[2], true);
 }
 
-fn create_groups<'a>(app: &'a App, combine_values_and_labels: bool) -> Vec<BarGroup<'a>> {
-    app.months
+fn draw_bar_with_group_labels<B>(f: &mut Frame<B>, app: &App, area: Rect, bar_labels: bool)
+where
+    B: Backend,
+{
+    let groups: Vec<BarGroup> = app
+        .months
         .iter()
         .enumerate()
         .map(|(i, &month)| {
@@ -173,31 +182,17 @@ fn create_groups<'a>(app: &'a App, combine_values_and_labels: bool) -> Vec<BarGr
                             Style::default()
                                 .bg(c.bar_style.fg.unwrap())
                                 .fg(Color::Black),
-                        );
-
-                    if combine_values_and_labels {
-                        bar = bar.text_value(format!(
-                            "{} ({:.1} M)",
-                            c.label,
-                            (c.revenue[i] as f64) / 1000.
-                        ));
-                    } else {
-                        bar = bar
-                            .text_value(format!("{:.1}", (c.revenue[i] as f64) / 1000.))
-                            .label(c.label.into());
+                        )
+                        .text_value(format!("{:.1}", (c.revenue[i] as f64) / 1000.));
+                    if bar_labels {
+                        bar = bar.label(c.label.into());
                     }
                     bar
                 })
                 .collect();
-            BarGroup::default()
-                .label(Line::from(month).alignment(Alignment::Center))
-                .bars(&bars)
+            BarGroup::default().label(month.into()).bars(&bars)
         })
-        .collect()
-}
-
-fn draw_bar_with_group_labels(f: &mut Frame, app: &App, area: Rect) {
-    let groups = create_groups(app, false);
+        .collect();
 
     let mut barchart = BarChart::default()
         .block(Block::default().title("Data1").borders(Borders::ALL))
@@ -212,47 +207,20 @@ fn draw_bar_with_group_labels(f: &mut Frame, app: &App, area: Rect) {
 
     const LEGEND_HEIGHT: u16 = 6;
     if area.height >= LEGEND_HEIGHT && area.width >= TOTAL_REVENUE.len() as u16 + 2 {
-        let legend_width = TOTAL_REVENUE.len() as u16 + 2;
         let legend_area = Rect {
             height: LEGEND_HEIGHT,
-            width: legend_width,
+            width: TOTAL_REVENUE.len() as u16 + 2,
             y: area.y,
-            x: area.right() - legend_width,
+            x: area.x,
         };
         draw_legend(f, legend_area);
     }
 }
 
-fn draw_horizontal_bars(f: &mut Frame, app: &App, area: Rect) {
-    let groups = create_groups(app, true);
-
-    let mut barchart = BarChart::default()
-        .block(Block::default().title("Data1").borders(Borders::ALL))
-        .bar_width(1)
-        .group_gap(1)
-        .bar_gap(0)
-        .direction(Direction::Horizontal);
-
-    for group in groups {
-        barchart = barchart.data(group)
-    }
-
-    f.render_widget(barchart, area);
-
-    const LEGEND_HEIGHT: u16 = 6;
-    if area.height >= LEGEND_HEIGHT && area.width >= TOTAL_REVENUE.len() as u16 + 2 {
-        let legend_width = TOTAL_REVENUE.len() as u16 + 2;
-        let legend_area = Rect {
-            height: LEGEND_HEIGHT,
-            width: legend_width,
-            y: area.y,
-            x: area.right() - legend_width,
-        };
-        draw_legend(f, legend_area);
-    }
-}
-
-fn draw_legend(f: &mut Frame, area: Rect) {
+fn draw_legend<B>(f: &mut Frame<B>, area: Rect)
+where
+    B: Backend,
+{
     let text = vec![
         Line::from(Span::styled(
             TOTAL_REVENUE,

examples/barchart.tape

@@ -1,7 +1,6 @@
 # This is a vhs script. See https://github.com/charmbracelet/vhs for more info.
 # To run this script, install vhs and run `vhs ./examples/barchart.tape`
 Output "target/barchart.gif"
-Set Theme "Aardvark Blue"
 Set Width 1200
 Set Height 800
 Hide

examples/block.rs

@@ -1,252 +1,123 @@
-use std::{
-    error::Error,
-    io::{stdout, Stdout},
-    ops::ControlFlow,
-    time::Duration,
-};
+use std::{error::Error, io, time::Duration};
 
 use crossterm::{
-    event::{self, Event, KeyCode},
+    event::{self, DisableMouseCapture, EnableMouseCapture, Event, KeyCode},
     execute,
     terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
 };
-use itertools::Itertools;
-use ratatui::{
-    prelude::*,
-    widgets::{
-        block::{Position, Title},
-        Block, BorderType, Borders, Padding, Paragraph, Wrap,
-    },
-};
+use ratatui::{prelude::*, widgets::*};
 
-// These type aliases are used to make the code more readable by reducing repetition of the generic
-// types. They are not necessary for the functionality of the code.
-type Terminal = ratatui::Terminal<CrosstermBackend<Stdout>>;
-type Result<T> = std::result::Result<T, Box<dyn Error>>;
-
-fn main() -> Result<()> {
-    let mut terminal = setup_terminal()?;
-    let result = run(&mut terminal);
-    restore_terminal(terminal)?;
-
-    if let Err(err) = result {
-        eprintln!("{err:?}");
-    }
-    Ok(())
-}
-
-fn setup_terminal() -> Result<Terminal> {
+fn main() -> Result<(), Box<dyn Error>> {
+    // setup terminal
     enable_raw_mode()?;
-    let mut stdout = stdout();
-    execute!(stdout, EnterAlternateScreen)?;
+    let mut stdout = io::stdout();
+    execute!(stdout, EnterAlternateScreen, EnableMouseCapture)?;
     let backend = CrosstermBackend::new(stdout);
-    let terminal = Terminal::new(backend)?;
-    Ok(terminal)
-}
+    let mut terminal = Terminal::new(backend)?;
 
-fn restore_terminal(mut terminal: Terminal) -> Result<()> {
+    // create app and run it
+    let res = run_app(&mut terminal);
+
+    // restore terminal
     disable_raw_mode()?;
-    execute!(terminal.backend_mut(), LeaveAlternateScreen)?;
+    execute!(
+        terminal.backend_mut(),
+        LeaveAlternateScreen,
+        DisableMouseCapture
+    )?;
+    terminal.clear()?;
+    terminal.show_cursor()?;
+
+    if let Err(err) = res {
+        println!("{err:?}");
+    }
+
     Ok(())
 }
 
-fn run(terminal: &mut Terminal) -> Result<()> {
+fn run_app<B: Backend>(terminal: &mut Terminal<B>) -> io::Result<()> {
     loop {
         terminal.draw(ui)?;
-        if handle_events()?.is_break() {
-            return Ok(());
-        }
-    }
-}
 
-fn handle_events() -> Result<ControlFlow<()>> {
-    if event::poll(Duration::from_millis(100))? {
-        if let Event::Key(key) = event::read()? {
-            if let KeyCode::Char('q') = key.code {
-                return Ok(ControlFlow::Break(()));
+        if event::poll(Duration::from_millis(250))? {
+            if let Event::Key(key) = event::read()? {
+                if let KeyCode::Char('q') = key.code {
+                    return Ok(());
+                }
             }
         }
     }
-    Ok(ControlFlow::Continue(()))
 }
 
-fn ui(frame: &mut Frame) {
-    let (title_area, layout) = calculate_layout(frame.size());
-
-    render_title(frame, title_area);
-
-    let paragraph = placeholder_paragraph();
-
-    render_borders(&paragraph, Borders::ALL, frame, layout[0][0]);
-    render_borders(&paragraph, Borders::NONE, frame, layout[0][1]);
-    render_borders(&paragraph, Borders::LEFT, frame, layout[1][0]);
-    render_borders(&paragraph, Borders::RIGHT, frame, layout[1][1]);
-    render_borders(&paragraph, Borders::TOP, frame, layout[2][0]);
-    render_borders(&paragraph, Borders::BOTTOM, frame, layout[2][1]);
-
-    render_border_type(&paragraph, BorderType::Plain, frame, layout[3][0]);
-    render_border_type(&paragraph, BorderType::Rounded, frame, layout[3][1]);
-    render_border_type(&paragraph, BorderType::Double, frame, layout[4][0]);
-    render_border_type(&paragraph, BorderType::Thick, frame, layout[4][1]);
-
-    render_styled_block(&paragraph, frame, layout[5][0]);
-    render_styled_borders(&paragraph, frame, layout[5][1]);
-    render_styled_title(&paragraph, frame, layout[6][0]);
-    render_styled_title_content(&paragraph, frame, layout[6][1]);
-    render_multiple_titles(&paragraph, frame, layout[7][0]);
-    render_multiple_title_positions(&paragraph, frame, layout[7][1]);
-    render_padding(&paragraph, frame, layout[8][0]);
-    render_nested_blocks(&paragraph, frame, layout[8][1]);
-}
-
-/// Calculate the layout of the UI elements.
-///
-/// Returns a tuple of the title area and the main areas.
-fn calculate_layout(area: Rect) -> (Rect, Vec<Vec<Rect>>) {
-    let layout = Layout::default()
+fn ui<B: Backend>(f: &mut Frame<B>) {
+    // Wrapping block for a group
+    // Just draw the block and the group on the same area and build the group
+    let outer = f.size();
+    let outer_block = Block::default()
+        .borders(Borders::ALL)
+        .title(block::Title::from("Main block with round corners").alignment(Alignment::Center))
+        .border_type(BorderType::Rounded);
+    let inner = outer_block.inner(outer);
+    let [top, bottom] = *Layout::default()
         .direction(Direction::Vertical)
-        .constraints([Constraint::Length(1), Constraint::Min(0)])
-        .split(area);
-    let title_area = layout[0];
-    let main_areas = Layout::default()
-        .direction(Direction::Vertical)
-        .constraints([Constraint::Max(4); 9])
-        .split(layout[1])
-        .iter()
-        .map(|&area| {
-            Layout::default()
-                .direction(Direction::Horizontal)
-                .constraints([Constraint::Percentage(50), Constraint::Percentage(50)])
-                .split(area)
-                .to_vec()
-        })
-        .collect_vec();
-    (title_area, main_areas)
-}
+        .margin(1)
+        .constraints([Constraint::Percentage(50), Constraint::Percentage(50)].as_ref())
+        .split(inner)
+    else {
+        return;
+    };
+    let [top_left, top_right] = *Layout::default()
+        .direction(Direction::Horizontal)
+        .constraints([Constraint::Percentage(50), Constraint::Percentage(50)].as_ref())
+        .split(top)
+    else {
+        return;
+    };
+    let [bottom_left, bottom_right] = *Layout::default()
+        .direction(Direction::Horizontal)
+        .constraints([Constraint::Percentage(50), Constraint::Percentage(50)].as_ref())
+        .split(bottom)
+    else {
+        return;
+    };
 
-fn render_title(frame: &mut Frame, area: Rect) {
-    frame.render_widget(
-        Paragraph::new("Block example. Press q to quit")
-            .dark_gray()
-            .alignment(Alignment::Center),
-        area,
+    let top_left_block = Block::default()
+        .title("With Green Background")
+        .borders(Borders::all())
+        .on_green();
+    let top_right_block = Block::default()
+        .title(
+            block::Title::from("With styled title".white().on_red().bold())
+                .alignment(Alignment::Right),
+        )
+        .borders(Borders::ALL);
+    let bottom_left_block = Paragraph::new("Text inside padded block").block(
+        Block::default()
+            .title("With borders")
+            .borders(Borders::ALL)
+            .padding(Padding {
+                left: 4,
+                right: 4,
+                top: 2,
+                bottom: 2,
+            }),
     );
-}
+    let bottom_right_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)
+        .padding(Padding::uniform(1));
+    let bottom_inner_block = Block::default()
+        .title("Block inside padded block")
+        .borders(Borders::ALL);
 
-fn placeholder_paragraph() -> Paragraph<'static> {
-    let text = "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.";
-    Paragraph::new(text.dark_gray()).wrap(Wrap { trim: true })
-}
-
-fn render_borders(paragraph: &Paragraph, border: Borders, frame: &mut Frame, area: Rect) {
-    let block = Block::new()
-        .borders(border)
-        .title(format!("Borders::{border:#?}", border = border));
-    frame.render_widget(paragraph.clone().block(block), area);
-}
-
-fn render_border_type(
-    paragraph: &Paragraph,
-    border_type: BorderType,
-    frame: &mut Frame,
-    area: Rect,
-) {
-    let block = Block::new()
-        .borders(Borders::ALL)
-        .border_type(border_type)
-        .title(format!("BorderType::{border_type:#?}"));
-    frame.render_widget(paragraph.clone().block(block), area);
-}
-fn render_styled_borders(paragraph: &Paragraph, frame: &mut Frame, area: Rect) {
-    let block = Block::new()
-        .borders(Borders::ALL)
-        .border_style(Style::new().blue().on_white().bold().italic())
-        .title("Styled borders");
-    frame.render_widget(paragraph.clone().block(block), area);
-}
-
-fn render_styled_block(paragraph: &Paragraph, frame: &mut Frame, area: Rect) {
-    let block = Block::new()
-        .borders(Borders::ALL)
-        .style(Style::new().blue().on_white().bold().italic())
-        .title("Styled block");
-    frame.render_widget(paragraph.clone().block(block), area);
-}
-
-// Note: this currently renders incorrectly, see https://github.com/ratatui-org/ratatui/issues/349
-fn render_styled_title(paragraph: &Paragraph, frame: &mut Frame, area: Rect) {
-    let block = Block::new()
-        .borders(Borders::ALL)
-        .title("Styled title")
-        .title_style(Style::new().blue().on_white().bold().italic());
-    frame.render_widget(paragraph.clone().block(block), area);
-}
-
-fn render_styled_title_content(paragraph: &Paragraph, frame: &mut Frame, area: Rect) {
-    let title = Line::from(vec![
-        "Styled ".blue().on_white().bold().italic(),
-        "title content".red().on_white().bold().italic(),
-    ]);
-    let block = Block::new().borders(Borders::ALL).title(title);
-    frame.render_widget(paragraph.clone().block(block), area);
-}
-
-fn render_multiple_titles(paragraph: &Paragraph, frame: &mut Frame, area: Rect) {
-    let block = Block::new()
-        .borders(Borders::ALL)
-        .title("Multiple".blue().on_white().bold().italic())
-        .title("Titles".red().on_white().bold().italic());
-    frame.render_widget(paragraph.clone().block(block), area);
-}
-
-fn render_multiple_title_positions(paragraph: &Paragraph, frame: &mut Frame, area: Rect) {
-    let block = Block::new()
-        .borders(Borders::ALL)
-        .title(
-            Title::from("top left")
-                .position(Position::Top)
-                .alignment(Alignment::Left),
-        )
-        .title(
-            Title::from("top center")
-                .position(Position::Top)
-                .alignment(Alignment::Center),
-        )
-        .title(
-            Title::from("top right")
-                .position(Position::Top)
-                .alignment(Alignment::Right),
-        )
-        .title(
-            Title::from("bottom left")
-                .position(Position::Bottom)
-                .alignment(Alignment::Left),
-        )
-        .title(
-            Title::from("bottom center")
-                .position(Position::Bottom)
-                .alignment(Alignment::Center),
-        )
-        .title(
-            Title::from("bottom right")
-                .position(Position::Bottom)
-                .alignment(Alignment::Right),
-        );
-    frame.render_widget(paragraph.clone().block(block), area);
-}
-
-fn render_padding(paragraph: &Paragraph, frame: &mut Frame, area: Rect) {
-    let block = Block::new()
-        .borders(Borders::ALL)
-        .title("Padding")
-        .padding(Padding::new(5, 10, 1, 2));
-    frame.render_widget(paragraph.clone().block(block), area);
-}
-
-fn render_nested_blocks(paragraph: &Paragraph, frame: &mut Frame, area: Rect) {
-    let outer_block = Block::new().borders(Borders::ALL).title("Outer block");
-    let inner_block = Block::new().borders(Borders::ALL).title("Inner block");
-    let inner = outer_block.inner(area);
-    frame.render_widget(outer_block, area);
-    frame.render_widget(paragraph.clone().block(inner_block), inner);
+    f.render_widget(outer_block, outer);
+    f.render_widget(Clear, top_left);
+    f.render_widget(top_left_block, top_left);
+    f.render_widget(top_right_block, top_right);
+    f.render_widget(bottom_left_block, bottom_left);
+    let bottom_right_inner = bottom_right_block.inner(bottom_right);
+    f.render_widget(bottom_right_block, bottom_right);
+    f.render_widget(bottom_inner_block, bottom_right_inner);
 }

examples/block.tape

@@ -1,12 +1,11 @@
 # This is a vhs script. See https://github.com/charmbracelet/vhs for more info.
 # To run this script, install vhs and run `vhs ./examples/block.tape`
 Output "target/block.gif"
-Set Theme "Aardvark Blue"
 Set Width 1200
-Set Height 1200
+Set Height 800
 Hide
 Type "cargo run --example=block"
 Enter
-Sleep 2s
+Sleep 1s
 Show
-Sleep 2s
+Sleep 5s

examples/calendar.rs

@@ -16,7 +16,7 @@ fn main() -> Result<(), Box<dyn Error>> {
     let mut terminal = Terminal::new(backend)?;
 
     loop {
-        let _ = terminal.draw(draw);
+        let _ = terminal.draw(|f| draw(f));
 
         if let Event::Key(key) = event::read()? {
             #[allow(clippy::single_match)]
@@ -35,7 +35,7 @@ fn main() -> Result<(), Box<dyn Error>> {
     Ok(())
 }
 
-fn draw(f: &mut Frame) {
+fn draw<B: Backend>(f: &mut Frame<B>) {
     let app_area = f.size();
 
     let calarea = Rect {
@@ -69,11 +69,14 @@ fn split_rows(area: &Rect) -> Rc<[Rect]> {
     let list_layout = Layout::default()
         .direction(Direction::Vertical)
         .margin(0)
-        .constraints([
-            Constraint::Percentage(33),
-            Constraint::Percentage(33),
-            Constraint::Percentage(33),
-        ]);
+        .constraints(
+            [
+                Constraint::Percentage(33),
+                Constraint::Percentage(33),
+                Constraint::Percentage(33),
+            ]
+            .as_ref(),
+        );
 
     list_layout.split(*area)
 }
@@ -82,12 +85,15 @@ fn split_cols(area: &Rect) -> Rc<[Rect]> {
     let list_layout = Layout::default()
         .direction(Direction::Horizontal)
         .margin(0)
-        .constraints([
-            Constraint::Percentage(25),
-            Constraint::Percentage(25),
-            Constraint::Percentage(25),
-            Constraint::Percentage(25),
-        ]);
+        .constraints(
+            [
+                Constraint::Percentage(25),
+                Constraint::Percentage(25),
+                Constraint::Percentage(25),
+                Constraint::Percentage(25),
+            ]
+            .as_ref(),
+        );
 
     list_layout.split(*area)
 }

examples/calendar.tape

@@ -1,7 +1,6 @@
 # This is a vhs script. See https://github.com/charmbracelet/vhs for more info.
 # To run this script, install vhs and run `vhs ./examples/calendar.tape`
 Output "target/calendar.gif"
-Set Theme "Aardvark Blue"
 Set Width 1200
 Set Height 800
 Hide

examples/canvas.rs

@@ -1,29 +1,28 @@
 use std::{
-    io::{self, stdout, Stdout},
+    error::Error,
+    io,
     time::{Duration, Instant},
 };
 
 use crossterm::{
-    event::{self, Event, KeyCode},
+    event::{self, DisableMouseCapture, EnableMouseCapture, Event, KeyCode},
+    execute,
     terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
-    ExecutableCommand,
 };
 use ratatui::{
     prelude::*,
     widgets::{canvas::*, *},
 };
 
-fn main() -> io::Result<()> {
-    App::run()
-}
-
 struct App {
     x: f64,
     y: f64,
-    ball: Circle,
+    ball: Rectangle,
     playground: Rect,
     vx: f64,
     vy: f64,
+    dir_x: bool,
+    dir_y: bool,
     tick_count: u64,
     marker: Marker,
 }
@@ -33,166 +32,155 @@ impl App {
         App {
             x: 0.0,
             y: 0.0,
-            ball: Circle {
-                x: 20.0,
-                y: 40.0,
-                radius: 10.0,
+            ball: Rectangle {
+                x: 10.0,
+                y: 30.0,
+                width: 10.0,
+                height: 10.0,
                 color: Color::Yellow,
             },
-            playground: Rect::new(10, 10, 200, 100),
+            playground: Rect::new(10, 10, 100, 100),
             vx: 1.0,
             vy: 1.0,
+            dir_x: true,
+            dir_y: true,
             tick_count: 0,
             marker: Marker::Dot,
         }
     }
 
-    pub fn run() -> io::Result<()> {
-        let mut terminal = init_terminal()?;
-        let mut app = App::new();
-        let mut last_tick = Instant::now();
-        let tick_rate = Duration::from_millis(16);
-        loop {
-            let _ = terminal.draw(|frame| app.ui(frame));
-            let timeout = tick_rate.saturating_sub(last_tick.elapsed());
-            if event::poll(timeout)? {
-                if let Event::Key(key) = event::read()? {
-                    match key.code {
-                        KeyCode::Char('q') => break,
-                        KeyCode::Down => app.y += 1.0,
-                        KeyCode::Up => app.y -= 1.0,
-                        KeyCode::Right => app.x += 1.0,
-                        KeyCode::Left => app.x -= 1.0,
-                        _ => {}
-                    }
-                }
-            }
-
-            if last_tick.elapsed() >= tick_rate {
-                app.on_tick();
-                last_tick = Instant::now();
-            }
-        }
-        restore_terminal()
-    }
-
     fn on_tick(&mut self) {
         self.tick_count += 1;
-        // only change marker every 180 ticks (3s) to avoid stroboscopic effect
-        if (self.tick_count % 180) == 0 {
+        // only change marker every 4 ticks (1s) to avoid stroboscopic effect
+        if (self.tick_count % 4) == 0 {
             self.marker = match self.marker {
-                Marker::Dot => Marker::Braille,
-                Marker::Braille => Marker::Block,
-                Marker::Block => Marker::HalfBlock,
-                Marker::HalfBlock => Marker::Bar,
-                Marker::Bar => Marker::Dot,
+                Marker::Dot => Marker::Block,
+                Marker::Block => Marker::Bar,
+                Marker::Bar => Marker::Braille,
+                Marker::Braille => Marker::Dot,
             };
         }
-        // bounce the ball by flipping the velocity vector
-        let ball = &self.ball;
-        let playground = self.playground;
-        if ball.x - ball.radius < playground.left() as f64
-            || ball.x + ball.radius > playground.right() as f64
+        if self.ball.x < self.playground.left() as f64
+            || self.ball.x + self.ball.width > self.playground.right() as f64
         {
-            self.vx = -self.vx;
+            self.dir_x = !self.dir_x;
         }
-        if ball.y - ball.radius < playground.top() as f64
-            || ball.y + ball.radius > playground.bottom() as f64
+        if self.ball.y < self.playground.top() as f64
+            || self.ball.y + self.ball.height > self.playground.bottom() as f64
         {
-            self.vy = -self.vy;
+            self.dir_y = !self.dir_y;
         }
 
-        self.ball.x += self.vx;
-        self.ball.y += self.vy;
-    }
+        if self.dir_x {
+            self.ball.x += self.vx;
+        } else {
+            self.ball.x -= self.vx;
+        }
 
-    fn ui(&self, frame: &mut Frame) {
-        let main_layout = Layout::default()
-            .direction(Direction::Horizontal)
-            .constraints([Constraint::Percentage(50), Constraint::Percentage(50)])
-            .split(frame.size());
-
-        let right_layout = Layout::default()
-            .direction(Direction::Vertical)
-            .constraints([Constraint::Percentage(50), Constraint::Percentage(50)])
-            .split(main_layout[1]);
-
-        frame.render_widget(self.map_canvas(), main_layout[0]);
-        frame.render_widget(self.pong_canvas(), right_layout[0]);
-        frame.render_widget(self.boxes_canvas(right_layout[1]), right_layout[1]);
-    }
-
-    fn map_canvas(&self) -> impl Widget + '_ {
-        Canvas::default()
-            .block(Block::default().borders(Borders::ALL).title("World"))
-            .marker(self.marker)
-            .paint(|ctx| {
-                ctx.draw(&Map {
-                    color: Color::Green,
-                    resolution: MapResolution::High,
-                });
-                ctx.print(self.x, -self.y, "You are here".yellow());
-            })
-            .x_bounds([-180.0, 180.0])
-            .y_bounds([-90.0, 90.0])
-    }
-
-    fn pong_canvas(&self) -> impl Widget + '_ {
-        Canvas::default()
-            .block(Block::default().borders(Borders::ALL).title("Pong"))
-            .marker(self.marker)
-            .paint(|ctx| {
-                ctx.draw(&self.ball);
-            })
-            .x_bounds([10.0, 210.0])
-            .y_bounds([10.0, 110.0])
-    }
-
-    fn boxes_canvas(&self, area: Rect) -> impl Widget {
-        let (left, right, bottom, top) =
-            (0.0, area.width as f64, 0.0, area.height as f64 * 2.0 - 4.0);
-        Canvas::default()
-            .block(Block::default().borders(Borders::ALL).title("Rects"))
-            .marker(self.marker)
-            .x_bounds([left, right])
-            .y_bounds([bottom, top])
-            .paint(|ctx| {
-                for i in 0..=11 {
-                    ctx.draw(&Rectangle {
-                        x: (i * i + 3 * i) as f64 / 2.0 + 2.0,
-                        y: 2.0,
-                        width: i as f64,
-                        height: i as f64,
-                        color: Color::Red,
-                    });
-                    ctx.draw(&Rectangle {
-                        x: (i * i + 3 * i) as f64 / 2.0 + 2.0,
-                        y: 21.0,
-                        width: i as f64,
-                        height: i as f64,
-                        color: Color::Blue,
-                    });
-                }
-                for i in 0..100 {
-                    if i % 10 != 0 {
-                        ctx.print(i as f64 + 1.0, 0.0, format!("{i}", i = i % 10));
-                    }
-                    if i % 2 == 0 && i % 10 != 0 {
-                        ctx.print(0.0, i as f64, format!("{i}", i = i % 10));
-                    }
-                }
-            })
+        if self.dir_y {
+            self.ball.y += self.vy;
+        } else {
+            self.ball.y -= self.vy
+        }
     }
 }
 
-fn init_terminal() -> io::Result<Terminal<CrosstermBackend<Stdout>>> {
+fn main() -> Result<(), Box<dyn Error>> {
+    // setup terminal
     enable_raw_mode()?;
-    stdout().execute(EnterAlternateScreen)?;
-    Terminal::new(CrosstermBackend::new(stdout()))
-}
+    let mut stdout = io::stdout();
+    execute!(stdout, EnterAlternateScreen, EnableMouseCapture)?;
+    let backend = CrosstermBackend::new(stdout);
+    let mut terminal = Terminal::new(backend)?;
 
-fn restore_terminal() -> io::Result<()> {
+    // create app and run it
+    let tick_rate = Duration::from_millis(250);
+    let app = App::new();
+    let res = run_app(&mut terminal, app, tick_rate);
+
+    // restore terminal
     disable_raw_mode()?;
-    stdout().execute(LeaveAlternateScreen)?;
+    execute!(
+        terminal.backend_mut(),
+        LeaveAlternateScreen,
+        DisableMouseCapture
+    )?;
+    terminal.show_cursor()?;
+
+    if let Err(err) = res {
+        println!("{err:?}");
+    }
+
     Ok(())
 }
+
+fn run_app<B: Backend>(
+    terminal: &mut Terminal<B>,
+    mut app: App,
+    tick_rate: Duration,
+) -> io::Result<()> {
+    let mut last_tick = Instant::now();
+    loop {
+        terminal.draw(|f| ui(f, &app))?;
+
+        let timeout = tick_rate
+            .checked_sub(last_tick.elapsed())
+            .unwrap_or_else(|| Duration::from_secs(0));
+        if event::poll(timeout)? {
+            if let Event::Key(key) = event::read()? {
+                match key.code {
+                    KeyCode::Char('q') => {
+                        return Ok(());
+                    }
+                    KeyCode::Down => {
+                        app.y += 1.0;
+                    }
+                    KeyCode::Up => {
+                        app.y -= 1.0;
+                    }
+                    KeyCode::Right => {
+                        app.x += 1.0;
+                    }
+                    KeyCode::Left => {
+                        app.x -= 1.0;
+                    }
+                    _ => {}
+                }
+            }
+        }
+
+        if last_tick.elapsed() >= tick_rate {
+            app.on_tick();
+            last_tick = Instant::now();
+        }
+    }
+}
+
+fn ui<B: Backend>(f: &mut Frame<B>, app: &App) {
+    let chunks = Layout::default()
+        .direction(Direction::Horizontal)
+        .constraints([Constraint::Percentage(50), Constraint::Percentage(50)].as_ref())
+        .split(f.size());
+    let canvas = Canvas::default()
+        .block(Block::default().borders(Borders::ALL).title("World"))
+        .marker(app.marker)
+        .paint(|ctx| {
+            ctx.draw(&Map {
+                color: Color::White,
+                resolution: MapResolution::High,
+            });
+            ctx.print(app.x, -app.y, "You are here".yellow());
+        })
+        .x_bounds([-180.0, 180.0])
+        .y_bounds([-90.0, 90.0]);
+    f.render_widget(canvas, chunks[0]);
+    let canvas = Canvas::default()
+        .block(Block::default().borders(Borders::ALL).title("Pong"))
+        .marker(app.marker)
+        .paint(|ctx| {
+            ctx.draw(&app.ball);
+        })
+        .x_bounds([10.0, 110.0])
+        .y_bounds([10.0, 110.0]);
+    f.render_widget(canvas, chunks[1]);
+}

examples/canvas.tape

@@ -1,13 +1,11 @@
 # This is a vhs script. See https://github.com/charmbracelet/vhs for more info.
 # To run this script, install vhs and run `vhs ./examples/canvas.tape`
 Output "target/canvas.gif"
-Set Theme "Aardvark Blue"
-Set FontSize 12
 Set Width 1200
 Set Height 800
 Hide
 Type "cargo run --example=canvas --features=crossterm"
 Enter
-Sleep 2s
+Sleep 1s
 Show
-Sleep 30s
+Sleep 5s

examples/chart.rs

@@ -125,7 +125,9 @@ fn run_app<B: Backend>(
     loop {
         terminal.draw(|f| ui(f, &app))?;
 
-        let timeout = tick_rate.saturating_sub(last_tick.elapsed());
+        let timeout = tick_rate
+            .checked_sub(last_tick.elapsed())
+            .unwrap_or_else(|| Duration::from_secs(0));
         if crossterm::event::poll(timeout)? {
             if let Event::Key(key) = event::read()? {
                 if let KeyCode::Char('q') = key.code {
@@ -140,15 +142,18 @@ fn run_app<B: Backend>(
     }
 }
 
-fn ui(f: &mut Frame, app: &App) {
+fn ui<B: Backend>(f: &mut Frame<B>, app: &App) {
     let size = f.size();
     let chunks = Layout::default()
         .direction(Direction::Vertical)
-        .constraints([
-            Constraint::Ratio(1, 3),
-            Constraint::Ratio(1, 3),
-            Constraint::Ratio(1, 3),
-        ])
+        .constraints(
+            [
+                Constraint::Ratio(1, 3),
+                Constraint::Ratio(1, 3),
+                Constraint::Ratio(1, 3),
+            ]
+            .as_ref(),
+        )
         .split(size);
     let x_labels = vec![
         Span::styled(

examples/chart.tape

@@ -1,7 +1,6 @@
 # This is a vhs script. See https://github.com/charmbracelet/vhs for more info.
 # To run this script, install vhs and run `vhs ./examples/chart.tape`
 Output "target/chart.gif"
-Set Theme "Aardvark Blue"
 Set Width 1200
 Set Height 800
 Hide

examples/colors.rs

@@ -1,295 +0,0 @@
-/// This example shows all the colors supported by ratatui. It will render a grid of foreground
-/// and background colors with their names and indexes.
-use std::{
-    error::Error,
-    io::{self, Stdout},
-    result,
-    time::Duration,
-};
-
-use crossterm::{
-    event::{self, Event, KeyCode},
-    execute,
-    terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
-};
-use itertools::Itertools;
-use ratatui::{prelude::*, widgets::*};
-
-type Result<T> = result::Result<T, Box<dyn Error>>;
-
-fn main() -> Result<()> {
-    let mut terminal = setup_terminal()?;
-    let res = run_app(&mut terminal);
-    restore_terminal(terminal)?;
-    if let Err(err) = res {
-        eprintln!("{err:?}");
-    }
-    Ok(())
-}
-
-fn run_app<B: Backend>(terminal: &mut Terminal<B>) -> io::Result<()> {
-    loop {
-        terminal.draw(ui)?;
-
-        if event::poll(Duration::from_millis(250))? {
-            if let Event::Key(key) = event::read()? {
-                if let KeyCode::Char('q') = key.code {
-                    return Ok(());
-                }
-            }
-        }
-    }
-}
-
-fn ui(frame: &mut Frame) {
-    let layout = Layout::default()
-        .direction(Direction::Vertical)
-        .constraints([
-            Constraint::Length(30),
-            Constraint::Length(17),
-            Constraint::Length(2),
-        ])
-        .split(frame.size());
-
-    render_named_colors(frame, layout[0]);
-    render_indexed_colors(frame, layout[1]);
-    render_indexed_grayscale(frame, layout[2]);
-}
-
-const NAMED_COLORS: [Color; 16] = [
-    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,
-];
-
-fn render_named_colors(frame: &mut Frame, area: Rect) {
-    let layout = Layout::default()
-        .direction(Direction::Vertical)
-        .constraints([Constraint::Length(3); 10])
-        .split(area);
-
-    render_fg_named_colors(frame, Color::Reset, layout[0]);
-    render_fg_named_colors(frame, Color::Black, layout[1]);
-    render_fg_named_colors(frame, Color::DarkGray, layout[2]);
-    render_fg_named_colors(frame, Color::Gray, layout[3]);
-    render_fg_named_colors(frame, Color::White, layout[4]);
-
-    render_bg_named_colors(frame, Color::Reset, layout[5]);
-    render_bg_named_colors(frame, Color::Black, layout[6]);
-    render_bg_named_colors(frame, Color::DarkGray, layout[7]);
-    render_bg_named_colors(frame, Color::Gray, layout[8]);
-    render_bg_named_colors(frame, Color::White, layout[9]);
-}
-
-fn render_fg_named_colors(frame: &mut Frame, bg: Color, area: Rect) {
-    let block = title_block(format!("Foreground colors on {bg} background"));
-    let inner = block.inner(area);
-    frame.render_widget(block, area);
-
-    let layout = Layout::default()
-        .direction(Direction::Vertical)
-        .constraints([Constraint::Length(1); 2])
-        .split(inner)
-        .iter()
-        .flat_map(|area| {
-            Layout::default()
-                .direction(Direction::Horizontal)
-                .constraints([Constraint::Ratio(1, 8); 8])
-                .split(*area)
-                .to_vec()
-        })
-        .collect_vec();
-    for (i, &fg) in NAMED_COLORS.iter().enumerate() {
-        let color_name = fg.to_string();
-        let paragraph = Paragraph::new(color_name).fg(fg).bg(bg);
-        frame.render_widget(paragraph, layout[i]);
-    }
-}
-
-fn render_bg_named_colors(frame: &mut Frame, fg: Color, area: Rect) {
-    let block = title_block(format!("Background colors with {fg} foreground"));
-    let inner = block.inner(area);
-    frame.render_widget(block, area);
-
-    let layout = Layout::default()
-        .direction(Direction::Vertical)
-        .constraints([Constraint::Length(1); 2])
-        .split(inner)
-        .iter()
-        .flat_map(|area| {
-            Layout::default()
-                .direction(Direction::Horizontal)
-                .constraints([Constraint::Ratio(1, 8); 8])
-                .split(*area)
-                .to_vec()
-        })
-        .collect_vec();
-    for (i, &bg) in NAMED_COLORS.iter().enumerate() {
-        let color_name = bg.to_string();
-        let paragraph = Paragraph::new(color_name).fg(fg).bg(bg);
-        frame.render_widget(paragraph, layout[i]);
-    }
-}
-
-fn render_indexed_colors(frame: &mut Frame, area: Rect) {
-    let block = title_block("Indexed colors".into());
-    let inner = block.inner(area);
-    frame.render_widget(block, area);
-
-    let layout = Layout::default()
-        .direction(Direction::Vertical)
-        .constraints([
-            Constraint::Length(1), // 0 - 15
-            Constraint::Length(1), // blank
-            Constraint::Min(6),    // 16 - 123
-            Constraint::Length(1), // blank
-            Constraint::Min(6),    // 124 - 231
-            Constraint::Length(1), // blank
-        ])
-        .split(inner);
-
-    //    0   1   2   3   4   5    6   7   8   9  10  11   12  13  14  15
-    let color_layout = Layout::default()
-        .direction(Direction::Horizontal)
-        .constraints([Constraint::Length(5); 16])
-        .split(layout[0]);
-    for i in 0..16 {
-        let color = Color::Indexed(i);
-        let color_index = format!("{i:0>2}");
-        let bg = if i < 1 { Color::DarkGray } else { Color::Black };
-        let paragraph = Paragraph::new(Line::from(vec![
-            color_index.fg(color).bg(bg),
-            "██".bg(color).fg(color),
-        ]));
-        frame.render_widget(paragraph, color_layout[i as usize]);
-    }
-
-    //   16  17  18  19  20  21   52  53  54  55  56  57   88  89  90  91  92  93
-    //   22  23  24  25  26  27   58  59  60  61  62  63   94  95  96  97  98  99
-    //   28  29  30  31  32  33   64  65  66  67  68  69  100 101 102 103 104 105
-    //   34  35  36  37  38  39   70  71  72  73  74  75  106 107 108 109 110 111
-    //   40  41  42  43  44  45   76  77  78  79  80  81  112 113 114 115 116 117
-    //   46  47  48  49  50  51   82  83  84  85  86  87  118 119 120 121 122 123
-    //
-    //  124 125 126 127 128 129  160 161 162 163 164 165  196 197 198 199 200 201
-    //  130 131 132 133 134 135  166 167 168 169 170 171  202 203 204 205 206 207
-    //  136 137 138 139 140 141  172 173 174 175 176 177  208 209 210 211 212 213
-    //  142 143 144 145 146 147  178 179 180 181 182 183  214 215 216 217 218 219
-    //  148 149 150 151 152 153  184 185 186 187 188 189  220 221 222 223 224 225
-    //  154 155 156 157 158 159  190 191 192 193 194 195  226 227 228 229 230 231
-
-    // the above looks complex but it's so the colors are grouped into blocks that display nicely
-    let index_layout = [layout[2], layout[4]]
-        .iter()
-        // two rows of 3 columns
-        .flat_map(|area| {
-            Layout::default()
-                .direction(Direction::Horizontal)
-                .constraints([Constraint::Length(27); 3])
-                .split(*area)
-                .to_vec()
-        })
-        // each with 6 rows
-        .flat_map(|area| {
-            Layout::default()
-                .direction(Direction::Vertical)
-                .constraints([Constraint::Length(1); 6])
-                .split(area)
-                .to_vec()
-        })
-        // each with 6 columns
-        .flat_map(|area| {
-            Layout::default()
-                .direction(Direction::Horizontal)
-                .constraints([Constraint::Min(4); 6])
-                .split(area)
-                .to_vec()
-        })
-        .collect_vec();
-
-    for i in 16..=231 {
-        let color = Color::Indexed(i);
-        let color_index = format!("{i:0>3}");
-        let paragraph = Paragraph::new(Line::from(vec![
-            color_index.fg(color).bg(Color::Reset),
-            ".".bg(color).fg(color),
-            // There's a bug in VHS that seems to bleed backgrounds into the next
-            // character. This is a workaround to make the bug less obvious.
-            "███".reversed(),
-        ]));
-        frame.render_widget(paragraph, index_layout[i as usize - 16]);
-    }
-}
-
-fn title_block(title: String) -> Block<'static> {
-    Block::default()
-        .borders(Borders::TOP)
-        .border_style(Style::new().dark_gray())
-        .title(title)
-        .title_alignment(Alignment::Center)
-        .title_style(Style::new().reset())
-}
-
-fn render_indexed_grayscale(frame: &mut Frame, area: Rect) {
-    let layout = Layout::default()
-        .direction(Direction::Vertical)
-        .constraints([
-            Constraint::Length(1), // 232 - 243
-            Constraint::Length(1), // 244 - 255
-        ])
-        .split(area)
-        .iter()
-        .flat_map(|area| {
-            Layout::default()
-                .direction(Direction::Horizontal)
-                .constraints([Constraint::Length(6); 12])
-                .split(*area)
-                .to_vec()
-        })
-        .collect_vec();
-
-    for i in 232..=255 {
-        let color = Color::Indexed(i);
-        let color_index = format!("{i:0>3}");
-        // make the dark colors easier to read
-        let bg = if i < 244 { Color::Gray } else { Color::Black };
-        let paragraph = Paragraph::new(Line::from(vec![
-            color_index.fg(color).bg(bg),
-            "██".bg(color).fg(color),
-            // There's a bug in VHS that seems to bleed backgrounds into the next
-            // character. This is a workaround to make the bug less obvious.
-            "███████".reversed(),
-        ]));
-        frame.render_widget(paragraph, layout[i as usize - 232]);
-    }
-}
-
-fn setup_terminal() -> Result<Terminal<CrosstermBackend<Stdout>>> {
-    enable_raw_mode()?;
-    let mut stdout = io::stdout();
-    execute!(stdout, EnterAlternateScreen)?;
-    let backend = CrosstermBackend::new(stdout);
-    let mut terminal = Terminal::new(backend)?;
-    terminal.hide_cursor()?;
-    Ok(terminal)
-}
-
-fn restore_terminal(mut terminal: Terminal<CrosstermBackend<Stdout>>) -> Result<()> {
-    disable_raw_mode()?;
-    execute!(terminal.backend_mut(), LeaveAlternateScreen)?;
-    terminal.show_cursor()?;
-    Ok(())
-}

examples/colors.tape

@@ -1,12 +0,0 @@
-# This is a vhs script. See https://github.com/charmbracelet/vhs for more info.
-# To run this script, install vhs and run `vhs ./examples/colors.tape`
-Output "target/colors.gif"
-Set Theme "Aardvark Blue"
-Set Width 1200
-Set Height 1410
-Hide
-Type "cargo run --example=colors --features=crossterm"
-Enter
-Sleep 2s
-Show
-Sleep 1s

examples/colors_rgb.rs

@@ -1,147 +0,0 @@
-/// This example shows the full range of RGB colors that can be displayed in the terminal.
-///
-/// Requires a terminal that supports 24-bit color (true color) and unicode.
-use std::{
-    error::Error,
-    io::{stdout, Stdout},
-    rc::Rc,
-    time::Duration,
-};
-
-use crossterm::{
-    event::{self, Event, KeyCode, KeyEventKind},
-    terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
-    ExecutableCommand,
-};
-use palette::{
-    convert::{FromColorUnclamped, IntoColorUnclamped},
-    Okhsv, Srgb,
-};
-use ratatui::{prelude::*, widgets::*};
-
-type Result<T> = std::result::Result<T, Box<dyn Error>>;
-
-fn main() -> Result<()> {
-    install_panic_hook();
-    App::new()?.run()
-}
-
-struct App {
-    terminal: Terminal<CrosstermBackend<Stdout>>,
-    should_quit: bool,
-}
-
-impl App {
-    pub fn new() -> Result<Self> {
-        Ok(Self {
-            terminal: Terminal::new(CrosstermBackend::new(stdout()))?,
-            should_quit: false,
-        })
-    }
-
-    pub fn run(mut self) -> Result<()> {
-        init_terminal()?;
-        self.terminal.clear()?;
-        while !self.should_quit {
-            self.draw()?;
-            self.handle_events()?;
-        }
-        restore_terminal()?;
-        Ok(())
-    }
-
-    fn draw(&mut self) -> Result<()> {
-        self.terminal.draw(|frame| {
-            frame.render_widget(RgbColors, frame.size());
-        })?;
-        Ok(())
-    }
-
-    fn handle_events(&mut self) -> Result<()> {
-        if event::poll(Duration::from_millis(100))? {
-            if let Event::Key(key) = event::read()? {
-                if key.kind == KeyEventKind::Press && key.code == KeyCode::Char('q') {
-                    self.should_quit = true;
-                };
-            }
-        }
-        Ok(())
-    }
-}
-
-impl Drop for App {
-    fn drop(&mut self) {
-        let _ = restore_terminal();
-    }
-}
-
-struct RgbColors;
-
-impl Widget for RgbColors {
-    fn render(self, area: Rect, buf: &mut Buffer) {
-        let layout = Self::layout(area);
-        Self::render_title(layout[0], buf);
-        Self::render_colors(layout[1], buf);
-    }
-}
-
-impl RgbColors {
-    fn layout(area: Rect) -> Rc<[Rect]> {
-        Layout::default()
-            .direction(Direction::Vertical)
-            .constraints([Constraint::Length(1), Constraint::Min(0)])
-            .split(area)
-    }
-
-    fn render_title(area: Rect, buf: &mut Buffer) {
-        Paragraph::new("colors_rgb example. Press q to quit")
-            .dark_gray()
-            .alignment(Alignment::Center)
-            .render(area, buf);
-    }
-
-    /// Render a colored grid of half block characters (`"▀"`) each with a different RGB color.
-    fn render_colors(area: Rect, buf: &mut Buffer) {
-        for (xi, x) in (area.left()..area.right()).enumerate() {
-            for (yi, y) in (area.top()..area.bottom()).enumerate() {
-                let hue = xi as f32 * 360.0 / area.width as f32;
-
-                let value_fg = (yi as f32) / (area.height as f32 - 0.5);
-                let fg = Okhsv::<f32>::new(hue, Okhsv::max_saturation(), value_fg);
-                let fg: Srgb = fg.into_color_unclamped();
-                let fg: Srgb<u8> = fg.into_format();
-                let fg = Color::Rgb(fg.red, fg.green, fg.blue);
-
-                let value_bg = (yi as f32 + 0.5) / (area.height as f32 - 0.5);
-                let bg = Okhsv::new(hue, Okhsv::max_saturation(), value_bg);
-                let bg = Srgb::<f32>::from_color_unclamped(bg);
-                let bg: Srgb<u8> = bg.into_format();
-                let bg = Color::Rgb(bg.red, bg.green, bg.blue);
-
-                buf.get_mut(x, y).set_char('▀').set_fg(fg).set_bg(bg);
-            }
-        }
-    }
-}
-
-/// Install a panic hook that restores the terminal before panicking.
-fn install_panic_hook() {
-    better_panic::install();
-    let prev_hook = std::panic::take_hook();
-    std::panic::set_hook(Box::new(move |info| {
-        let _ = restore_terminal();
-        prev_hook(info);
-    }));
-}
-
-fn init_terminal() -> Result<()> {
-    enable_raw_mode()?;
-    stdout().execute(EnterAlternateScreen)?;
-    Ok(())
-}
-
-fn restore_terminal() -> Result<()> {
-    disable_raw_mode()?;
-    stdout().execute(LeaveAlternateScreen)?;
-    Ok(())
-}

examples/colors_rgb.tape

@@ -1,13 +0,0 @@
-# This is a vhs script. See https://github.com/charmbracelet/vhs for more info.
-# To run this script, install vhs and run `vhs ./examples/colors_rgb.tape`
-Output "target/colors_rgb.gif"
-Set Theme "Aardvark Blue"
-Set Width 1200
-Set Height 800
-Hide
-Type "cargo run --example=colors_rgb --features=crossterm"
-Enter
-Sleep 2s
-Screenshot "target/colors_rgb.png"
-Show
-Sleep 1s

examples/custom_widget.rs

@@ -1,121 +1,27 @@
-use std::{error::Error, io, ops::ControlFlow, time::Duration};
+use std::{error::Error, io};
 
 use crossterm::{
-    event::{
-        self, DisableMouseCapture, EnableMouseCapture, Event, KeyCode, MouseButton, MouseEvent,
-        MouseEventKind,
-    },
+    event::{self, DisableMouseCapture, EnableMouseCapture, Event, KeyCode},
     execute,
     terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
 };
 use ratatui::{prelude::*, widgets::*};
 
-/// A custom widget that renders a button with a label, theme and state.
-#[derive(Debug, Clone)]
-struct Button<'a> {
-    label: Line<'a>,
-    theme: Theme,
-    state: State,
+#[derive(Default)]
+struct Label<'a> {
+    text: &'a str,
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-enum State {
-    Normal,
-    Selected,
-    Active,
-}
-
-#[derive(Debug, Clone, Copy)]
-struct Theme {
-    text: Color,
-    background: Color,
-    highlight: Color,
-    shadow: Color,
-}
-
-const BLUE: Theme = Theme {
-    text: Color::Rgb(16, 24, 48),
-    background: Color::Rgb(48, 72, 144),
-    highlight: Color::Rgb(64, 96, 192),
-    shadow: Color::Rgb(32, 48, 96),
-};
-
-const RED: Theme = Theme {
-    text: Color::Rgb(48, 16, 16),
-    background: Color::Rgb(144, 48, 48),
-    highlight: Color::Rgb(192, 64, 64),
-    shadow: Color::Rgb(96, 32, 32),
-};
-
-const GREEN: Theme = Theme {
-    text: Color::Rgb(16, 48, 16),
-    background: Color::Rgb(48, 144, 48),
-    highlight: Color::Rgb(64, 192, 64),
-    shadow: Color::Rgb(32, 96, 32),
-};
-
-/// A button with a label that can be themed.
-impl<'a> Button<'a> {
-    pub fn new<T: Into<Line<'a>>>(label: T) -> Button<'a> {
-        Button {
-            label: label.into(),
-            theme: BLUE,
-            state: State::Normal,
-        }
-    }
-
-    pub fn theme(mut self, theme: Theme) -> Button<'a> {
-        self.theme = theme;
-        self
-    }
-
-    pub fn state(mut self, state: State) -> Button<'a> {
-        self.state = state;
-        self
-    }
-}
-
-impl<'a> Widget for Button<'a> {
+impl<'a> Widget for Label<'a> {
     fn render(self, area: Rect, buf: &mut Buffer) {
-        let (background, text, shadow, highlight) = self.colors();
-        buf.set_style(area, Style::new().bg(background).fg(text));
-
-        // render top line if there's enough space
-        if area.height > 2 {
-            buf.set_string(
-                area.x,
-                area.y,
-                "▔".repeat(area.width as usize),
-                Style::new().fg(highlight).bg(background),
-            );
-        }
-        // render bottom line if there's enough space
-        if area.height > 1 {
-            buf.set_string(
-                area.x,
-                area.y + area.height - 1,
-                "▁".repeat(area.width as usize),
-                Style::new().fg(shadow).bg(background),
-            );
-        }
-        // render label centered
-        buf.set_line(
-            area.x + (area.width.saturating_sub(self.label.width() as u16)) / 2,
-            area.y + (area.height.saturating_sub(1)) / 2,
-            &self.label,
-            area.width,
-        );
+        buf.set_string(area.left(), area.top(), self.text, Style::default());
     }
 }
 
-impl Button<'_> {
-    fn colors(&self) -> (Color, Color, Color, Color) {
-        let theme = self.theme;
-        match self.state {
-            State::Normal => (theme.background, theme.text, theme.shadow, theme.highlight),
-            State::Selected => (theme.highlight, theme.text, theme.shadow, theme.highlight),
-            State::Active => (theme.background, theme.text, theme.highlight, theme.shadow),
-        }
+impl<'a> Label<'a> {
+    fn text(mut self, text: &'a str) -> Label<'a> {
+        self.text = text;
+        self
     }
 }
 
@@ -147,126 +53,19 @@ fn main() -> Result<(), Box<dyn Error>> {
 }
 
 fn run_app<B: Backend>(terminal: &mut Terminal<B>) -> io::Result<()> {
-    let mut selected_button: usize = 0;
-    let button_states = &mut [State::Selected, State::Normal, State::Normal];
     loop {
-        terminal.draw(|frame| ui(frame, button_states))?;
-        if !event::poll(Duration::from_millis(100))? {
-            continue;
-        }
-        match event::read()? {
-            Event::Key(key) => {
-                if key.kind != event::KeyEventKind::Press {
-                    continue;
-                }
-                if handle_key_event(key, button_states, &mut selected_button).is_break() {
-                    break;
-                }
+        terminal.draw(ui)?;
+
+        if let Event::Key(key) = event::read()? {
+            if let KeyCode::Char('q') = key.code {
+                return Ok(());
             }
-            Event::Mouse(mouse) => handle_mouse_event(mouse, button_states, &mut selected_button),
-            _ => (),
         }
     }
-    Ok(())
 }
 
-fn ui(frame: &mut Frame, states: &[State; 3]) {
-    let layout = Layout::default()
-        .direction(Direction::Vertical)
-        .constraints([
-            Constraint::Length(1),
-            Constraint::Max(3),
-            Constraint::Length(1),
-            Constraint::Min(0), // ignore remaining space
-        ])
-        .split(frame.size());
-    frame.render_widget(
-        Paragraph::new("Custom Widget Example (mouse enabled)"),
-        layout[0],
-    );
-    render_buttons(frame, layout[1], states);
-    frame.render_widget(
-        Paragraph::new("←/→: select, Space: toggle, q: quit"),
-        layout[2],
-    );
-}
-
-fn render_buttons(frame: &mut Frame<'_>, area: Rect, states: &[State; 3]) {
-    let layout = Layout::default()
-        .direction(Direction::Horizontal)
-        .constraints([
-            Constraint::Length(15),
-            Constraint::Length(15),
-            Constraint::Length(15),
-            Constraint::Min(0), // ignore remaining space
-        ])
-        .split(area);
-    frame.render_widget(Button::new("Red").theme(RED).state(states[0]), layout[0]);
-    frame.render_widget(
-        Button::new("Green").theme(GREEN).state(states[1]),
-        layout[1],
-    );
-    frame.render_widget(Button::new("Blue").theme(BLUE).state(states[2]), layout[2]);
-}
-
-fn handle_key_event(
-    key: event::KeyEvent,
-    button_states: &mut [State; 3],
-    selected_button: &mut usize,
-) -> ControlFlow<()> {
-    match key.code {
-        KeyCode::Char('q') => return ControlFlow::Break(()),
-        KeyCode::Left => {
-            button_states[*selected_button] = State::Normal;
-            *selected_button = selected_button.saturating_sub(1);
-            button_states[*selected_button] = State::Selected;
-        }
-        KeyCode::Right => {
-            button_states[*selected_button] = State::Normal;
-            *selected_button = selected_button.saturating_add(1).min(2);
-            button_states[*selected_button] = State::Selected;
-        }
-        KeyCode::Char(' ') => {
-            if button_states[*selected_button] == State::Active {
-                button_states[*selected_button] = State::Normal;
-            } else {
-                button_states[*selected_button] = State::Active;
-            }
-        }
-        _ => (),
-    }
-    ControlFlow::Continue(())
-}
-
-fn handle_mouse_event(
-    mouse: MouseEvent,
-    button_states: &mut [State; 3],
-    selected_button: &mut usize,
-) {
-    match mouse.kind {
-        MouseEventKind::Moved => {
-            let old_selected_button = *selected_button;
-            *selected_button = match mouse.column {
-                x if x < 15 => 0,
-                x if x < 30 => 1,
-                _ => 2,
-            };
-            if old_selected_button != *selected_button {
-                if button_states[old_selected_button] != State::Active {
-                    button_states[old_selected_button] = State::Normal;
-                }
-                if button_states[*selected_button] != State::Active {
-                    button_states[*selected_button] = State::Selected;
-                }
-            }
-        }
-        MouseEventKind::Down(MouseButton::Left) => {
-            if button_states[*selected_button] == State::Active {
-                button_states[*selected_button] = State::Normal;
-            } else {
-                button_states[*selected_button] = State::Active;
-            }
-        }
-        _ => (),
-    }
+fn ui<B: Backend>(f: &mut Frame<B>) {
+    let size = f.size();
+    let label = Label::default().text("Test");
+    f.render_widget(label, size);
 }

examples/custom_widget.tape

@@ -1,21 +1,11 @@
 # This is a vhs script. See https://github.com/charmbracelet/vhs for more info.
 # To run this script, install vhs and run `vhs ./examples/custom_widget.tape`
 Output "target/custom_widget.gif"
-Set Theme "Aardvark Blue"
-Set Width 760
-Set Height 260
+Set Width 1200
+Set Height 200
 Hide
 Type "cargo run --example=custom_widget --features=crossterm"
 Enter
-Sleep 2s
-Show
 Sleep 1s
-Set TypingSpeed 0.7s
-Right
-Right
-Space
-Space
-Left
-Space
-Left
-Space
+Show
+Sleep 5s

examples/demo.tape

@@ -1,18 +0,0 @@
-# This is a vhs script. See https://github.com/charmbracelet/vhs for more info.
-# To run this script, install vhs and run `vhs ./examples/demo.tape`
-Output "target/demo.gif"
-Set Theme "Aardvark Blue"
-Set Width 1200
-Set Height 1200
-Set PlaybackSpeed 0.5
-Hide
-Type "cargo run --example demo"
-Enter
-Sleep 2s
-Show
-Sleep 1s
-Down@1s 12
-Right
-Sleep 4s
-Right
-Sleep 4s

examples/demo/crossterm.rs

@@ -50,7 +50,9 @@ fn run_app<B: Backend>(
     loop {
         terminal.draw(|f| ui::draw(f, &mut app))?;
 
-        let timeout = tick_rate.saturating_sub(last_tick.elapsed());
+        let timeout = tick_rate
+            .checked_sub(last_tick.elapsed())
+            .unwrap_or_else(|| Duration::from_secs(0));
         if crossterm::event::poll(timeout)? {
             if let Event::Key(key) = event::read()? {
                 if key.kind == KeyEventKind::Press {

examples/demo/termwiz.rs

@@ -1,5 +1,6 @@
 use std::{
     error::Error,
+    io,
     time::{Duration, Instant},
 };
 
@@ -31,17 +32,19 @@ fn run_app(
     terminal: &mut Terminal<TermwizBackend>,
     mut app: App,
     tick_rate: Duration,
-) -> Result<(), Box<dyn Error>> {
+) -> io::Result<()> {
     let mut last_tick = Instant::now();
     loop {
         terminal.draw(|f| ui::draw(f, &mut app))?;
 
-        let timeout = tick_rate.saturating_sub(last_tick.elapsed());
-        if let Some(input) = terminal
+        let timeout = tick_rate
+            .checked_sub(last_tick.elapsed())
+            .unwrap_or_else(|| Duration::from_secs(0));
+        if let Ok(Some(input)) = terminal
             .backend_mut()
             .buffered_terminal_mut()
             .terminal()
-            .poll_input(Some(timeout))?
+            .poll_input(Some(timeout))
         {
             match input {
                 InputEvent::Key(key_code) => match key_code.key {

examples/demo/ui.rs

@@ -5,9 +5,9 @@ use ratatui::{
 
 use crate::app::App;
 
-pub fn draw(f: &mut Frame, app: &mut App) {
+pub fn draw<B: Backend>(f: &mut Frame<B>, app: &mut App) {
     let chunks = Layout::default()
-        .constraints([Constraint::Length(3), Constraint::Min(0)])
+        .constraints([Constraint::Length(3), Constraint::Min(0)].as_ref())
         .split(f.size());
     let titles = app
         .tabs
@@ -28,26 +28,38 @@ pub fn draw(f: &mut Frame, app: &mut App) {
     };
 }
 
-fn draw_first_tab(f: &mut Frame, app: &mut 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(9),
-            Constraint::Min(8),
-            Constraint::Length(7),
-        ])
+        .constraints(
+            [
+                Constraint::Length(9),
+                Constraint::Min(8),
+                Constraint::Length(7),
+            ]
+            .as_ref(),
+        )
         .split(area);
     draw_gauges(f, app, chunks[0]);
     draw_charts(f, app, chunks[1]);
     draw_text(f, chunks[2]);
 }
 
-fn draw_gauges(f: &mut Frame, app: &mut 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),
-            Constraint::Length(1),
-        ])
+        .constraints(
+            [
+                Constraint::Length(2),
+                Constraint::Length(3),
+                Constraint::Length(1),
+            ]
+            .as_ref(),
+        )
         .margin(1)
         .split(area);
     let block = Block::default().borders(Borders::ALL).title("Graphs");
@@ -90,7 +102,10 @@ fn draw_gauges(f: &mut Frame, app: &mut App, area: Rect) {
     f.render_widget(line_gauge, chunks[2]);
 }
 
-fn draw_charts(f: &mut Frame, app: &mut App, area: Rect) {
+fn draw_charts<B>(f: &mut Frame<B>, app: &mut App, area: Rect)
+where
+    B: Backend,
+{
     let constraints = if app.show_chart {
         vec![Constraint::Percentage(50), Constraint::Percentage(50)]
     } else {
@@ -102,11 +117,11 @@ fn draw_charts(f: &mut Frame, app: &mut App, area: Rect) {
         .split(area);
     {
         let chunks = Layout::default()
-            .constraints([Constraint::Percentage(50), Constraint::Percentage(50)])
+            .constraints([Constraint::Percentage(50), Constraint::Percentage(50)].as_ref())
             .split(chunks[0]);
         {
             let chunks = Layout::default()
-                .constraints([Constraint::Percentage(50), Constraint::Percentage(50)])
+                .constraints([Constraint::Percentage(50), Constraint::Percentage(50)].as_ref())
                 .direction(Direction::Horizontal)
                 .split(chunks[0]);
 
@@ -234,7 +249,10 @@ fn draw_charts(f: &mut Frame, app: &mut App, area: Rect) {
     }
 }
 
-fn draw_text(f: &mut Frame, area: Rect) {
+fn draw_text<B>(f: &mut Frame<B>, area: Rect)
+where
+    B: Backend,
+{
     let text = vec![
         text::Line::from("This is a paragraph with several lines. You can change style your text the way you want"),
         text::Line::from(""),
@@ -272,9 +290,12 @@ fn draw_text(f: &mut Frame, area: Rect) {
     f.render_widget(paragraph, area);
 }
 
-fn draw_second_tab(f: &mut Frame, app: &mut App, area: Rect) {
+fn draw_second_tab<B>(f: &mut Frame<B>, app: &mut App, area: Rect)
+where
+    B: Backend,
+{
     let chunks = Layout::default()
-        .constraints([Constraint::Percentage(30), Constraint::Percentage(70)])
+        .constraints([Constraint::Percentage(30), Constraint::Percentage(70)].as_ref())
         .direction(Direction::Horizontal)
         .split(area);
     let up_style = Style::default().fg(Color::Green);
@@ -296,7 +317,7 @@ fn draw_second_tab(f: &mut Frame, app: &mut App, area: Rect) {
                 .bottom_margin(1),
         )
         .block(Block::default().title("Servers").borders(Borders::ALL))
-        .widths([
+        .widths(&[
             Constraint::Length(15),
             Constraint::Length(15),
             Constraint::Length(10),
@@ -358,7 +379,10 @@ fn draw_second_tab(f: &mut Frame, app: &mut App, area: Rect) {
     f.render_widget(map, chunks[1]);
 }
 
-fn draw_third_tab(f: &mut Frame, _app: &mut App, area: Rect) {
+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)])
@@ -395,7 +419,7 @@ fn draw_third_tab(f: &mut Frame, _app: &mut App, area: Rect) {
         .collect();
     let table = Table::new(items)
         .block(Block::default().title("Colors").borders(Borders::ALL))
-        .widths([
+        .widths(&[
             Constraint::Ratio(1, 3),
             Constraint::Ratio(1, 3),
             Constraint::Ratio(1, 3),

examples/demo2-social.tape

@@ -1,43 +0,0 @@
-# This is a vhs script. See https://github.com/charmbracelet/vhs for more info.
-# To run this script, install vhs and run `vhs ./examples/demo.tape`
-
-Output "target/demo2-social.gif"
-Set Theme "Aardvark Blue"
-# Github social preview size (1280x640 with 80px padding) and must be < 1MB
-# This puts some constraints on the amount of interactivity we can do.
-Set Width 1280
-Set Height 640
-Set Padding 80
-Hide
-Type "cargo run --example demo2 --features crossterm,widget-calendar"
-Enter
-Sleep 2s
-Show
-# About screen
-Sleep 3.5s
-Down # Red eye
-Sleep 0.4s
-Down # black eye
-Sleep 1s
-Tab
-# Recipe
-Sleep 1s
-Set TypingSpeed 500ms
-Down 7
-Sleep 1s
-Tab
-# Email
-Sleep 2s
-Down 4
-Sleep 2s
-Tab
-# Trace route
-Sleep 1s
-Set TypingSpeed 200ms
-Down 10
-Sleep 2s
-Tab
-# Weather
-Set TypingSpeed 100ms
-Down 40
-Sleep 2s

examples/demo2.tape

@@ -1,49 +0,0 @@
-# This is a vhs script. See https://github.com/charmbracelet/vhs for more info.
-# To run this script, install vhs and run `vhs ./examples/demo.tape`
-# NOTE: Requires VHS 0.6.1 or later for Screenshot support
-Output "target/demo2.gif"
-Set Theme "Aardvark Blue"
-# The reason for this strange size is that the social preview image for this
-# demo is 1280x64 with 80 pixels of padding on each side. We want a version
-# without the padding for README.md, etc.
-Set Width 1120
-Set Height 480
-Set Padding 0
-Hide
-Type "cargo run --example demo2 --features crossterm,widget-calendar"
-Enter
-Sleep 2s
-Show
-# About screen
-Screenshot "target/demo2-about.png"
-Sleep 3.5s
-Down # Red eye
-Sleep 0.4s
-Down # black eye
-Sleep 1s
-Tab
-# Recipe
-Screenshot "target/demo2-recipe.png"
-Sleep 1s
-Set TypingSpeed 500ms
-Down 7
-Sleep 1s
-Tab
-# Email
-Screenshot "target/demo2-email.png"
-Sleep 2s
-Down 4
-Sleep 2s
-Tab
-# Trace route
-Screenshot "target/demo2-trace.png"
-Sleep 1s
-Set TypingSpeed 200ms
-Down 10
-Sleep 2s
-Tab
-# Weather
-Screenshot "target/demo2-weather.png"
-Set TypingSpeed 100ms
-Down 40
-Sleep 2s

examples/demo2/app.rs

@@ -1,99 +0,0 @@
-use std::time::Duration;
-
-use anyhow::{Context, Result};
-use crossterm::event::{Event, KeyCode, KeyEvent, KeyEventKind, KeyModifiers};
-use ratatui::prelude::Rect;
-
-use crate::{Root, Term};
-
-#[derive(Debug)]
-pub struct App {
-    term: Term,
-    should_quit: bool,
-    context: AppContext,
-}
-
-#[derive(Debug, Default, Clone, Copy)]
-pub struct AppContext {
-    pub tab_index: usize,
-    pub row_index: usize,
-}
-
-impl App {
-    fn new() -> Result<Self> {
-        Ok(Self {
-            term: Term::start()?,
-            should_quit: false,
-            context: AppContext::default(),
-        })
-    }
-
-    pub fn run() -> Result<()> {
-        install_panic_hook();
-        let mut app = Self::new()?;
-        while !app.should_quit {
-            app.draw()?;
-            app.handle_events()?;
-        }
-        Term::stop()?;
-        Ok(())
-    }
-
-    fn draw(&mut self) -> Result<()> {
-        self.term
-            .draw(|frame| frame.render_widget(Root::new(&self.context), frame.size()))
-            .context("terminal.draw")?;
-        Ok(())
-    }
-
-    fn handle_events(&mut self) -> Result<()> {
-        match Term::next_event(Duration::from_millis(16))? {
-            Some(Event::Key(key)) => self.handle_key_event(key),
-            Some(Event::Resize(width, height)) => {
-                Ok(self.term.resize(Rect::new(0, 0, width, height))?)
-            }
-            _ => Ok(()),
-        }
-    }
-
-    fn handle_key_event(&mut self, key: KeyEvent) -> Result<()> {
-        if key.kind != KeyEventKind::Press {
-            return Ok(());
-        }
-
-        let context = &mut self.context;
-        const TAB_COUNT: usize = 5;
-        match key.code {
-            KeyCode::Char('q') | KeyCode::Esc => {
-                self.should_quit = true;
-            }
-            KeyCode::Tab | KeyCode::BackTab if key.modifiers.contains(KeyModifiers::SHIFT) => {
-                let tab_index = context.tab_index + TAB_COUNT; // to wrap around properly
-                context.tab_index = tab_index.saturating_sub(1) % TAB_COUNT;
-                context.row_index = 0;
-            }
-            KeyCode::Tab | KeyCode::BackTab => {
-                context.tab_index = context.tab_index.saturating_add(1) % TAB_COUNT;
-                context.row_index = 0;
-            }
-            KeyCode::Up | KeyCode::Char('k') => {
-                context.row_index = context.row_index.saturating_sub(1);
-            }
-            KeyCode::Down | KeyCode::Char('j') => {
-                context.row_index = context.row_index.saturating_add(1);
-            }
-            _ => {}
-        };
-        Ok(())
-    }
-}
-
-pub fn install_panic_hook() {
-    better_panic::install();
-    let hook = std::panic::take_hook();
-    std::panic::set_hook(Box::new(move |info| {
-        let _ = Term::stop();
-        hook(info);
-        std::process::exit(1);
-    }));
-}

examples/demo2/colors.rs

@@ -1,34 +0,0 @@
-use palette::{IntoColor, Okhsv, Srgb};
-use ratatui::{prelude::*, widgets::*};
-
-/// A widget that renders a color swatch of RGB colors.
-///
-/// The widget is rendered as a rectangle with the hue changing along the x-axis from 0.0 to 360.0
-/// and the value changing along the y-axis (from 1.0 to 0.0). Each pixel is rendered as a block
-/// character with the top half slightly lighter than the bottom half.
-pub struct RgbSwatch;
-
-impl Widget for RgbSwatch {
-    fn render(self, area: Rect, buf: &mut Buffer) {
-        for (yi, y) in (area.top()..area.bottom()).enumerate() {
-            let value = area.height as f32 - yi as f32;
-            let value_fg = value / (area.height as f32);
-            let value_bg = (value - 0.5) / (area.height as f32);
-            for (xi, x) in (area.left()..area.right()).enumerate() {
-                let hue = xi as f32 * 360.0 / area.width as f32;
-                let fg = color_from_oklab(hue, Okhsv::max_saturation(), value_fg);
-                let bg = color_from_oklab(hue, Okhsv::max_saturation(), value_bg);
-                buf.get_mut(x, y).set_char('▀').set_fg(fg).set_bg(bg);
-            }
-        }
-    }
-}
-
-/// Convert a hue and value into an RGB color via the OkLab color space.
-///
-/// See <https://bottosson.github.io/posts/oklab/> for more details.
-pub fn color_from_oklab(hue: f32, saturation: f32, value: f32) -> Color {
-    let color: Srgb = Okhsv::new(hue, saturation, value).into_color();
-    let color = color.into_format();
-    Color::Rgb(color.red, color.green, color.blue)
-}

examples/demo2/main.rs

@@ -1,17 +0,0 @@
-use anyhow::Result;
-pub use app::*;
-pub use colors::*;
-pub use root::*;
-pub use term::*;
-pub use theme::*;
-
-mod app;
-mod colors;
-mod root;
-mod tabs;
-mod term;
-mod theme;
-
-fn main() -> Result<()> {
-    App::run()
-}

examples/demo2/root.rs

@@ -1,93 +0,0 @@
-use std::rc::Rc;
-
-use itertools::Itertools;
-use ratatui::{prelude::*, widgets::*};
-
-use crate::{tabs::*, AppContext, THEME};
-
-pub struct Root<'a> {
-    context: &'a AppContext,
-}
-
-impl<'a> Root<'a> {
-    pub fn new(context: &'a AppContext) -> Self {
-        Root { context }
-    }
-}
-
-impl Widget for Root<'_> {
-    fn render(self, area: Rect, buf: &mut Buffer) {
-        Block::new().style(THEME.root).render(area, buf);
-        let area = layout(area, Direction::Vertical, vec![1, 0, 1]);
-        self.render_title_bar(area[0], buf);
-        self.render_selected_tab(area[1], buf);
-        self.render_bottom_bar(area[2], buf);
-    }
-}
-
-impl Root<'_> {
-    fn render_title_bar(&self, area: Rect, buf: &mut Buffer) {
-        let area = layout(area, Direction::Horizontal, vec![0, 45]);
-
-        Paragraph::new(Span::styled("Ratatui", THEME.app_title)).render(area[0], buf);
-        let titles = vec!["", " Recipe ", " Email ", " Traceroute ", " Weather "];
-        Tabs::new(titles)
-            .style(THEME.tabs)
-            .highlight_style(THEME.tabs_selected)
-            .select(self.context.tab_index)
-            .divider("")
-            .render(area[1], buf);
-    }
-
-    fn render_selected_tab(&self, area: Rect, buf: &mut Buffer) {
-        let row_index = self.context.row_index;
-        match self.context.tab_index {
-            0 => AboutTab::new(row_index).render(area, buf),
-            1 => RecipeTab::new(row_index).render(area, buf),
-            2 => EmailTab::new(row_index).render(area, buf),
-            3 => TracerouteTab::new(row_index).render(area, buf),
-            4 => WeatherTab::new(row_index).render(area, buf),
-            _ => unreachable!(),
-        };
-    }
-
-    fn render_bottom_bar(&self, area: Rect, buf: &mut Buffer) {
-        let keys = [
-            ("Q/Esc", "Quit"),
-            ("Tab", "Next Tab"),
-            ("↑/k", "Up"),
-            ("↓/j", "Down"),
-        ];
-        let spans = keys
-            .iter()
-            .flat_map(|(key, desc)| {
-                let key = Span::styled(format!(" {} ", key), THEME.key_binding.key);
-                let desc = Span::styled(format!(" {} ", desc), THEME.key_binding.description);
-                [key, desc]
-            })
-            .collect_vec();
-        Paragraph::new(Line::from(spans))
-            .alignment(Alignment::Center)
-            .fg(Color::Indexed(236))
-            .bg(Color::Indexed(232))
-            .render(area, buf);
-    }
-}
-
-/// simple helper method to split an area into multiple sub-areas
-pub fn layout(area: Rect, direction: Direction, heights: Vec<u16>) -> Rc<[Rect]> {
-    let constraints = heights
-        .iter()
-        .map(|&h| {
-            if h > 0 {
-                Constraint::Length(h)
-            } else {
-                Constraint::Min(0)
-            }
-        })
-        .collect_vec();
-    Layout::default()
-        .direction(direction)
-        .constraints(constraints)
-        .split(area)
-}

examples/demo2/tabs.rs

@@ -1,11 +0,0 @@
-mod about;
-mod email;
-mod recipe;
-mod traceroute;
-mod weather;
-
-pub use about::AboutTab;
-pub use email::EmailTab;
-pub use recipe::RecipeTab;
-pub use traceroute::TracerouteTab;
-pub use weather::WeatherTab;

examples/demo2/tabs/about.rs

@@ -1,157 +0,0 @@
-use itertools::Itertools;
-use ratatui::{prelude::*, widgets::*};
-
-use crate::{layout, RgbSwatch, THEME};
-
-const RATATUI_LOGO: [&str; 32] = [
-    "               ███              ",
-    "             ██████             ",
-    "            ███████             ",
-    "           ████████             ",
-    "          █████████             ",
-    "         ██████████             ",
-    "        ████████████            ",
-    "        █████████████           ",
-    "        █████████████     ██████",
-    "         ███████████    ████████",
-    "              █████ ███████████ ",
-    "               ███ ██ee████████ ",
-    "                █ █████████████ ",
-    "            ████ █████████████  ",
-    "           █████████████████    ",
-    "           ████████████████     ",
-    "           ████████████████     ",
-    "            ███ ██████████      ",
-    "          ██    █████████       ",
-    "         █xx█   █████████       ",
-    "        █xxxx█ ██████████       ",
-    "       █xx█xxx█ █████████       ",
-    "      █xx██xxxx█ ████████       ",
-    "     █xxxxxxxxxx█ ██████████    ",
-    "    █xxxxxxxxxxxx█ ██████████   ",
-    "   █xxxxxxx██xxxxx█ █████████   ",
-    "  █xxxxxxxxx██xxxxx█ ████  ███  ",
-    " █xxxxxxxxxxxxxxxxxx█ ██   ███  ",
-    "█xxxxxxxxxxxxxxxxxxxx█ █   ███  ",
-    "█xxxxxxxxxxxxxxxxxxxxx█   ███   ",
-    " █xxxxxxxxxxxxxxxxxxxxx█ ███    ",
-    "  █xxxxxxxxxxxxxxxxxxxxx█ █     ",
-];
-
-pub struct AboutTab {
-    selected_row: usize,
-}
-
-impl AboutTab {
-    pub fn new(selected_row: usize) -> Self {
-        Self { selected_row }
-    }
-}
-
-impl Widget for AboutTab {
-    fn render(self, area: Rect, buf: &mut Buffer) {
-        RgbSwatch.render(area, buf);
-        let area = layout(area, Direction::Horizontal, vec![34, 0]);
-        render_crate_description(area[1], buf);
-        render_logo(self.selected_row, area[0], buf);
-    }
-}
-
-fn render_crate_description(area: Rect, buf: &mut Buffer) {
-    let area = area.inner(
-        &(Margin {
-            vertical: 4,
-            horizontal: 2,
-        }),
-    );
-    Clear.render(area, buf); // clear out the color swatches
-    Block::new().style(THEME.content).render(area, buf);
-    let area = area.inner(
-        &(Margin {
-            vertical: 1,
-            horizontal: 2,
-        }),
-    );
-    let text = "- cooking up terminal user interfaces -
-
-    Ratatui is a Rust crate that provides widgets (e.g. Paragraph, Table) and draws them to the \
-    screen efficiently every frame.";
-    Paragraph::new(text)
-        .style(THEME.description)
-        .block(
-            Block::new()
-                .title(" Ratatui ")
-                .title_alignment(Alignment::Center)
-                .borders(Borders::TOP)
-                .border_style(THEME.description_title)
-                .padding(Padding::new(0, 0, 0, 0)),
-        )
-        .wrap(Wrap { trim: true })
-        .scroll((0, 0))
-        .render(area, buf);
-}
-
-/// Use half block characters to render a logo based on the RATATUI_LOGO const.
-///
-/// The logo is rendered in three colors, one for the rat, one for the terminal, and one for the
-/// rat's eye. The eye color alternates between two colors based on the selected row.
-pub fn render_logo(selected_row: usize, area: Rect, buf: &mut Buffer) {
-    let eye_color = if selected_row % 2 == 0 {
-        THEME.logo.rat_eye
-    } else {
-        THEME.logo.rat_eye_alt
-    };
-    let area = area.inner(&Margin {
-        vertical: 0,
-        horizontal: 2,
-    });
-    for (y, (line1, line2)) in RATATUI_LOGO.iter().tuples().enumerate() {
-        for (x, (ch1, ch2)) in line1.chars().zip(line2.chars()).enumerate() {
-            let x = area.left() + x as u16;
-            let y = area.top() + y as u16;
-            let cell = buf.get_mut(x, y);
-            let rat_color = THEME.logo.rat;
-            let term_color = THEME.logo.term;
-            match (ch1, ch2) {
-                ('█', '█') => {
-                    cell.set_char('█');
-                    cell.fg = rat_color;
-                }
-                ('█', ' ') => {
-                    cell.set_char('▀');
-                    cell.fg = rat_color;
-                }
-                (' ', '█') => {
-                    cell.set_char('▄');
-                    cell.fg = rat_color;
-                }
-                ('█', 'x') => {
-                    cell.set_char('▀');
-                    cell.fg = rat_color;
-                    cell.bg = term_color;
-                }
-                ('x', '█') => {
-                    cell.set_char('▄');
-                    cell.fg = rat_color;
-                    cell.bg = term_color;
-                }
-                ('x', 'x') => {
-                    cell.set_char(' ');
-                    cell.fg = term_color;
-                    cell.bg = term_color;
-                }
-                ('█', 'e') => {
-                    cell.set_char('▀');
-                    cell.fg = rat_color;
-                    cell.bg = eye_color;
-                }
-                ('e', '█') => {
-                    cell.set_char('▄');
-                    cell.fg = rat_color;
-                    cell.bg = eye_color;
-                }
-                (_, _) => {}
-            };
-        }
-    }
-}

examples/demo2/tabs/email.rs

@@ -1,143 +0,0 @@
-use itertools::Itertools;
-use ratatui::{prelude::*, widgets::*};
-use unicode_width::UnicodeWidthStr;
-
-use crate::{layout, RgbSwatch, THEME};
-
-#[derive(Debug, Default)]
-pub struct Email {
-    from: &'static str,
-    subject: &'static str,
-    body: &'static str,
-}
-
-const EMAILS: &[Email] = &[
-    Email {
-        from: "Alice <alice@example.com>",
-        subject: "Hello",
-        body: "Hi Bob,\nHow are you?\n\nAlice",
-    },
-    Email {
-        from: "Bob <bob@example.com>",
-        subject: "Re: Hello",
-        body: "Hi Alice,\nI'm fine, thanks!\n\nBob",
-    },
-    Email {
-        from: "Charlie <charlie@example.com>",
-        subject: "Re: Hello",
-        body: "Hi Alice,\nI'm fine, thanks!\n\nCharlie",
-    },
-    Email {
-        from: "Dave <dave@example.com>",
-        subject: "Re: Hello (STOP REPLYING TO ALL)",
-        body: "Hi Everyone,\nPlease stop replying to all.\n\nDave",
-    },
-    Email {
-        from: "Eve <eve@example.com>",
-        subject: "Re: Hello (STOP REPLYING TO ALL)",
-        body: "Hi Everyone,\nI'm reading all your emails.\n\nEve",
-    },
-];
-
-#[derive(Debug, Default)]
-pub struct EmailTab {
-    selected_index: usize,
-}
-
-impl EmailTab {
-    pub fn new(selected_index: usize) -> Self {
-        Self {
-            selected_index: selected_index % EMAILS.len(),
-        }
-    }
-}
-
-impl Widget for EmailTab {
-    fn render(self, area: Rect, buf: &mut Buffer) {
-        RgbSwatch.render(area, buf);
-        let area = area.inner(&Margin {
-            vertical: 1,
-            horizontal: 2,
-        });
-        Clear.render(area, buf);
-        let area = layout(area, Direction::Vertical, vec![5, 0]);
-        render_inbox(self.selected_index, area[0], buf);
-        render_email(self.selected_index, area[1], buf);
-    }
-}
-fn render_inbox(selected_index: usize, area: Rect, buf: &mut Buffer) {
-    let area = layout(area, Direction::Vertical, vec![1, 0]);
-    let theme = THEME.email;
-    Tabs::new(vec![" Inbox ", " Sent ", " Drafts "])
-        .style(theme.tabs)
-        .highlight_style(theme.tabs_selected)
-        .select(0)
-        .divider("")
-        .render(area[0], buf);
-
-    let highlight_symbol = ">>";
-    let from_width = EMAILS
-        .iter()
-        .map(|e| e.from.width())
-        .max()
-        .unwrap_or_default();
-    let items = EMAILS
-        .iter()
-        .map(|e| {
-            let from = format!("{:width$}", e.from, width = from_width).into();
-            ListItem::new(Line::from(vec![from, " ".into(), e.subject.into()]))
-        })
-        .collect_vec();
-    let mut state = ListState::default().with_selected(Some(selected_index));
-    StatefulWidget::render(
-        List::new(items)
-            .style(theme.inbox)
-            .highlight_style(theme.selected_item)
-            .highlight_symbol(highlight_symbol),
-        area[1],
-        buf,
-        &mut state,
-    );
-    let mut scrollbar_state = ScrollbarState::default()
-        .content_length(EMAILS.len())
-        .position(selected_index);
-    Scrollbar::default()
-        .begin_symbol(None)
-        .end_symbol(None)
-        .track_symbol(None)
-        .thumb_symbol("▐")
-        .render(area[1], buf, &mut scrollbar_state);
-}
-
-fn render_email(selected_index: usize, area: Rect, buf: &mut Buffer) {
-    let theme = THEME.email;
-    let email = EMAILS.get(selected_index);
-    let block = Block::new()
-        .style(theme.body)
-        .padding(Padding::new(2, 2, 0, 0))
-        .borders(Borders::TOP)
-        .border_type(BorderType::Thick);
-    let inner = block.inner(area);
-    block.render(area, buf);
-    if let Some(email) = email {
-        let area = layout(inner, Direction::Vertical, vec![3, 0]);
-        let headers = vec![
-            Line::from(vec![
-                "From: ".set_style(theme.header),
-                email.from.set_style(theme.header_value),
-            ]),
-            Line::from(vec![
-                "Subject: ".set_style(theme.header),
-                email.subject.set_style(theme.header_value),
-            ]),
-            "-".repeat(inner.width as usize).dim().into(),
-        ];
-        Paragraph::new(headers)
-            .style(theme.body)
-            .render(area[0], buf);
-        let body = email.body.lines().map(Line::from).collect_vec();
-        Paragraph::new(body).style(theme.body).render(area[1], buf);
-    } else {
-        Paragraph::new("No email selected").render(inner, buf);
-    }
-}

examples/demo2/tabs/recipe.rs

@@ -1,171 +0,0 @@
-use itertools::Itertools;
-use ratatui::{prelude::*, widgets::*};
-
-use crate::{layout, RgbSwatch, THEME};
-
-#[derive(Debug, Default, Clone, Copy)]
-struct Ingredient {
-    quantity: &'static str,
-    name: &'static str,
-}
-
-impl Ingredient {
-    fn height(&self) -> u16 {
-        self.name.lines().count() as u16
-    }
-}
-
-impl<'a> From<Ingredient> for Row<'a> {
-    fn from(i: Ingredient) -> Self {
-        Row::new(vec![i.quantity, i.name]).height(i.height())
-    }
-}
-
-// https://www.realsimple.com/food-recipes/browse-all-recipes/ratatouille
-const RECIPE: &[(&str, &str)] = &[
-    (
-        "Step 1: ",
-        "Over medium-low heat, add the oil to a large skillet with the onion, garlic, and bay \
-        leaf, stirring occasionally, until the onion has softened.",
-    ),
-    (
-        "Step 2: ",
-        "Add the eggplant and cook, stirring occasionally, for 8 minutes or until the eggplant \
-        has softened. Stir in the zucchini, red bell pepper, tomatoes, and salt, and cook over \
-        medium heat, stirring occasionally, for 5 to 7 minutes or until the vegetables are \
-        tender. Stir in the basil and few grinds of pepper to taste.",
-    ),
-];
-
-const INGREDIENTS: &[Ingredient] = &[
-    Ingredient {
-        quantity: "4 tbsp",
-        name: "olive oil",
-    },
-    Ingredient {
-        quantity: "1",
-        name: "onion thinly sliced",
-    },
-    Ingredient {
-        quantity: "4",
-        name: "cloves garlic\npeeled and sliced",
-    },
-    Ingredient {
-        quantity: "1",
-        name: "small bay leaf",
-    },
-    Ingredient {
-        quantity: "1",
-        name: "small eggplant cut\ninto 1/2 inch cubes",
-    },
-    Ingredient {
-        quantity: "1",
-        name: "small zucchini halved\nlengthwise and cut\ninto thin slices",
-    },
-    Ingredient {
-        quantity: "1",
-        name: "red bell pepper cut\ninto slivers",
-    },
-    Ingredient {
-        quantity: "4",
-        name: "plum tomatoes\ncoarsely chopped",
-    },
-    Ingredient {
-        quantity: "1 tsp",
-        name: "kosher salt",
-    },
-    Ingredient {
-        quantity: "1/4 cup",
-        name: "shredded fresh basil\nleaves",
-    },
-    Ingredient {
-        quantity: "",
-        name: "freshly ground black\npepper",
-    },
-];
-
-#[derive(Debug)]
-pub struct RecipeTab {
-    selected_row: usize,
-}
-
-impl RecipeTab {
-    pub fn new(selected_row: usize) -> Self {
-        Self {
-            selected_row: selected_row % INGREDIENTS.len(),
-        }
-    }
-}
-
-impl Widget for RecipeTab {
-    fn render(self, area: Rect, buf: &mut Buffer) {
-        RgbSwatch.render(area, buf);
-        let area = area.inner(&Margin {
-            vertical: 1,
-            horizontal: 2,
-        });
-        Clear.render(area, buf);
-        Block::new()
-            .title("Ratatouille Recipe".bold().white())
-            .title_alignment(Alignment::Center)
-            .style(THEME.content)
-            .padding(Padding::new(1, 1, 2, 1))
-            .render(area, buf);
-
-        let scrollbar_area = Rect {
-            y: area.y + 2,
-            height: area.height - 3,
-            ..area
-        };
-        render_scrollbar(self.selected_row, scrollbar_area, buf);
-
-        let area = area.inner(&Margin {
-            horizontal: 2,
-            vertical: 1,
-        });
-        let area = layout(area, Direction::Horizontal, vec![44, 0]);
-
-        render_recipe(area[0], buf);
-        render_ingredients(self.selected_row, area[1], buf);
-    }
-}
-
-fn render_recipe(area: Rect, buf: &mut Buffer) {
-    let lines = RECIPE
-        .iter()
-        .map(|(step, text)| Line::from(vec![step.white().bold(), text.gray()]))
-        .collect_vec();
-    Paragraph::new(lines)
-        .wrap(Wrap { trim: true })
-        .block(Block::new().padding(Padding::new(0, 1, 0, 0)))
-        .render(area, buf);
-}
-
-fn render_ingredients(selected_row: usize, area: Rect, buf: &mut Buffer) {
-    let mut state = TableState::default().with_selected(Some(selected_row));
-    let rows = INGREDIENTS.iter().map(|&i| i.into()).collect_vec();
-    let theme = THEME.recipe;
-    StatefulWidget::render(
-        Table::new(rows)
-            .block(Block::new().style(theme.ingredients))
-            .header(Row::new(vec!["Qty", "Ingredient"]).style(theme.ingredients_header))
-            .widths([Constraint::Length(7), Constraint::Length(30)])
-            .highlight_style(Style::new().light_yellow()),
-        area,
-        buf,
-        &mut state,
-    );
-}
-
-fn render_scrollbar(position: usize, area: Rect, buf: &mut Buffer) {
-    let mut state = ScrollbarState::default()
-        .content_length(INGREDIENTS.len())
-        .viewport_content_length(6)
-        .position(position);
-    Scrollbar::new(ScrollbarOrientation::VerticalRight)
-        .begin_symbol(None)
-        .end_symbol(None)
-        .track_symbol(None)
-        .thumb_symbol("▐")
-        .render(area, buf, &mut state)
-}

examples/demo2/tabs/traceroute.rs

@@ -1,199 +0,0 @@
-use itertools::Itertools;
-use ratatui::{
-    prelude::*,
-    widgets::{canvas::*, *},
-};
-
-use crate::{layout, RgbSwatch, THEME};
-
-#[derive(Debug)]
-pub struct TracerouteTab {
-    selected_row: usize,
-}
-
-impl TracerouteTab {
-    pub fn new(selected_row: usize) -> Self {
-        Self {
-            selected_row: selected_row % HOPS.len(),
-        }
-    }
-}
-
-impl Widget for TracerouteTab {
-    fn render(self, area: Rect, buf: &mut Buffer) {
-        RgbSwatch.render(area, buf);
-        let area = area.inner(&Margin {
-            vertical: 1,
-            horizontal: 2,
-        });
-        Clear.render(area, buf);
-        Block::new().style(THEME.content).render(area, buf);
-        let area = Layout::default()
-            .direction(Direction::Horizontal)
-            .constraints([Constraint::Ratio(1, 2), Constraint::Ratio(1, 2)])
-            .split(area);
-        let left_area = layout(area[0], Direction::Vertical, vec![0, 3]);
-        render_hops(self.selected_row, left_area[0], buf);
-        render_ping(self.selected_row, left_area[1], buf);
-        render_map(self.selected_row, area[1], buf);
-    }
-}
-
-fn render_hops(selected_row: usize, area: Rect, buf: &mut Buffer) {
-    let mut state = TableState::default().with_selected(Some(selected_row));
-    let rows = HOPS
-        .iter()
-        .map(|hop| Row::new(vec![hop.host, hop.address]))
-        .collect_vec();
-    let block = Block::default()
-        .title("Traceroute bad.horse".bold().white())
-        .title_alignment(Alignment::Center)
-        .padding(Padding::new(1, 1, 1, 1));
-    StatefulWidget::render(
-        Table::new(rows)
-            .header(Row::new(vec!["Host", "Address"]).set_style(THEME.traceroute.header))
-            .widths([Constraint::Max(100), Constraint::Length(15)])
-            .highlight_style(THEME.traceroute.selected)
-            .block(block),
-        area,
-        buf,
-        &mut state,
-    );
-    let mut scrollbar_state = ScrollbarState::default()
-        .content_length(HOPS.len())
-        .position(selected_row);
-    let area = Rect {
-        width: area.width + 1,
-        y: area.y + 3,
-        height: area.height - 4,
-        ..area
-    };
-    Scrollbar::default()
-        .orientation(ScrollbarOrientation::VerticalLeft)
-        .begin_symbol(None)
-        .end_symbol(None)
-        .track_symbol(None)
-        .thumb_symbol("▌")
-        .render(area, buf, &mut scrollbar_state);
-}
-
-pub fn render_ping(progress: usize, area: Rect, buf: &mut Buffer) {
-    let mut data = [
-        8, 8, 8, 8, 7, 7, 7, 6, 6, 5, 4, 3, 3, 2, 2, 1, 1, 1, 2, 2, 3, 4, 5, 6, 7, 7, 8, 8, 8, 7,
-        7, 6, 5, 4, 3, 2, 1, 1, 1, 1, 1, 2, 4, 6, 7, 8, 8, 8, 8, 6, 4, 2, 1, 1, 1, 1, 2, 2, 2, 3,
-        3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7,
-    ];
-    let mid = progress % data.len();
-    data.rotate_left(mid);
-    Sparkline::default()
-        .block(
-            Block::new()
-                .title("Ping")
-                .title_alignment(Alignment::Center)
-                .border_type(BorderType::Thick),
-        )
-        .data(&data)
-        .style(THEME.traceroute.ping)
-        .render(area, buf);
-}
-
-fn render_map(selected_row: usize, area: Rect, buf: &mut Buffer) {
-    let theme = THEME.traceroute.map;
-    let path: Option<(&Hop, &Hop)> = HOPS.iter().tuple_windows().nth(selected_row);
-    let map = Map {
-        resolution: canvas::MapResolution::High,
-        color: theme.color,
-    };
-    Canvas::default()
-        .background_color(theme.background_color)
-        .block(
-            Block::new()
-                .padding(Padding::new(1, 0, 1, 0))
-                .style(theme.style),
-        )
-        .marker(Marker::HalfBlock)
-        // picked to show Australia for the demo as it's the most interesting part of the map
-        // (and the only part with hops ;))
-        .x_bounds([112.0, 155.0])
-        .y_bounds([-46.0, -11.0])
-        .paint(|context| {
-            context.draw(&map);
-            if let Some(path) = path {
-                context.draw(&canvas::Line::new(
-                    path.0.location.0,
-                    path.0.location.1,
-                    path.1.location.0,
-                    path.1.location.1,
-                    theme.path,
-                ));
-                context.draw(&Points {
-                    color: theme.source,
-                    coords: &[path.0.location], // sydney
-                });
-                context.draw(&Points {
-                    color: theme.destination,
-                    coords: &[path.1.location], // perth
-                });
-            }
-        })
-        .render(area, buf);
-}
-
-#[derive(Debug)]
-struct Hop {
-    host: &'static str,
-    address: &'static str,
-    location: (f64, f64),
-}
-
-impl Hop {
-    const fn new(name: &'static str, address: &'static str, location: (f64, f64)) -> Self {
-        Self {
-            host: name,
-            address,
-            location,
-        }
-    }
-}
-
-const CANBERRA: (f64, f64) = (149.1, -35.3);
-const SYDNEY: (f64, f64) = (151.1, -33.9);
-const MELBOURNE: (f64, f64) = (144.9, -37.8);
-const PERTH: (f64, f64) = (115.9, -31.9);
-const DARWIN: (f64, f64) = (130.8, -12.4);
-const BRISBANE: (f64, f64) = (153.0, -27.5);
-const ADELAIDE: (f64, f64) = (138.6, -34.9);
-
-// Go traceroute bad.horse some time, it's fun. these locations are made up and don't correspond
-// to the actual IP addresses (which are in Toronto, Canada).
-const HOPS: &[Hop] = &[
-    Hop::new("home", "127.0.0.1", CANBERRA),
-    Hop::new("bad.horse", "162.252.205.130", SYDNEY),
-    Hop::new("bad.horse", "162.252.205.131", MELBOURNE),
-    Hop::new("bad.horse", "162.252.205.132", BRISBANE),
-    Hop::new("bad.horse", "162.252.205.133", SYDNEY),
-    Hop::new("he.rides.across.the.nation", "162.252.205.134", PERTH),
-    Hop::new("the.thoroughbred.of.sin", "162.252.205.135", DARWIN),
-    Hop::new("he.got.the.application", "162.252.205.136", BRISBANE),
-    Hop::new("that.you.just.sent.in", "162.252.205.137", ADELAIDE),
-    Hop::new("it.needs.evaluation", "162.252.205.138", DARWIN),
-    Hop::new("so.let.the.games.begin", "162.252.205.139", PERTH),
-    Hop::new("a.heinous.crime", "162.252.205.140", BRISBANE),
-    Hop::new("a.show.of.force", "162.252.205.141", CANBERRA),
-    Hop::new("a.murder.would.be.nice.of.course", "162.252.205.142", PERTH),
-    Hop::new("bad.horse", "162.252.205.143", MELBOURNE),
-    Hop::new("bad.horse", "162.252.205.144", DARWIN),
-    Hop::new("bad.horse", "162.252.205.145", MELBOURNE),
-    Hop::new("he-s.bad", "162.252.205.146", PERTH),
-    Hop::new("the.evil.league.of.evil", "162.252.205.147", BRISBANE),
-    Hop::new("is.watching.so.beware", "162.252.205.148", DARWIN),
-    Hop::new("the.grade.that.you.receive", "162.252.205.149", PERTH),
-    Hop::new("will.be.your.last.we.swear", "162.252.205.150", ADELAIDE),
-    Hop::new("so.make.the.bad.horse.gleeful", "162.252.205.151", SYDNEY),
-    Hop::new("or.he-ll.make.you.his.mare", "162.252.205.152", MELBOURNE),
-    Hop::new("o_o", "162.252.205.153", BRISBANE),
-    Hop::new("you-re.saddled.up", "162.252.205.154", DARWIN),
-    Hop::new("there-s.no.recourse", "162.252.205.155", PERTH),
-    Hop::new("it-s.hi-ho.silver", "162.252.205.156", SYDNEY),
-    Hop::new("signed.bad.horse", "162.252.205.157", CANBERRA),
-];

examples/demo2/tabs/weather.rs

@@ -1,141 +0,0 @@
-use itertools::Itertools;
-use palette::Okhsv;
-use ratatui::{
-    prelude::*,
-    widgets::{calendar::CalendarEventStore, *},
-};
-use time::OffsetDateTime;
-
-use crate::{color_from_oklab, layout, RgbSwatch, THEME};
-
-pub struct WeatherTab {
-    pub selected_row: usize,
-}
-
-impl WeatherTab {
-    pub fn new(selected_row: usize) -> Self {
-        Self { selected_row }
-    }
-}
-
-impl Widget for WeatherTab {
-    fn render(self, area: Rect, buf: &mut Buffer) {
-        RgbSwatch.render(area, buf);
-        let area = area.inner(&Margin {
-            vertical: 1,
-            horizontal: 2,
-        });
-        Clear.render(area, buf);
-        Block::new().style(THEME.content).render(area, buf);
-
-        let area = area.inner(&Margin {
-            horizontal: 2,
-            vertical: 1,
-        });
-        let area = layout(area, Direction::Vertical, vec![0, 1, 1]);
-        render_gauges(self.selected_row, area[2], buf);
-
-        let area = layout(area[0], Direction::Horizontal, vec![23, 0]);
-        render_calendar(area[0], buf);
-        let area = layout(area[1], Direction::Horizontal, vec![29, 0]);
-        render_simple_barchart(area[0], buf);
-        render_horizontal_barchart(area[1], buf);
-    }
-}
-
-fn render_calendar(area: Rect, buf: &mut Buffer) {
-    let date = OffsetDateTime::now_utc().date();
-    calendar::Monthly::new(date, CalendarEventStore::today(Style::new().red().bold()))
-        .block(Block::new().padding(Padding::new(0, 0, 2, 0)))
-        .show_month_header(Style::new().bold())
-        .show_weekdays_header(Style::new().italic())
-        .render(area, buf);
-}
-
-fn render_simple_barchart(area: Rect, buf: &mut Buffer) {
-    let data = [
-        ("Sat", 76),
-        ("Sun", 69),
-        ("Mon", 65),
-        ("Tue", 67),
-        ("Wed", 65),
-        ("Thu", 69),
-        ("Fri", 73),
-    ];
-    let data = data
-        .into_iter()
-        .map(|(label, value)| {
-            Bar::default()
-                .value(value)
-                // This doesn't actually render correctly as the text is too wide for the bar
-                // See https://github.com/ratatui-org/ratatui/issues/513 for more info
-                // (the demo GIFs hack around this by hacking the calculation in bars.rs)
-                .text_value(format!("{}°", value))
-                .style(if value > 70 {
-                    Style::new().fg(Color::Red)
-                } else {
-                    Style::new().fg(Color::Yellow)
-                })
-                .value_style(if value > 70 {
-                    Style::new().fg(Color::Gray).bg(Color::Red).bold()
-                } else {
-                    Style::new().fg(Color::DarkGray).bg(Color::Yellow).bold()
-                })
-                .label(label.into())
-        })
-        .collect_vec();
-    let group = BarGroup::default().bars(&data);
-    BarChart::default()
-        .data(group)
-        .bar_width(3)
-        .bar_gap(1)
-        .render(area, buf);
-}
-
-fn render_horizontal_barchart(area: Rect, buf: &mut Buffer) {
-    let bg = Color::Rgb(32, 48, 96);
-    let data = [
-        Bar::default().text_value("Winter 37-51".into()).value(51),
-        Bar::default().text_value("Spring 40-65".into()).value(65),
-        Bar::default().text_value("Summer 54-77".into()).value(77),
-        Bar::default()
-            .text_value("Fall 41-71".into())
-            .value(71)
-            .value_style(Style::new().bold()), // current season
-    ];
-    let group = BarGroup::default().label("GPU".into()).bars(&data);
-    BarChart::default()
-        .block(Block::new().padding(Padding::new(0, 0, 2, 0)))
-        .direction(Direction::Horizontal)
-        .data(group)
-        .bar_gap(1)
-        .bar_style(Style::new().fg(bg))
-        .value_style(Style::new().bg(bg).fg(Color::Gray))
-        .render(area, buf);
-}
-
-pub fn render_gauges(progress: usize, area: Rect, buf: &mut Buffer) {
-    let percent = (progress * 3).min(100) as f64;
-
-    render_line_gauge(percent, area, buf);
-}
-
-fn render_line_gauge(percent: f64, area: Rect, buf: &mut Buffer) {
-    // cycle color hue based on the percent for a neat effect yellow -> red
-    let hue = 90.0 - (percent as f32 * 0.6);
-    let value = Okhsv::max_value();
-    let fg = color_from_oklab(hue, Okhsv::max_saturation(), value);
-    let bg = color_from_oklab(hue, Okhsv::max_saturation(), value * 0.5);
-    let label = if percent < 100.0 {
-        format!("Downloading: {}%", percent)
-    } else {
-        "Download Complete!".into()
-    };
-    LineGauge::default()
-        .ratio(percent / 100.0)
-        .label(label)
-        .style(Style::new().light_blue())
-        .gauge_style(Style::new().fg(fg).bg(bg))
-        .line_set(symbols::line::THICK)
-        .render(area, buf);
-}

examples/demo2/term.rs

@@ -1,71 +0,0 @@
-use std::{
-    io::{self, stdout, Stdout},
-    ops::{Deref, DerefMut},
-    time::Duration,
-};
-
-use anyhow::{Context, Result};
-use crossterm::{
-    event::{self, Event},
-    terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
-    ExecutableCommand,
-};
-use ratatui::prelude::*;
-
-/// A wrapper around the terminal that handles setting up and tearing down the terminal
-/// and provides a helper method to read events from the terminal.
-#[derive(Debug)]
-pub struct Term {
-    terminal: Terminal<CrosstermBackend<Stdout>>,
-}
-
-impl Term {
-    pub fn start() -> Result<Self> {
-        // this size is to match the size of the terminal when running the demo
-        // using vhs in a 1280x640 sized window (github social preview size)
-        let options = TerminalOptions {
-            viewport: Viewport::Fixed(Rect::new(0, 0, 81, 18)),
-        };
-        let terminal = Terminal::with_options(CrosstermBackend::new(io::stdout()), options)?;
-        enable_raw_mode().context("enable raw mode")?;
-        stdout()
-            .execute(EnterAlternateScreen)
-            .context("enter alternate screen")?;
-        Ok(Self { terminal })
-    }
-
-    pub fn stop() -> Result<()> {
-        disable_raw_mode().context("disable raw mode")?;
-        stdout()
-            .execute(LeaveAlternateScreen)
-            .context("leave alternate screen")?;
-        Ok(())
-    }
-
-    pub fn next_event(timeout: Duration) -> io::Result<Option<Event>> {
-        if !event::poll(timeout)? {
-            return Ok(None);
-        }
-        let event = event::read()?;
-        Ok(Some(event))
-    }
-}
-
-impl Deref for Term {
-    type Target = Terminal<CrosstermBackend<Stdout>>;
-    fn deref(&self) -> &Self::Target {
-        &self.terminal
-    }
-}
-
-impl DerefMut for Term {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.terminal
-    }
-}
-
-impl Drop for Term {
-    fn drop(&mut self) {
-        let _ = Term::stop();
-    }
-}

examples/demo2/theme.rs

@@ -1,136 +0,0 @@
-use ratatui::prelude::*;
-
-pub struct Theme {
-    pub root: Style,
-    pub content: Style,
-    pub app_title: Style,
-    pub tabs: Style,
-    pub tabs_selected: Style,
-    pub borders: Style,
-    pub description: Style,
-    pub description_title: Style,
-    pub key_binding: KeyBinding,
-    pub logo: Logo,
-    pub email: Email,
-    pub traceroute: Traceroute,
-    pub recipe: Recipe,
-}
-
-pub struct KeyBinding {
-    pub key: Style,
-    pub description: Style,
-}
-
-pub struct Logo {
-    pub rat: Color,
-    pub rat_eye: Color,
-    pub rat_eye_alt: Color,
-    pub term: Color,
-}
-
-pub struct Email {
-    pub tabs: Style,
-    pub tabs_selected: Style,
-    pub inbox: Style,
-    pub item: Style,
-    pub selected_item: Style,
-    pub header: Style,
-    pub header_value: Style,
-    pub body: Style,
-}
-
-pub struct Traceroute {
-    pub header: Style,
-    pub selected: Style,
-    pub ping: Style,
-    pub map: Map,
-}
-
-pub struct Map {
-    pub style: Style,
-    pub color: Color,
-    pub path: Color,
-    pub source: Color,
-    pub destination: Color,
-    pub background_color: Color,
-}
-
-pub struct Recipe {
-    pub ingredients: Style,
-    pub ingredients_header: Style,
-}
-
-pub const THEME: Theme = Theme {
-    root: Style::new().bg(DARK_BLUE),
-    content: Style::new().bg(DARK_BLUE).fg(LIGHT_GRAY),
-    app_title: Style::new()
-        .fg(WHITE)
-        .bg(DARK_BLUE)
-        .add_modifier(Modifier::BOLD),
-    tabs: Style::new().fg(MID_GRAY).bg(DARK_BLUE),
-    tabs_selected: Style::new()
-        .fg(WHITE)
-        .bg(DARK_BLUE)
-        .add_modifier(Modifier::BOLD)
-        .add_modifier(Modifier::REVERSED),
-    borders: Style::new().fg(LIGHT_GRAY),
-    description: Style::new().fg(LIGHT_GRAY).bg(DARK_BLUE),
-    description_title: Style::new().fg(LIGHT_GRAY).add_modifier(Modifier::BOLD),
-    logo: Logo {
-        rat: WHITE,
-        rat_eye: BLACK,
-        rat_eye_alt: RED,
-        term: BLACK,
-    },
-    key_binding: KeyBinding {
-        key: Style::new().fg(BLACK).bg(DARK_GRAY),
-        description: Style::new().fg(DARK_GRAY).bg(BLACK),
-    },
-    email: Email {
-        tabs: Style::new().fg(MID_GRAY).bg(DARK_BLUE),
-        tabs_selected: Style::new()
-            .fg(WHITE)
-            .bg(DARK_BLUE)
-            .add_modifier(Modifier::BOLD),
-        inbox: Style::new().bg(DARK_BLUE).fg(LIGHT_GRAY),
-        item: Style::new().fg(LIGHT_GRAY),
-        selected_item: Style::new().fg(LIGHT_YELLOW),
-        header: Style::new().add_modifier(Modifier::BOLD),
-        header_value: Style::new().fg(LIGHT_GRAY),
-        body: Style::new().bg(DARK_BLUE).fg(LIGHT_GRAY),
-    },
-    traceroute: Traceroute {
-        header: Style::new()
-            .bg(DARK_BLUE)
-            .add_modifier(Modifier::BOLD)
-            .add_modifier(Modifier::UNDERLINED),
-        selected: Style::new().fg(LIGHT_YELLOW),
-        ping: Style::new().fg(WHITE),
-        map: Map {
-            style: Style::new().bg(DARK_BLUE),
-            background_color: DARK_BLUE,
-            color: LIGHT_GRAY,
-            path: LIGHT_BLUE,
-            source: LIGHT_GREEN,
-            destination: LIGHT_RED,
-        },
-    },
-    recipe: Recipe {
-        ingredients: Style::new().bg(DARK_BLUE).fg(LIGHT_GRAY),
-        ingredients_header: Style::new()
-            .add_modifier(Modifier::BOLD)
-            .add_modifier(Modifier::UNDERLINED),
-    },
-};
-
-const DARK_BLUE: Color = Color::Rgb(16, 24, 48);
-const LIGHT_BLUE: Color = Color::Rgb(64, 96, 192);
-const LIGHT_YELLOW: Color = Color::Rgb(192, 192, 96);
-const LIGHT_GREEN: Color = Color::Rgb(64, 192, 96);
-const LIGHT_RED: Color = Color::Rgb(192, 96, 96);
-const RED: Color = Color::Indexed(160);
-const BLACK: Color = Color::Indexed(232); // not really black, often #080808
-const DARK_GRAY: Color = Color::Indexed(238);
-const MID_GRAY: Color = Color::Indexed(244);
-const LIGHT_GRAY: Color = Color::Indexed(250);
-const WHITE: Color = Color::Indexed(255); // not really white, often #eeeeee

examples/docsrs.rs

@@ -1,126 +0,0 @@
-use std::io::{self, stdout};
-
-use crossterm::{
-    terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
-    ExecutableCommand,
-};
-use ratatui::{prelude::*, widgets::*};
-
-/// Example code for libr.rs
-///
-/// When cargo-rdme supports doc comments that import from code, this will be imported
-/// rather than copied to the lib.rs file.
-fn main() -> io::Result<()> {
-    let arg = std::env::args().nth(1).unwrap_or_default();
-    enable_raw_mode()?;
-    stdout().execute(EnterAlternateScreen)?;
-    let mut terminal = Terminal::new(CrosstermBackend::new(stdout()))?;
-
-    let mut should_quit = false;
-    while !should_quit {
-        terminal.draw(match arg.as_str() {
-            "hello_world" => hello_world,
-            "layout" => layout,
-            "styling" => styling,
-            _ => hello_world,
-        })?;
-        should_quit = handle_events()?;
-    }
-
-    disable_raw_mode()?;
-    stdout().execute(LeaveAlternateScreen)?;
-    Ok(())
-}
-
-fn hello_world(frame: &mut Frame) {
-    frame.render_widget(
-        Paragraph::new("Hello World!")
-            .block(Block::default().title("Greeting").borders(Borders::ALL)),
-        frame.size(),
-    );
-}
-
-use crossterm::event::{self, Event, KeyCode};
-fn handle_events() -> io::Result<bool> {
-    if event::poll(std::time::Duration::from_millis(50))? {
-        if let Event::Key(key) = event::read()? {
-            if key.kind == event::KeyEventKind::Press && key.code == KeyCode::Char('q') {
-                return Ok(true);
-            }
-        }
-    }
-    Ok(false)
-}
-
-fn layout(frame: &mut Frame) {
-    let main_layout = Layout::default()
-        .direction(Direction::Vertical)
-        .constraints([
-            Constraint::Length(1),
-            Constraint::Min(0),
-            Constraint::Length(1),
-        ])
-        .split(frame.size());
-    frame.render_widget(
-        Block::new().borders(Borders::TOP).title("Title Bar"),
-        main_layout[0],
-    );
-    frame.render_widget(
-        Block::new().borders(Borders::TOP).title("Status Bar"),
-        main_layout[2],
-    );
-
-    let inner_layout = Layout::default()
-        .direction(Direction::Horizontal)
-        .constraints([Constraint::Percentage(50), Constraint::Percentage(50)])
-        .split(main_layout[1]);
-    frame.render_widget(
-        Block::default().borders(Borders::ALL).title("Left"),
-        inner_layout[0],
-    );
-    frame.render_widget(
-        Block::default().borders(Borders::ALL).title("Right"),
-        inner_layout[1],
-    );
-}
-
-fn styling(frame: &mut Frame) {
-    let areas = Layout::default()
-        .direction(Direction::Vertical)
-        .constraints([
-            Constraint::Length(1),
-            Constraint::Length(1),
-            Constraint::Length(1),
-            Constraint::Length(1),
-            Constraint::Min(0),
-        ])
-        .split(frame.size());
-
-    let span1 = Span::raw("Hello ");
-    let span2 = Span::styled(
-        "World",
-        Style::new()
-            .fg(Color::Green)
-            .bg(Color::White)
-            .add_modifier(Modifier::BOLD),
-    );
-    let span3 = "!".red().on_light_yellow().italic();
-
-    let line = Line::from(vec![span1, span2, span3]);
-    let text: Text = Text::from(vec![line]);
-
-    frame.render_widget(Paragraph::new(text), areas[0]);
-    // or using the short-hand syntax and implicit conversions
-    frame.render_widget(
-        Paragraph::new("Hello World!".red().on_white().bold()),
-        areas[1],
-    );
-
-    // to style the whole widget instead of just the text
-    frame.render_widget(
-        Paragraph::new("Hello World!").style(Style::new().red().on_white()),
-        areas[2],
-    );
-    // or using the short-hand syntax
-    frame.render_widget(Paragraph::new("Hello World!").blue().on_yellow(), areas[3]);
-}

examples/docsrs.tape

@@ -1,39 +0,0 @@
-# This is a vhs script. See https://github.com/charmbracelet/vhs for more info.
-# To run this script, install vhs and run `vhs ./examples/demo.tape`
-# NOTE: Requires VHS 0.6.1 or later for Screenshot support
-Output "target/docsrs.gif"
-Set Theme "Aardvark Blue"
-# The reason for this strange size is that the social preview image for this
-# demo is 1280x64 with 80 pixels of padding on each side. We want a version
-# without the padding for README.md, etc.
-Set Width 640
-Set Height 160
-Set Padding 0
-Hide
-Type "cargo run --example docsrs --features crossterm"
-Enter
-Sleep 2s
-Show
-Sleep 1s
-Screenshot "target/docsrs-hello.png"
-Sleep 1s
-Hide
-Type "q"
-Type "cargo run --example docsrs --features crossterm -- layout"
-Enter
-Sleep 2s
-Show
-Sleep 1s
-Screenshot "target/docsrs-layout.png"
-Sleep 1s
-Hide
-Type "q"
-Type "cargo run --example docsrs --features crossterm -- styling"
-Enter
-Sleep 2s
-Show
-Sleep 1s
-Screenshot "target/docsrs-styling.png"
-Sleep 1s
-Hide
-Type "q"

examples/gauge.rs

@@ -1,32 +1,17 @@
 use std::{
-    io::{self, stdout, Stdout},
-    rc::Rc,
-    time::Duration,
+    error::Error,
+    io,
+    time::{Duration, Instant},
 };
 
-use anyhow::Result;
 use crossterm::{
-    event::{self, Event, KeyCode, KeyEventKind},
+    event::{self, DisableMouseCapture, EnableMouseCapture, Event, KeyCode},
+    execute,
     terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
-    ExecutableCommand,
 };
-use ratatui::{
-    prelude::*,
-    widgets::{block::Title, *},
-};
-
-fn main() -> Result<()> {
-    App::run()
-}
+use ratatui::{prelude::*, widgets::*};
 
 struct App {
-    term: Term,
-    should_quit: bool,
-    state: AppState,
-}
-
-#[derive(Debug, Default, Clone, Copy)]
-struct AppState {
     progress1: u16,
     progress2: u16,
     progress3: f64,
@@ -34,154 +19,141 @@ struct AppState {
 }
 
 impl App {
-    fn run() -> Result<()> {
-        // run at ~10 fps minus the time it takes to draw
-        let timeout = Duration::from_secs_f32(1.0 / 10.0);
-        let mut app = Self::start()?;
-        while !app.should_quit {
-            app.update();
-            app.draw()?;
-            app.handle_events(timeout)?;
+    fn new() -> App {
+        App {
+            progress1: 0,
+            progress2: 0,
+            progress3: 0.45,
+            progress4: 0,
         }
-        app.stop()?;
-        Ok(())
     }
 
-    fn start() -> Result<Self> {
-        Ok(App {
-            term: Term::start()?,
-            should_quit: false,
-            state: AppState {
-                progress1: 0,
-                progress2: 0,
-                progress3: 0.0,
-                progress4: 0,
-            },
-        })
+    fn on_tick(&mut self) {
+        self.progress1 += 1;
+        if self.progress1 > 100 {
+            self.progress1 = 0;
+        }
+        self.progress2 += 2;
+        if self.progress2 > 100 {
+            self.progress2 = 0;
+        }
+        self.progress3 += 0.001;
+        if self.progress3 > 1.0 {
+            self.progress3 = 0.0;
+        }
+        self.progress4 += 1;
+        if self.progress4 > 100 {
+            self.progress4 = 0;
+        }
+    }
+}
+
+fn main() -> Result<(), Box<dyn Error>> {
+    // setup terminal
+    enable_raw_mode()?;
+    let mut stdout = io::stdout();
+    execute!(stdout, EnterAlternateScreen, EnableMouseCapture)?;
+    let backend = CrosstermBackend::new(stdout);
+    let mut terminal = Terminal::new(backend)?;
+
+    // create app and run it
+    let tick_rate = Duration::from_millis(250);
+    let app = App::new();
+    let res = run_app(&mut terminal, app, tick_rate);
+
+    // restore terminal
+    disable_raw_mode()?;
+    execute!(
+        terminal.backend_mut(),
+        LeaveAlternateScreen,
+        DisableMouseCapture
+    )?;
+    terminal.show_cursor()?;
+
+    if let Err(err) = res {
+        println!("{err:?}");
     }
 
-    fn stop(&mut self) -> Result<()> {
-        Term::stop()?;
-        Ok(())
-    }
+    Ok(())
+}
 
-    fn update(&mut self) {
-        self.state.progress1 = (self.state.progress1 + 4).min(100);
-        self.state.progress2 = (self.state.progress2 + 3).min(100);
-        self.state.progress3 = (self.state.progress3 + 0.02).min(1.0);
-        self.state.progress4 = (self.state.progress4 + 1).min(100);
-    }
+fn run_app<B: Backend>(
+    terminal: &mut Terminal<B>,
+    mut app: App,
+    tick_rate: Duration,
+) -> io::Result<()> {
+    let mut last_tick = Instant::now();
+    loop {
+        terminal.draw(|f| ui(f, &app))?;
 
-    fn draw(&mut self) -> Result<()> {
-        self.term.draw(|frame| {
-            let state = self.state;
-            let layout = Self::equal_layout(frame);
-            Self::render_gauge1(state.progress1, frame, layout[0]);
-            Self::render_gauge2(state.progress2, frame, layout[1]);
-            Self::render_gauge3(state.progress3, frame, layout[2]);
-            Self::render_gauge4(state.progress4, frame, layout[3]);
-        })?;
-        Ok(())
-    }
-
-    fn handle_events(&mut self, timeout: Duration) -> io::Result<()> {
-        if event::poll(timeout)? {
+        let timeout = tick_rate
+            .checked_sub(last_tick.elapsed())
+            .unwrap_or_else(|| Duration::from_secs(0));
+        if crossterm::event::poll(timeout)? {
             if let Event::Key(key) = event::read()? {
-                if key.kind == KeyEventKind::Press {
-                    if let KeyCode::Char('q') = key.code {
-                        self.should_quit = true;
-                    }
+                if let KeyCode::Char('q') = key.code {
+                    return Ok(());
                 }
             }
         }
-        Ok(())
-    }
-
-    fn equal_layout(frame: &Frame) -> Rc<[Rect]> {
-        Layout::default()
-            .direction(Direction::Vertical)
-            .constraints([
-                Constraint::Percentage(25),
-                Constraint::Percentage(25),
-                Constraint::Percentage(25),
-                Constraint::Percentage(25),
-            ])
-            .split(frame.size())
-    }
-
-    fn render_gauge1(progress: u16, frame: &mut Frame, area: Rect) {
-        let title = Self::title_block("Gauge with percentage progress");
-        let gauge = Gauge::default()
-            .block(title)
-            .gauge_style(Style::new().light_red())
-            .percent(progress);
-        frame.render_widget(gauge, area);
-    }
-
-    fn render_gauge2(progress: u16, frame: &mut Frame, area: Rect) {
-        let title = Self::title_block("Gauge with percentage progress and custom label");
-        let label = format!("{}/100", progress);
-        let gauge = Gauge::default()
-            .block(title)
-            .gauge_style(Style::new().blue().on_light_blue())
-            .percent(progress)
-            .label(label);
-        frame.render_widget(gauge, area);
-    }
-
-    fn render_gauge3(progress: f64, frame: &mut Frame, area: Rect) {
-        let title =
-            Self::title_block("Gauge with ratio progress, custom label with style, and unicode");
-        let label = Span::styled(
-            format!("{:.2}%", progress * 100.0),
-            Style::new().red().italic().bold(),
-        );
-        let gauge = Gauge::default()
-            .block(title)
-            .gauge_style(Style::default().fg(Color::Yellow))
-            .ratio(progress)
-            .label(label)
-            .use_unicode(true);
-        frame.render_widget(gauge, area);
-    }
-
-    fn render_gauge4(progress: u16, frame: &mut Frame, area: Rect) {
-        let title = Self::title_block("Gauge with percentage progress and label");
-        let label = format!("{}/100", progress);
-        let gauge = Gauge::default()
-            .block(title)
-            .gauge_style(Style::new().green().italic())
-            .percent(progress)
-            .label(label);
-        frame.render_widget(gauge, area);
-    }
-
-    fn title_block(title: &str) -> Block {
-        let title = Title::from(title).alignment(Alignment::Center);
-        Block::default().title(title).borders(Borders::TOP)
+        if last_tick.elapsed() >= tick_rate {
+            app.on_tick();
+            last_tick = Instant::now();
+        }
     }
 }
 
-struct Term {
-    terminal: Terminal<CrosstermBackend<Stdout>>,
-}
-
-impl Term {
-    pub fn start() -> io::Result<Term> {
-        stdout().execute(EnterAlternateScreen)?;
-        enable_raw_mode()?;
-        let terminal = Terminal::new(CrosstermBackend::new(stdout()))?;
-        Ok(Self { terminal })
-    }
-
-    pub fn stop() -> io::Result<()> {
-        disable_raw_mode()?;
-        stdout().execute(LeaveAlternateScreen)?;
-        Ok(())
-    }
-
-    fn draw(&mut self, frame: impl FnOnce(&mut Frame)) -> Result<()> {
-        self.terminal.draw(frame)?;
-        Ok(())
-    }
+fn ui<B: Backend>(f: &mut Frame<B>, app: &App) {
+    let chunks = Layout::default()
+        .direction(Direction::Vertical)
+        .constraints(
+            [
+                Constraint::Percentage(25),
+                Constraint::Percentage(25),
+                Constraint::Percentage(25),
+                Constraint::Percentage(25),
+            ]
+            .as_ref(),
+        )
+        .split(f.size());
+
+    let gauge = Gauge::default()
+        .block(Block::default().title("Gauge1").borders(Borders::ALL))
+        .gauge_style(Style::default().fg(Color::Yellow))
+        .percent(app.progress1);
+    f.render_widget(gauge, chunks[0]);
+
+    let label = format!("{}/100", app.progress2);
+    let gauge = Gauge::default()
+        .block(Block::default().title("Gauge2").borders(Borders::ALL))
+        .gauge_style(Style::default().fg(Color::Magenta).bg(Color::Green))
+        .percent(app.progress2)
+        .label(label);
+    f.render_widget(gauge, chunks[1]);
+
+    let label = Span::styled(
+        format!("{:.2}%", app.progress3 * 100.0),
+        Style::default()
+            .fg(Color::Red)
+            .add_modifier(Modifier::ITALIC | Modifier::BOLD),
+    );
+    let gauge = Gauge::default()
+        .block(Block::default().title("Gauge3").borders(Borders::ALL))
+        .gauge_style(Style::default().fg(Color::Yellow))
+        .ratio(app.progress3)
+        .label(label)
+        .use_unicode(true);
+    f.render_widget(gauge, chunks[2]);
+
+    let label = format!("{}/100", app.progress4);
+    let gauge = Gauge::default()
+        .block(Block::default().title("Gauge4").borders(Borders::ALL))
+        .gauge_style(
+            Style::default()
+                .fg(Color::Cyan)
+                .add_modifier(Modifier::ITALIC),
+        )
+        .percent(app.progress4)
+        .label(label);
+    f.render_widget(gauge, chunks[3]);
 }

examples/gauge.tape

@@ -1,9 +1,8 @@
 # This is a vhs script. See https://github.com/charmbracelet/vhs for more info.
 # To run this script, install vhs and run `vhs ./examples/gauge.tape`
 Output "target/gauge.gif"
-Set Theme "Aardvark Blue"
 Set Width 1200
-Set Height 550
+Set Height 600
 Hide
 Type "cargo run --example=gauge --features=crossterm"
 Enter

examples/generate.bash

@@ -1,41 +0,0 @@
-#!/bin/bash
-
-# This script is used to generate the images for the examples README
-# It requires the following tools:
-# - cargo: https://doc.rust-lang.org/cargo/getting-started/installation.html
-# - gh: https://github.com/cli/cli
-# - git: https://git-scm.com/
-# - vhs: https://github.com/charmbracelet/vhs - currently this needs to be installed from the
-#   main branch, as the latest release doesn't support the theme we use or the Screenshot
-#   command. Install using `go install github.com/charmbracelet/vhs@main``
-# - go: https://golang.org/doc/install
-# - ttyd: https://github.com/tsl0922/ttyd
-
-# Exit on error. Append "|| true" if you expect an error.
-set -o errexit
-# Exit on error inside any functions or subshells.
-set -o errtrace
-# Do not allow use of undefined vars. Use ${VAR:-} to use an undefined VAR
-set -o nounset
-# Catch the error in case mysqldump fails (but gzip succeeds) in `mysqldump |gzip`
-set -o pipefail
-# Turn on traces, useful while debugging but commented out by default
-# set -o xtrace
-
-# ensure that running each example doesn't have to wait for the build
-cargo build --examples --features=crossterm,all-widgets
-
-for tape in examples/*.tape; do
-    gif=${tape/examples\//}
-    gif=${gif/.tape/.gif}
-    ~/go/bin/vhs $tape --quiet
-    # this can be pasted into the examples README.md
-    echo "[${gif}]: https://github.com/ratatui-org/ratatui/blob/images/examples/${gif}?raw=true"
-done
-git switch images
-git pull --rebase upstream images
-cp target/*.gif examples/
-git add examples/*.gif
-git commit -m 'docs(examples): update images'
-gh pr create
-git sw -

examples/hello_world.rs

@@ -61,7 +61,7 @@ fn run(terminal: &mut Terminal<CrosstermBackend<Stdout>>) -> Result<()> {
 
 /// Render the application. This is where you would draw the application UI. This example just
 /// draws a greeting.
-fn render_app(frame: &mut Frame) {
+fn render_app(frame: &mut ratatui::Frame<CrosstermBackend<Stdout>>) {
     let greeting = Paragraph::new("Hello World! (press 'q' to quit)");
     frame.render_widget(greeting, frame.size());
 }

examples/hello_world.tape

@@ -1,7 +1,6 @@
 # This is a vhs script. See https://github.com/charmbracelet/vhs for more info.
 # To run this script, install vhs and run `vhs ./examples/hello_world.tape`
 Output "target/hello_world.gif"
-Set Theme "Aardvark Blue"
 Set Width 1200
 Set Height 200
 Hide

examples/inline.rs

@@ -98,7 +98,9 @@ fn input_handling(tx: mpsc::Sender<Event>) {
         let mut last_tick = Instant::now();
         loop {
             // poll for tick rate duration, if no events, sent tick event.
-            let timeout = tick_rate.saturating_sub(last_tick.elapsed());
+            let timeout = tick_rate
+                .checked_sub(last_tick.elapsed())
+                .unwrap_or_else(|| Duration::from_secs(0));
             if crossterm::event::poll(timeout).unwrap() {
                 match crossterm::event::read().unwrap() {
                     crossterm::event::Event::Key(key) => tx.send(Event::Input(key)).unwrap(),
@@ -214,14 +216,14 @@ fn run_app<B: Backend>(
     Ok(())
 }
 
-fn ui(f: &mut Frame, downloads: &Downloads) {
+fn ui<B: Backend>(f: &mut Frame<B>, downloads: &Downloads) {
     let size = f.size();
 
     let block = Block::default().title(block::Title::from("Progress").alignment(Alignment::Center));
     f.render_widget(block, size);
 
     let chunks = Layout::default()
-        .constraints([Constraint::Length(2), Constraint::Length(4)])
+        .constraints(vec![Constraint::Length(2), Constraint::Length(4)])
         .margin(1)
         .split(size);
 
@@ -235,7 +237,7 @@ fn ui(f: &mut Frame, downloads: &Downloads) {
 
     let chunks = Layout::default()
         .direction(Direction::Horizontal)
-        .constraints([Constraint::Percentage(20), Constraint::Percentage(80)])
+        .constraints(vec![Constraint::Percentage(20), Constraint::Percentage(80)])
         .split(chunks[1]);
 
     // in progress downloads

examples/inline.tape

@@ -1,7 +1,6 @@
 # This is a vhs script. See https://github.com/charmbracelet/vhs for more info.
 # To run this script, install vhs and run `vhs ./examples/inline.tape`
 Output "target/inline.gif"
-Set Theme "Aardvark Blue"
 Set Width 1200
 Set Height 600
 Type "cargo run --example=inline --features=crossterm"

examples/layout.rs

@@ -5,8 +5,7 @@ use crossterm::{
     execute,
     terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
 };
-use itertools::Itertools;
-use ratatui::{layout::Constraint::*, prelude::*, widgets::*};
+use ratatui::{prelude::*, widgets::*};
 
 fn main() -> Result<(), Box<dyn Error>> {
     // setup terminal
@@ -37,7 +36,7 @@ fn main() -> Result<(), Box<dyn Error>> {
 
 fn run_app<B: Backend>(terminal: &mut Terminal<B>) -> io::Result<()> {
     loop {
-        terminal.draw(ui)?;
+        terminal.draw(|f| ui(f))?;
 
         if let Event::Key(key) = event::read()? {
             if let KeyCode::Char('q') = key.code {
@@ -47,173 +46,51 @@ fn run_app<B: Backend>(terminal: &mut Terminal<B>) -> io::Result<()> {
     }
 }
 
-fn ui(frame: &mut Frame) {
-    let main_layout = Layout::default()
+fn ui<B: Backend>(frame: &mut Frame<B>) {
+    let [top, mid, bottom] = *Layout::default()
         .direction(Direction::Vertical)
-        .constraints([
-            Length(4),  // text
-            Length(50), // examples
-            Min(0),     // fills remaining space
-        ])
-        .split(frame.size());
-
-    // title
+        .constraints(
+            [
+                Constraint::Length(4),
+                Constraint::Percentage(50),
+                Constraint::Min(4),
+            ]
+            .as_ref(),
+        )
+        .split(frame.size())
+    else {
+        return;
+    };
+    let [left, right] = *Layout::default()
+        .direction(Direction::Horizontal)
+        .horizontal_margin(5)
+        .vertical_margin(2)
+        .constraints([Constraint::Ratio(2, 5), Constraint::Ratio(3, 5)].as_ref())
+        .split(mid)
+    else {
+        return;
+    };
     frame.render_widget(
-        Paragraph::new(vec![
-            Line::from("Horizontal Layout Example. Press q to quit".dark_gray())
-                .alignment(Alignment::Center),
-            Line::from("Each line has 2 constraints, plus Min(0) to fill the remaining space."),
-            Line::from("E.g. the second line of the Len/Min box is [Length(2), Min(2), Min(0)]"),
-            Line::from("Note: constraint labels that don't fit are truncated"),
-        ]),
-        main_layout[0],
+        Paragraph::new("Constraint::Length(4)").block(Block::default().borders(Borders::ALL)),
+        top,
     );
 
-    let example_rows = Layout::default()
-        .direction(Direction::Vertical)
-        .constraints([
-            Length(9),
-            Length(9),
-            Length(9),
-            Length(9),
-            Length(9),
-            Min(0), // fills remaining space
-        ])
-        .split(main_layout[1]);
-    let example_areas = example_rows
-        .iter()
-        .flat_map(|area| {
-            Layout::default()
-                .direction(Direction::Horizontal)
-                .constraints([
-                    Length(14),
-                    Length(14),
-                    Length(14),
-                    Length(14),
-                    Length(14),
-                    Min(0), // fills remaining space
-                ])
-                .split(*area)
-                .iter()
-                .copied()
-                .take(5) // ignore Min(0)
-                .collect_vec()
-        })
-        .collect_vec();
+    frame.render_widget(
+        Paragraph::new("Constraint::Percentage(50)").block(Block::default().borders(Borders::ALL)),
+        mid,
+    );
 
-    // the examples are a cartesian product of the following constraints
-    // e.g. Len/Len, Len/Min, Len/Max, Len/Perc, Len/Ratio, Min/Len, Min/Min, ...
-    let examples = [
-        (
-            "Len",
-            vec![
-                Length(0),
-                Length(2),
-                Length(3),
-                Length(6),
-                Length(10),
-                Length(15),
-            ],
-        ),
-        (
-            "Min",
-            vec![Min(0), Min(2), Min(3), Min(6), Min(10), Min(15)],
-        ),
-        (
-            "Max",
-            vec![Max(0), Max(2), Max(3), Max(6), Max(10), Max(15)],
-        ),
-        (
-            "Perc",
-            vec![
-                Percentage(0),
-                Percentage(25),
-                Percentage(50),
-                Percentage(75),
-                Percentage(100),
-                Percentage(150),
-            ],
-        ),
-        (
-            "Ratio",
-            vec![
-                Ratio(0, 4),
-                Ratio(1, 4),
-                Ratio(2, 4),
-                Ratio(3, 4),
-                Ratio(4, 4),
-                Ratio(6, 4),
-            ],
-        ),
-    ];
-
-    for (i, (a, b)) in examples
-        .iter()
-        .cartesian_product(examples.iter())
-        .enumerate()
-    {
-        let (name_a, examples_a) = a;
-        let (name_b, examples_b) = b;
-        let constraints = examples_a
-            .iter()
-            .copied()
-            .zip(examples_b.iter().copied())
-            .collect_vec();
-        render_example_combination(
-            frame,
-            example_areas[i],
-            &format!("{name_a}/{name_b}"),
-            constraints,
-        );
-    }
-}
-
-/// Renders a single example box
-fn render_example_combination(
-    frame: &mut Frame,
-    area: Rect,
-    title: &str,
-    constraints: Vec<(Constraint, Constraint)>,
-) {
-    let block = Block::default()
-        .title(title.gray())
-        .style(Style::reset())
-        .borders(Borders::ALL)
-        .border_style(Style::default().fg(Color::DarkGray));
-    let inner = block.inner(area);
-    frame.render_widget(block, area);
-    let layout = Layout::default()
-        .direction(Direction::Vertical)
-        .constraints(vec![Length(1); constraints.len() + 1])
-        .split(inner);
-    for (i, (a, b)) in constraints.iter().enumerate() {
-        render_single_example(frame, layout[i], vec![*a, *b, Min(0)]);
-    }
-    // This is to make it easy to visually see the alignment of the examples
-    // with the constraints.
-    frame.render_widget(Paragraph::new("123456789012"), layout[6]);
-}
-
-/// Renders a single example line
-fn render_single_example(frame: &mut Frame, area: Rect, constraints: Vec<Constraint>) {
-    let red = Paragraph::new(constraint_label(constraints[0])).on_red();
-    let blue = Paragraph::new(constraint_label(constraints[1])).on_blue();
-    let green = Paragraph::new("·".repeat(12)).on_green();
-    let layout = Layout::default()
-        .direction(Direction::Horizontal)
-        .constraints(constraints)
-        .split(area);
-    frame.render_widget(red, layout[0]);
-    frame.render_widget(blue, layout[1]);
-    frame.render_widget(green, layout[2]);
-}
-
-fn constraint_label(constraint: Constraint) -> String {
-    match constraint {
-        Length(n) => format!("{n}"),
-        Min(n) => format!("{n}"),
-        Max(n) => format!("{n}"),
-        Percentage(n) => format!("{n}"),
-        Ratio(a, b) => format!("{a}:{b}"),
-    }
+    frame.render_widget(
+        Paragraph::new("Constraint::Ratio(2, 5)\nhorizontal_margin(5)\nvertical_margin(2)")
+            .block(Block::default().borders(Borders::ALL)),
+        left,
+    );
+    frame.render_widget(
+        Paragraph::new("Constraint::Ratio(3, 5)").block(Block::default().borders(Borders::ALL)),
+        right,
+    );
+    frame.render_widget(
+        Paragraph::new("Constraint::Min(4)").block(Block::default().borders(Borders::ALL)),
+        bottom,
+    );
 }

examples/layout.tape

@@ -1,12 +1,11 @@
 # This is a vhs script. See https://github.com/charmbracelet/vhs for more info.
 # To run this script, install vhs and run `vhs ./examples/layout.tape`
 Output "target/layout.gif"
-Set Theme "Aardvark Blue"
 Set Width 1200
-Set Height 1410
+Set Height 600
 Hide
 Type "cargo run --example=layout --features=crossterm"
 Enter
 Sleep 1s
 Show
-Sleep 2s
+Sleep 5s

examples/list.rs

@@ -175,7 +175,9 @@ fn run_app<B: Backend>(
     loop {
         terminal.draw(|f| ui(f, &mut app))?;
 
-        let timeout = tick_rate.saturating_sub(last_tick.elapsed());
+        let timeout = tick_rate
+            .checked_sub(last_tick.elapsed())
+            .unwrap_or_else(|| Duration::from_secs(0));
         if crossterm::event::poll(timeout)? {
             if let Event::Key(key) = event::read()? {
                 if key.kind == KeyEventKind::Press {
@@ -196,11 +198,11 @@ fn run_app<B: Backend>(
     }
 }
 
-fn ui(f: &mut Frame, app: &mut App) {
+fn ui<B: Backend>(f: &mut Frame<B>, app: &mut App) {
     // Create two chunks with equal horizontal screen space
     let chunks = Layout::default()
         .direction(Direction::Horizontal)
-        .constraints([Constraint::Percentage(50), Constraint::Percentage(50)])
+        .constraints([Constraint::Percentage(50), Constraint::Percentage(50)].as_ref())
         .split(f.size());
 
     // Iterate through all elements in the `items` app and append some debug text to it.

examples/list.tape

@@ -1,7 +1,6 @@
 # This is a vhs script. See https://github.com/charmbracelet/vhs for more info.
 # To run this script, install vhs and run `vhs ./examples/list.tape`
 Output "target/list.gif"
-Set Theme "Aardvark Blue"
 Set Width 1200
 Set Height 600
 Hide

examples/modifiers.rs

@@ -1,116 +0,0 @@
-/// This example is useful for testing how your terminal emulator handles different modifiers.
-/// It will render a grid of combinations of foreground and background colors with all
-/// modifiers applied to them.
-use std::{
-    error::Error,
-    io::{self, Stdout},
-    iter::once,
-    result,
-    time::Duration,
-};
-
-use crossterm::{
-    event::{self, Event, KeyCode},
-    execute,
-    terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
-};
-use itertools::Itertools;
-use ratatui::{prelude::*, widgets::*};
-
-type Result<T> = result::Result<T, Box<dyn Error>>;
-
-fn main() -> Result<()> {
-    let mut terminal = setup_terminal()?;
-    let res = run_app(&mut terminal);
-    restore_terminal(terminal)?;
-    if let Err(err) = res {
-        eprintln!("{err:?}");
-    }
-    Ok(())
-}
-
-fn run_app<B: Backend>(terminal: &mut Terminal<B>) -> io::Result<()> {
-    loop {
-        terminal.draw(ui)?;
-
-        if event::poll(Duration::from_millis(250))? {
-            if let Event::Key(key) = event::read()? {
-                if let KeyCode::Char('q') = key.code {
-                    return Ok(());
-                }
-            }
-        }
-    }
-}
-
-fn ui(frame: &mut Frame) {
-    let layout = Layout::default()
-        .direction(Direction::Vertical)
-        .constraints([Constraint::Length(1), Constraint::Min(0)])
-        .split(frame.size());
-    frame.render_widget(
-        Paragraph::new("Note: not all terminals support all modifiers")
-            .style(Style::default().fg(Color::Red).add_modifier(Modifier::BOLD)),
-        layout[0],
-    );
-    let layout = Layout::default()
-        .direction(Direction::Vertical)
-        .constraints([Constraint::Length(1); 50])
-        .split(layout[1])
-        .iter()
-        .flat_map(|area| {
-            Layout::default()
-                .direction(Direction::Horizontal)
-                .constraints([Constraint::Percentage(20); 5])
-                .split(*area)
-                .to_vec()
-        })
-        .collect_vec();
-
-    let colors = [
-        Color::Black,
-        Color::DarkGray,
-        Color::Gray,
-        Color::White,
-        Color::Red,
-    ];
-    let all_modifiers = once(Modifier::empty())
-        .chain(Modifier::all().iter())
-        .collect_vec();
-    let mut index = 0;
-    for bg in colors.iter() {
-        for fg in colors.iter() {
-            for modifier in &all_modifiers {
-                let modifier_name = format!("{modifier:11?}");
-                let padding = (" ").repeat(12 - modifier_name.len());
-                let paragraph = Paragraph::new(Line::from(vec![
-                    modifier_name.fg(*fg).bg(*bg).add_modifier(*modifier),
-                    padding.fg(*fg).bg(*bg).add_modifier(*modifier),
-                    // This is a hack to work around a bug in VHS which is used for rendering the
-                    // examples to gifs. The bug is that the background color of a paragraph seems
-                    // to bleed into the next character.
-                    ".".black().on_black(),
-                ]));
-                frame.render_widget(paragraph, layout[index]);
-                index += 1;
-            }
-        }
-    }
-}
-
-fn setup_terminal() -> Result<Terminal<CrosstermBackend<Stdout>>> {
-    enable_raw_mode()?;
-    let mut stdout = io::stdout();
-    execute!(stdout, EnterAlternateScreen)?;
-    let backend = CrosstermBackend::new(stdout);
-    let mut terminal = Terminal::new(backend)?;
-    terminal.hide_cursor()?;
-    Ok(terminal)
-}
-
-fn restore_terminal(mut terminal: Terminal<CrosstermBackend<Stdout>>) -> Result<()> {
-    disable_raw_mode()?;
-    execute!(terminal.backend_mut(), LeaveAlternateScreen)?;
-    terminal.show_cursor()?;
-    Ok(())
-}

examples/modifiers.tape

@@ -1,12 +0,0 @@
-# This is a vhs script. See https://github.com/charmbracelet/vhs for more info.
-# To run this script, install vhs and run `vhs ./examples/modifiers.tape`
-Output "target/modifiers.gif"
-Set Theme "Aardvark Blue"
-Set Width 1200
-Set Height 1460
-Hide
-Type "cargo run --example=modifiers --features=crossterm"
-Enter
-Sleep 2s
-Show
-Sleep 1s

examples/panic.rs

@@ -102,7 +102,7 @@ fn run_tui<B: Backend>(terminal: &mut Terminal<B>, app: &mut App) -> io::Result<
 }
 
 /// Render the TUI.
-fn ui(f: &mut Frame, app: &App) {
+fn ui<B: Backend>(f: &mut Frame<B>, app: &App) {
     let text = vec![
         if app.hook_enabled {
             Line::from("HOOK IS CURRENTLY **ENABLED**")

examples/panic.tape

@@ -1,7 +1,6 @@
 # This is a vhs script. See https://github.com/charmbracelet/vhs for more info.
 # To run this script, install vhs and run `vhs ./examples/panic.tape`
 Output "target/panic.gif"
-Set Theme "Aardvark Blue"
 Set Width 1200
 Set Height 600
 Type "cargo run --example=panic --features=crossterm"

examples/paragraph.rs

@@ -64,7 +64,9 @@ fn run_app<B: Backend>(
     loop {
         terminal.draw(|f| ui(f, &app))?;
 
-        let timeout = tick_rate.saturating_sub(last_tick.elapsed());
+        let timeout = tick_rate
+            .checked_sub(last_tick.elapsed())
+            .unwrap_or_else(|| Duration::from_secs(0));
         if crossterm::event::poll(timeout)? {
             if let Event::Key(key) = event::read()? {
                 if let KeyCode::Char('q') = key.code {
@@ -79,7 +81,7 @@ fn run_app<B: Backend>(
     }
 }
 
-fn ui(f: &mut Frame, app: &App) {
+fn ui<B: Backend>(f: &mut Frame<B>, app: &App) {
     let size = f.size();
 
     // Words made "loooong" to demonstrate line breaking.
@@ -92,12 +94,15 @@ fn ui(f: &mut Frame, app: &App) {
 
     let chunks = Layout::default()
         .direction(Direction::Vertical)
-        .constraints([
-            Constraint::Percentage(25),
-            Constraint::Percentage(25),
-            Constraint::Percentage(25),
-            Constraint::Percentage(25),
-        ])
+        .constraints(
+            [
+                Constraint::Percentage(25),
+                Constraint::Percentage(25),
+                Constraint::Percentage(25),
+                Constraint::Percentage(25),
+            ]
+            .as_ref(),
+        )
         .split(size);
 
     let text = vec![

examples/paragraph.tape

@@ -1,7 +1,6 @@
 # This is a vhs script. See https://github.com/charmbracelet/vhs for more info.
 # To run this script, install vhs and run `vhs ./examples/paragraph.tape`
 Output "target/paragraph.gif"
-Set Theme "Aardvark Blue"
 Set Width 1200
 Set Height 1800
 Hide

examples/popup.rs

@@ -61,11 +61,11 @@ fn run_app<B: Backend>(terminal: &mut Terminal<B>, mut app: App) -> io::Result<(
     }
 }
 
-fn ui(f: &mut Frame, app: &App) {
+fn ui<B: Backend>(f: &mut Frame<B>, app: &App) {
     let size = f.size();
 
     let chunks = Layout::default()
-        .constraints([Constraint::Percentage(20), Constraint::Percentage(80)])
+        .constraints([Constraint::Percentage(20), Constraint::Percentage(80)].as_ref())
         .split(size);
 
     let text = if app.show_popup {
@@ -96,19 +96,25 @@ fn ui(f: &mut Frame, app: &App) {
 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),
-        ])
+        .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),
-        ])
+        .constraints(
+            [
+                Constraint::Percentage((100 - percent_x) / 2),
+                Constraint::Percentage(percent_x),
+                Constraint::Percentage((100 - percent_x) / 2),
+            ]
+            .as_ref(),
+        )
         .split(popup_layout[1])[1]
 }

examples/popup.tape

@@ -1,7 +1,6 @@
 # This is a vhs script. See https://github.com/charmbracelet/vhs for more info.
 # To run this script, install vhs and run `vhs ./examples/popup.tape`
 Output "target/popup.gif"
-Set Theme "Aardvark Blue"
 Set Width 1200
 Set Height 600
 Hide

examples/scrollbar.rs

@@ -57,30 +57,36 @@ fn run_app<B: Backend>(
     loop {
         terminal.draw(|f| ui(f, &mut app))?;
 
-        let timeout = tick_rate.saturating_sub(last_tick.elapsed());
+        let timeout = tick_rate
+            .checked_sub(last_tick.elapsed())
+            .unwrap_or_else(|| Duration::from_secs(0));
         if crossterm::event::poll(timeout)? {
             if let Event::Key(key) = event::read()? {
                 match key.code {
                     KeyCode::Char('q') => return Ok(()),
                     KeyCode::Char('j') => {
                         app.vertical_scroll = app.vertical_scroll.saturating_add(1);
-                        app.vertical_scroll_state =
-                            app.vertical_scroll_state.position(app.vertical_scroll);
+                        app.vertical_scroll_state = app
+                            .vertical_scroll_state
+                            .position(app.vertical_scroll as u16);
                     }
                     KeyCode::Char('k') => {
                         app.vertical_scroll = app.vertical_scroll.saturating_sub(1);
-                        app.vertical_scroll_state =
-                            app.vertical_scroll_state.position(app.vertical_scroll);
+                        app.vertical_scroll_state = app
+                            .vertical_scroll_state
+                            .position(app.vertical_scroll as u16);
                     }
                     KeyCode::Char('h') => {
                         app.horizontal_scroll = app.horizontal_scroll.saturating_sub(1);
-                        app.horizontal_scroll_state =
-                            app.horizontal_scroll_state.position(app.horizontal_scroll);
+                        app.horizontal_scroll_state = app
+                            .horizontal_scroll_state
+                            .position(app.horizontal_scroll as u16);
                     }
                     KeyCode::Char('l') => {
                         app.horizontal_scroll = app.horizontal_scroll.saturating_add(1);
-                        app.horizontal_scroll_state =
-                            app.horizontal_scroll_state.position(app.horizontal_scroll);
+                        app.horizontal_scroll_state = app
+                            .horizontal_scroll_state
+                            .position(app.horizontal_scroll as u16);
                     }
                     _ => {}
                 }
@@ -92,7 +98,7 @@ fn run_app<B: Backend>(
     }
 }
 
-fn ui(f: &mut Frame, app: &mut App) {
+fn ui<B: Backend>(f: &mut Frame<B>, app: &mut App) {
     let size = f.size();
 
     // Words made "loooong" to demonstrate line breaking.
@@ -105,13 +111,16 @@ fn ui(f: &mut Frame, app: &mut App) {
 
     let chunks = Layout::default()
         .direction(Direction::Vertical)
-        .constraints([
-            Constraint::Min(1),
-            Constraint::Percentage(25),
-            Constraint::Percentage(25),
-            Constraint::Percentage(25),
-            Constraint::Percentage(25),
-        ])
+        .constraints(
+            [
+                Constraint::Min(1),
+                Constraint::Percentage(25),
+                Constraint::Percentage(25),
+                Constraint::Percentage(25),
+                Constraint::Percentage(25),
+            ]
+            .as_ref(),
+        )
         .split(size);
 
     let text = vec![
@@ -119,7 +128,7 @@ fn ui(f: &mut Frame, app: &mut App) {
         Line::from("This is a line   ".red()),
         Line::from("This is a line".on_dark_gray()),
         Line::from("This is a longer line".crossed_out()),
-        Line::from(long_line.clone()),
+        Line::from(long_line.reset()),
         Line::from("This is a line".reset()),
         Line::from(vec![
             Span::raw("Masked text: "),
@@ -132,7 +141,7 @@ fn ui(f: &mut Frame, app: &mut App) {
         Line::from("This is a line   ".red()),
         Line::from("This is a line".on_dark_gray()),
         Line::from("This is a longer line".crossed_out()),
-        Line::from(long_line.clone()),
+        Line::from(long_line.reset()),
         Line::from("This is a line".reset()),
         Line::from(vec![
             Span::raw("Masked text: "),
@@ -142,8 +151,10 @@ fn ui(f: &mut Frame, app: &mut App) {
             ),
         ]),
     ];
-    app.vertical_scroll_state = app.vertical_scroll_state.content_length(text.len());
-    app.horizontal_scroll_state = app.horizontal_scroll_state.content_length(long_line.len());
+    app.vertical_scroll_state = app.vertical_scroll_state.content_length(text.len() as u16);
+    app.horizontal_scroll_state = app
+        .horizontal_scroll_state
+        .content_length(long_line.len() as u16);
 
     let create_block = |title| {
         Block::default()
@@ -177,7 +188,7 @@ fn ui(f: &mut Frame, app: &mut App) {
     let paragraph = Paragraph::new(text.clone())
         .gray()
         .block(create_block(
-            "Vertical scrollbar without arrows, without track symbol and mirrored",
+            "Vertical scrollbar without arrows and mirrored",
         ))
         .scroll((app.vertical_scroll as u16, 0));
     f.render_widget(paragraph, chunks[2]);
@@ -186,7 +197,6 @@ fn ui(f: &mut Frame, app: &mut App) {
             .orientation(ScrollbarOrientation::VerticalLeft)
             .symbols(scrollbar::VERTICAL)
             .begin_symbol(None)
-            .track_symbol(None)
             .end_symbol(None),
         chunks[2].inner(&Margin {
             vertical: 1,
@@ -225,7 +235,7 @@ fn ui(f: &mut Frame, app: &mut App) {
         Scrollbar::default()
             .orientation(ScrollbarOrientation::HorizontalBottom)
             .thumb_symbol("░")
-            .track_symbol(Some("─")),
+            .track_symbol("─"),
         chunks[4].inner(&Margin {
             vertical: 0,
             horizontal: 1,

examples/scrollbar.tape

@@ -1,7 +1,6 @@
 # This is a vhs script. See https://github.com/charmbracelet/vhs for more info.
 # To run this script, install vhs and run `vhs ./examples/scrollbar.tape`
 Output "target/scrollbar.gif"
-Set Theme "Aardvark Blue"
 Set Width 1200
 Set Height 1200
 Hide

examples/sparkline.rs

@@ -109,7 +109,9 @@ fn run_app<B: Backend>(
     loop {
         terminal.draw(|f| ui(f, &app))?;
 
-        let timeout = tick_rate.saturating_sub(last_tick.elapsed());
+        let timeout = tick_rate
+            .checked_sub(last_tick.elapsed())
+            .unwrap_or_else(|| Duration::from_secs(0));
         if crossterm::event::poll(timeout)? {
             if let Event::Key(key) = event::read()? {
                 if let KeyCode::Char('q') = key.code {
@@ -124,14 +126,18 @@ fn run_app<B: Backend>(
     }
 }
 
-fn ui(f: &mut Frame, app: &App) {
+fn ui<B: Backend>(f: &mut Frame<B>, app: &App) {
     let chunks = Layout::default()
         .direction(Direction::Vertical)
-        .constraints([
-            Constraint::Length(3),
-            Constraint::Length(3),
-            Constraint::Min(0),
-        ])
+        .constraints(
+            [
+                Constraint::Length(3),
+                Constraint::Length(3),
+                Constraint::Length(7),
+                Constraint::Min(0),
+            ]
+            .as_ref(),
+        )
         .split(f.size());
     let sparkline = Sparkline::default()
         .block(

examples/sparkline.tape

@@ -1,7 +1,6 @@
 # This is a vhs script. See https://github.com/charmbracelet/vhs for more info.
 # To run this script, install vhs and run `vhs ./examples/sparkline.tape`
 Output "target/sparkline.gif"
-Set Theme "Aardvark Blue"
 Set Width 1200
 Set Height 600
 Hide

examples/table.rs

@@ -113,9 +113,9 @@ fn run_app<B: Backend>(terminal: &mut Terminal<B>, mut app: App) -> io::Result<(
     }
 }
 
-fn ui(f: &mut Frame, app: &mut App) {
+fn ui<B: Backend>(f: &mut Frame<B>, app: &mut App) {
     let rects = Layout::default()
-        .constraints([Constraint::Percentage(100)])
+        .constraints([Constraint::Percentage(100)].as_ref())
         .split(f.size());
 
     let selected_style = Style::default().add_modifier(Modifier::REVERSED);
@@ -142,7 +142,7 @@ fn ui(f: &mut Frame, app: &mut App) {
         .block(Block::default().borders(Borders::ALL).title("Table"))
         .highlight_style(selected_style)
         .highlight_symbol(">> ")
-        .widths([
+        .widths(&[
             Constraint::Percentage(50),
             Constraint::Max(30),
             Constraint::Min(10),

examples/table.tape

@@ -1,7 +1,6 @@
 # This is a vhs script. See https://github.com/charmbracelet/vhs for more info.
 # To run this script, install vhs and run `vhs ./examples/table.tape`
 Output "target/table.gif"
-Set Theme "Aardvark Blue"
 Set Width 1200
 Set Height 600
 Hide

examples/tabs.rs

@@ -78,11 +78,11 @@ fn run_app<B: Backend>(terminal: &mut Terminal<B>, mut app: App) -> io::Result<(
     }
 }
 
-fn ui(f: &mut Frame, app: &App) {
+fn ui<B: Backend>(f: &mut Frame<B>, app: &App) {
     let size = f.size();
     let chunks = Layout::default()
         .direction(Direction::Vertical)
-        .constraints([Constraint::Length(3), Constraint::Min(0)])
+        .constraints([Constraint::Length(3), Constraint::Min(0)].as_ref())
         .split(size);
 
     let block = Block::default().on_white().black();
@@ -98,8 +98,12 @@ fn ui(f: &mut Frame, app: &App) {
     let tabs = Tabs::new(titles)
         .block(Block::default().borders(Borders::ALL).title("Tabs"))
         .select(app.index)
-        .style(Style::default().cyan().on_gray())
-        .highlight_style(Style::default().bold().on_black());
+        .style(Style::default().fg(Color::Cyan))
+        .highlight_style(
+            Style::default()
+                .add_modifier(Modifier::BOLD)
+                .bg(Color::Black),
+        );
     f.render_widget(tabs, chunks[0]);
     let inner = match app.index {
         0 => Block::default().title("Inner 0").borders(Borders::ALL),

examples/tabs.tape

@@ -1,7 +1,6 @@
 # This is a vhs script. See https://github.com/charmbracelet/vhs for more info.
 # To run this script, install vhs and run `vhs ./examples/tabs.tape`
 Output "target/tabs.gif"
-Set Theme "Aardvark Blue"
 Set Width 1200
 Set Height 300
 Hide

examples/user_input.rs

@@ -171,14 +171,17 @@ fn run_app<B: Backend>(terminal: &mut Terminal<B>, mut app: App) -> io::Result<(
     }
 }
 
-fn ui(f: &mut Frame, app: &App) {
+fn ui<B: Backend>(f: &mut Frame<B>, app: &App) {
     let chunks = Layout::default()
         .direction(Direction::Vertical)
-        .constraints([
-            Constraint::Length(1),
-            Constraint::Length(3),
-            Constraint::Min(1),
-        ])
+        .constraints(
+            [
+                Constraint::Length(1),
+                Constraint::Length(3),
+                Constraint::Min(1),
+            ]
+            .as_ref(),
+        )
         .split(f.size());
 
     let (msg, style) = match app.input_mode {

examples/user_input.tape

@@ -1,7 +1,6 @@
 # This is a vhs script. See https://github.com/charmbracelet/vhs for more info.
 # To run this script, install vhs and run `vhs ./examples/user_input.tape`
 Output "target/user_input.gif"
-Set Theme "Aardvark Blue"
 Set Width 1200
 Set Height 600
 Hide

rust-toolchain.toml

@@ -1,2 +0,0 @@
-[toolchain]
-channel = "stable"

src/backend.rs

@@ -1,338 +0,0 @@
-#![warn(missing_docs)]
-//! This module provides the backend implementations for different terminal libraries.
-//!
-//! It defines the [`Backend`] trait which is used to abstract over the specific terminal library
-//! being used.
-//!
-//! Supported terminal backends:
-//! - [Crossterm]: enable the `crossterm` feature (enabled by default) and use [`CrosstermBackend`]
-//! - [Termion]: enable the `termion` feature and use [`TermionBackend`]
-//! - [Termwiz]: enable the `termwiz` feature and use [`TermwizBackend`]
-//!
-//! Additionally, a [`TestBackend`] is provided for testing purposes.
-//!
-//! See the [Backend Comparison] section of the [Ratatui Book] for more details on the different
-//! backends.
-//!
-//! Each backend supports a number of features, such as [raw mode](#raw-mode), [alternate
-//! screen](#alternate-screen), and [mouse capture](#mouse-capture). These features are generally
-//! not enabled by default, and must be enabled by the application before they can be used. See the
-//! documentation for each backend for more details.
-//!
-//! Note: most applications should use the [`Terminal`] struct instead of directly calling methods
-//! on the backend.
-//!
-//! # Example
-//!
-//! ```rust,no_run
-//! use std::io::stdout;
-//! use ratatui::prelude::*;
-//!
-//! let backend = CrosstermBackend::new(stdout());
-//! let mut terminal = Terminal::new(backend)?;
-//! terminal.clear()?;
-//! terminal.draw(|frame| {
-//!     // -- snip --
-//! })?;
-//! # std::io::Result::Ok(())
-//! ```
-//!
-//! See the the [examples] directory for more examples.
-//!
-//! # Raw Mode
-//!
-//! Raw mode is a mode where the terminal does not perform any processing or handling of the input
-//! and output. This means that features such as echoing input characters, line buffering, and
-//! special character processing (e.g., CTRL-C for SIGINT) are disabled. This is useful for
-//! applications that want to have complete control over the terminal input and output, processing
-//! each keystroke themselves.
-//!
-//! For example, in raw mode, the terminal will not perform line buffering on the input, so the
-//! application will receive each key press as it is typed, instead of waiting for the user to
-//! press enter. This makes it suitable for real-time applications like text editors,
-//! terminal-based games, and more.
-//!
-//! Each backend handles raw mode differently, so the behavior may vary depending on the backend
-//! being used. Be sure to consult the backend's specific documentation for exact details on how it
-//! implements raw mode.
-
-//! # Alternate Screen
-//!
-//! The alternate screen is a separate buffer that some terminals provide, distinct from the main
-//! screen. When activated, the terminal will display the alternate screen, hiding the current
-//! content of the main screen. Applications can write to this screen as if it were the regular
-//! terminal display, but when the application exits, the terminal will switch back to the main
-//! screen, and the contents of the alternate screen will be cleared. This is useful for
-//! applications like text editors or terminal games that want to use the full terminal window
-//! without disrupting the command line or other terminal content.
-//!
-//! This creates a seamless transition between the application and the regular terminal session, as
-//! the content displayed before launching the application will reappear after the application
-//! exits.
-//!
-//! Note that not all terminal emulators support the alternate screen, and even those that do may
-//! handle it differently. As a result, the behavior may vary depending on the backend being used.
-//! Always consult the specific backend's documentation to understand how it implements the
-//! alternate screen.
-//!
-//! # Mouse Capture
-//!
-//! Mouse capture is a mode where the terminal captures mouse events such as clicks, scrolls, and
-//! movement, and sends them to the application as special sequences or events. This enables the
-//! application to handle and respond to mouse actions, providing a more interactive and graphical
-//! user experience within the terminal. It's particularly useful for applications like
-//! terminal-based games, text editors, or other programs that require more direct interaction from
-//! the user.
-//!
-//! Each backend handles mouse capture differently, with variations in the types of events that can
-//! be captured and how they are represented. As such, the behavior may vary depending on the
-//! backend being used, and developers should consult the specific backend's documentation to
-//! understand how it implements mouse capture.
-//!
-//! [`TermionBackend`]: termion/struct.TermionBackend.html
-//! [`Terminal`]: crate::terminal::Terminal
-//! [`TermionBackend`]: termion/struct.TermionBackend.html
-//! [Crossterm]: https://crates.io/crates/crossterm
-//! [Termion]: https://crates.io/crates/termion
-//! [Termwiz]: https://crates.io/crates/termwiz
-//! [examples]: https://github.com/ratatui-org/ratatui/tree/main/examples#readme
-//! [Backend Comparison]:
-//!     https://ratatui-org.github.io/ratatui-book/concepts/backends/comparison.html
-//! [Ratatui Book]: https://ratatui-org.github.io/ratatui-book
-use std::io;
-
-use strum::{Display, EnumString};
-
-use crate::{buffer::Cell, layout::Size, prelude::Rect};
-
-#[cfg(feature = "termion")]
-mod termion;
-#[cfg(feature = "termion")]
-pub use self::termion::TermionBackend;
-
-#[cfg(feature = "crossterm")]
-mod crossterm;
-#[cfg(feature = "crossterm")]
-pub use self::crossterm::CrosstermBackend;
-
-#[cfg(feature = "termwiz")]
-mod termwiz;
-#[cfg(feature = "termwiz")]
-pub use self::termwiz::TermwizBackend;
-
-mod test;
-pub use self::test::TestBackend;
-
-/// Enum representing the different types of clearing operations that can be performed
-/// on the terminal screen.
-#[derive(Debug, Display, EnumString, Clone, Copy, Eq, PartialEq, Hash)]
-pub enum ClearType {
-    /// Clear the entire screen.
-    All,
-    /// Clear everything after the cursor.
-    AfterCursor,
-    /// Clear everything before the cursor.
-    BeforeCursor,
-    /// Clear the current line.
-    CurrentLine,
-    /// Clear everything from the cursor until the next newline.
-    UntilNewLine,
-}
-
-/// The window size in characters (columns / rows) as well as pixels.
-#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
-pub struct WindowSize {
-    /// Size of the window in characters (columns / rows).
-    pub columns_rows: Size,
-    /// Size of the window in pixels.
-    ///
-    /// The `pixels` fields may not be implemented by all terminals and return `0,0`. See
-    /// <https://man7.org/linux/man-pages/man4/tty_ioctl.4.html> under section "Get and set window
-    /// size" / TIOCGWINSZ where the fields are commented as "unused".
-    pub pixels: Size,
-}
-
-/// The `Backend` trait provides an abstraction over different terminal libraries. It defines the
-/// methods required to draw content, manipulate the cursor, and clear the terminal screen.
-///
-/// Most applications should not need to interact with the `Backend` trait directly as the
-/// [`Terminal`] struct provides a higher level interface for interacting with the terminal.
-///
-/// [`Terminal`]: crate::terminal::Terminal
-pub trait Backend {
-    /// Draw the given content to the terminal screen.
-    ///
-    /// The content is provided as an iterator over `(u16, u16, &Cell)` tuples, where the first two
-    /// elements represent the x and y coordinates, and the third element is a reference to the
-    /// [`Cell`] to be drawn.
-    fn draw<'a, I>(&mut self, content: I) -> io::Result<()>
-    where
-        I: Iterator<Item = (u16, u16, &'a Cell)>;
-
-    /// Insert `n` line breaks to the terminal screen.
-    ///
-    /// This method is optional and may not be implemented by all backends.
-    fn append_lines(&mut self, _n: u16) -> io::Result<()> {
-        Ok(())
-    }
-
-    /// Hide the cursor on the terminal screen.
-    ///
-    ///
-    /// See also [`show_cursor`].
-    /// # Example
-    ///
-    /// ```rust
-    /// # use ratatui::backend::{Backend, TestBackend};
-    /// # let mut backend = TestBackend::new(80, 25);
-    /// backend.hide_cursor()?;
-    /// // do something with hidden cursor
-    /// backend.show_cursor()?;
-    /// # std::io::Result::Ok(())
-    /// ```
-    ///
-    /// [`show_cursor`]: Backend::show_cursor
-    fn hide_cursor(&mut self) -> io::Result<()>;
-
-    /// Show the cursor on the terminal screen.
-    ///
-    /// See [`hide_cursor`] for an example.
-    ///
-    /// [`hide_cursor`]: Backend::hide_cursor
-    fn show_cursor(&mut self) -> io::Result<()>;
-
-    /// Get the current cursor position on the terminal screen.
-    ///
-    /// The returned tuple contains the x and y coordinates of the cursor. The origin
-    /// (0, 0) is at the top left corner of the screen.
-    ///
-    /// See [`set_cursor`] for an example.
-    ///
-    /// [`set_cursor`]: Backend::set_cursor
-    fn get_cursor(&mut self) -> io::Result<(u16, u16)>;
-
-    /// Set the cursor position on the terminal screen to the given x and y coordinates.
-    ///
-    /// The origin (0, 0) is at the top left corner of the screen.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// # use ratatui::backend::{Backend, TestBackend};
-    /// # let mut backend = TestBackend::new(80, 25);
-    /// backend.set_cursor(10, 20)?;
-    /// assert_eq!(backend.get_cursor()?, (10, 20));
-    /// # std::io::Result::Ok(())
-    /// ```
-    ///
-    /// [`get_cursor`]: Backend::get_cursor
-    fn set_cursor(&mut self, x: u16, y: u16) -> io::Result<()>;
-
-    /// Clears the whole terminal screen
-    ///
-    /// # Example
-    ///
-    /// ```rust,no_run
-    /// # use ratatui::backend::{Backend, TestBackend};
-    /// # let mut backend = TestBackend::new(80, 25);
-    /// backend.clear()?;
-    /// # std::io::Result::Ok(())
-    /// ```
-    fn clear(&mut self) -> io::Result<()>;
-
-    /// Clears a specific region of the terminal specified by the [`ClearType`] parameter
-    ///
-    /// This method is optional and may not be implemented by all backends. The default
-    /// implementation calls [`clear`] if the `clear_type` is [`ClearType::All`] and returns an
-    /// error otherwise.
-    ///
-    /// # Example
-    ///
-    /// ```rust,no_run
-    /// # use ratatui::{prelude::*, backend::{TestBackend, ClearType}};
-    /// # let mut backend = TestBackend::new(80, 25);
-    /// backend.clear_region(ClearType::All)?;
-    /// # std::io::Result::Ok(())
-    /// ```
-    ///
-    /// # Errors
-    ///
-    /// This method will return an error if the terminal screen could not be cleared. It will also
-    /// return an error if the `clear_type` is not supported by the backend.
-    ///
-    /// [`clear`]: Backend::clear
-    fn clear_region(&mut self, clear_type: ClearType) -> io::Result<()> {
-        match clear_type {
-            ClearType::All => self.clear(),
-            ClearType::AfterCursor
-            | ClearType::BeforeCursor
-            | ClearType::CurrentLine
-            | ClearType::UntilNewLine => Err(io::Error::new(
-                io::ErrorKind::Other,
-                format!("clear_type [{clear_type:?}] not supported with this backend"),
-            )),
-        }
-    }
-
-    /// Get the size of the terminal screen in columns/rows as a [`Rect`].
-    ///
-    /// The returned [`Rect`] contains the width and height of the terminal screen.
-    ///
-    /// # Example
-    ///
-    /// ```rust,no_run
-    /// # use ratatui::{prelude::*, backend::TestBackend};
-    /// let backend = TestBackend::new(80, 25);
-    /// assert_eq!(backend.size()?, Rect::new(0, 0, 80, 25));
-    /// # std::io::Result::Ok(())
-    /// ```
-    fn size(&self) -> io::Result<Rect>;
-
-    /// Get the size of the terminal screen in columns/rows and pixels as a [`WindowSize`].
-    ///
-    /// The reason for this not returning only the pixel size, given the redundancy with the
-    /// `size()` method, is that the underlying backends most likely get both values with one
-    /// syscall, and the user is also most likely to need columns and rows along with pixel size.
-    fn window_size(&mut self) -> io::Result<WindowSize>;
-
-    /// Flush any buffered content to the terminal screen.
-    fn flush(&mut self) -> io::Result<()>;
-}
-
-#[cfg(test)]
-mod tests {
-    use strum::ParseError;
-
-    use super::*;
-
-    #[test]
-    fn clear_type_tostring() {
-        assert_eq!(ClearType::All.to_string(), "All");
-        assert_eq!(ClearType::AfterCursor.to_string(), "AfterCursor");
-        assert_eq!(ClearType::BeforeCursor.to_string(), "BeforeCursor");
-        assert_eq!(ClearType::CurrentLine.to_string(), "CurrentLine");
-        assert_eq!(ClearType::UntilNewLine.to_string(), "UntilNewLine");
-    }
-
-    #[test]
-    fn clear_type_from_str() {
-        assert_eq!("All".parse::<ClearType>(), Ok(ClearType::All));
-        assert_eq!(
-            "AfterCursor".parse::<ClearType>(),
-            Ok(ClearType::AfterCursor)
-        );
-        assert_eq!(
-            "BeforeCursor".parse::<ClearType>(),
-            Ok(ClearType::BeforeCursor)
-        );
-        assert_eq!(
-            "CurrentLine".parse::<ClearType>(),
-            Ok(ClearType::CurrentLine)
-        );
-        assert_eq!(
-            "UntilNewLine".parse::<ClearType>(),
-            Ok(ClearType::UntilNewLine)
-        );
-        assert_eq!("".parse::<ClearType>(), Err(ParseError::VariantNotFound));
-    }
-}

src/backend/crossterm.rs

@@ -1,103 +1,59 @@
-//! This module provides the [`CrosstermBackend`] implementation for the [`Backend`] trait. It uses
-//! the [Crossterm] crate to interact with the terminal.
+//! This module provides the `CrosstermBackend` implementation for the `Backend` trait.
+//! It uses the `crossterm` crate to interact with the terminal.
 //!
-//! [Crossterm]: https://crates.io/crates/crossterm
+//!
+//! [`Backend`]: trait.Backend.html
+//! [`CrosstermBackend`]: struct.CrosstermBackend.html
+
 use std::io::{self, Write};
 
-#[cfg(feature = "underline-color")]
-use crossterm::style::SetUnderlineColor;
 use crossterm::{
     cursor::{Hide, MoveTo, Show},
     execute, queue,
     style::{
         Attribute as CAttribute, Color as CColor, Print, SetAttribute, SetBackgroundColor,
-        SetForegroundColor,
+        SetForegroundColor, SetUnderlineColor,
     },
     terminal::{self, Clear},
 };
 
 use crate::{
-    backend::{Backend, ClearType, WindowSize},
+    backend::{Backend, ClearType},
     buffer::Cell,
-    layout::Size,
-    prelude::Rect,
+    layout::Rect,
     style::{Color, Modifier},
 };
 
-/// A [`Backend`] implementation that uses [Crossterm] to render to the terminal.
+/// A backend implementation using the `crossterm` crate.
 ///
-/// The `CrosstermBackend` struct is a wrapper around a writer implementing [`Write`], which is
-/// used to send commands to the terminal. It provides methods for drawing content, manipulating
-/// the cursor, and clearing the terminal screen.
-///
-/// Most applications should not call the methods on `CrosstermBackend` directly, but will instead
-/// use the [`Terminal`] struct, which provides a more ergonomic interface.
-///
-/// Usually applications will enable raw mode and switch to alternate screen mode after creating
-/// a `CrosstermBackend`. This is done by calling [`crossterm::terminal::enable_raw_mode`] and
-/// [`crossterm::terminal::EnterAlternateScreen`] (and the corresponding disable/leave functions
-/// when the application exits). This is not done automatically by the backend because it is
-/// possible that the application may want to use the terminal for other purposes (like showing
-/// help text) before entering alternate screen mode.
+/// The `CrosstermBackend` struct is a wrapper around a type implementing `Write`, which
+/// is used to send commands to the terminal. It provides methods for drawing content,
+/// manipulating the cursor, and clearing the terminal screen.
 ///
 /// # Example
 ///
-/// ```rust,no_run
-/// use std::io::{stdout, stderr};
-/// use crossterm::{
-///     terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
-///     ExecutableCommand,
-/// };
-/// use ratatui::prelude::*;
+/// ```rust
+/// use ratatui::backend::{Backend, CrosstermBackend};
 ///
-/// let mut backend = CrosstermBackend::new(stdout());
-/// // or
-/// let backend = CrosstermBackend::new(stderr());
-/// let mut terminal = Terminal::new(backend)?;
-///
-/// enable_raw_mode()?;
-/// stdout().execute(EnterAlternateScreen)?;
-///
-/// terminal.clear()?;
-/// terminal.draw(|frame| {
-///     // -- snip --
-/// })?;
-///
-/// stdout().execute(LeaveAlternateScreen)?;
-/// disable_raw_mode()?;
-///
-/// # std::io::Result::Ok(())
+/// # fn main() -> Result<(), Box<dyn std::error::Error>> {
+/// let buffer = std::io::stdout();
+/// let mut backend = CrosstermBackend::new(buffer);
+/// backend.clear()?;
+/// # Ok(())
+/// # }
 /// ```
-///
-/// See the the [examples] directory for more examples. See the [`backend`] module documentation
-/// for more details on raw mode and alternate screen.
-///
-/// [`Write`]: std::io::Write
-/// [`Terminal`]: crate::terminal::Terminal
-/// [`backend`]: crate::backend
-/// [Crossterm]: https://crates.io/crates/crossterm
-/// [examples]: https://github.com/ratatui-org/ratatui/tree/main/examples#examples
-#[derive(Debug, Default, Clone, Eq, PartialEq, Hash)]
+#[derive(Debug, Default, Clone)]
 pub struct CrosstermBackend<W: Write> {
-    /// The writer used to send commands to the terminal.
-    writer: W,
+    buffer: W,
 }
 
 impl<W> CrosstermBackend<W>
 where
     W: Write,
 {
-    /// Creates a new `CrosstermBackend` with the given writer.
-    ///
-    /// # Example
-    ///
-    /// ```rust,no_run
-    /// # use std::io::stdout;
-    /// # use ratatui::prelude::*;
-    /// let backend = CrosstermBackend::new(stdout());
-    /// ```
-    pub fn new(writer: W) -> CrosstermBackend<W> {
-        CrosstermBackend { writer }
+    /// Creates a new `CrosstermBackend` with the given buffer.
+    pub fn new(buffer: W) -> CrosstermBackend<W> {
+        CrosstermBackend { buffer }
     }
 }
 
@@ -107,12 +63,12 @@ where
 {
     /// Writes a buffer of bytes to the underlying buffer.
     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        self.writer.write(buf)
+        self.buffer.write(buf)
     }
 
     /// Flushes the underlying buffer.
     fn flush(&mut self) -> io::Result<()> {
-        self.writer.flush()
+        self.buffer.flush()
     }
 }
 
@@ -126,14 +82,13 @@ where
     {
         let mut fg = Color::Reset;
         let mut bg = Color::Reset;
-        #[cfg(feature = "underline-color")]
         let mut underline_color = Color::Reset;
         let mut modifier = Modifier::empty();
         let mut last_pos: Option<(u16, u16)> = None;
         for (x, y, cell) in content {
             // 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) {
-                queue!(self.writer, MoveTo(x, y))?;
+                map_error(queue!(self.buffer, MoveTo(x, y)))?;
             }
             last_pos = Some((x, y));
             if cell.modifier != modifier {
@@ -141,52 +96,43 @@ where
                     from: modifier,
                     to: cell.modifier,
                 };
-                diff.queue(&mut self.writer)?;
+                diff.queue(&mut self.buffer)?;
                 modifier = cell.modifier;
             }
             if cell.fg != fg {
                 let color = CColor::from(cell.fg);
-                queue!(self.writer, SetForegroundColor(color))?;
+                map_error(queue!(self.buffer, SetForegroundColor(color)))?;
                 fg = cell.fg;
             }
             if cell.bg != bg {
                 let color = CColor::from(cell.bg);
-                queue!(self.writer, SetBackgroundColor(color))?;
+                map_error(queue!(self.buffer, SetBackgroundColor(color)))?;
                 bg = cell.bg;
             }
-            #[cfg(feature = "underline-color")]
             if cell.underline_color != underline_color {
                 let color = CColor::from(cell.underline_color);
-                queue!(self.writer, SetUnderlineColor(color))?;
+                map_error(queue!(self.buffer, SetUnderlineColor(color)))?;
                 underline_color = cell.underline_color;
             }
 
-            queue!(self.writer, Print(cell.symbol()))?;
+            map_error(queue!(self.buffer, Print(&cell.symbol)))?;
         }
 
-        #[cfg(feature = "underline-color")]
-        return queue!(
-            self.writer,
+        map_error(queue!(
+            self.buffer,
             SetForegroundColor(CColor::Reset),
             SetBackgroundColor(CColor::Reset),
             SetUnderlineColor(CColor::Reset),
-            SetAttribute(CAttribute::Reset),
-        );
-        #[cfg(not(feature = "underline-color"))]
-        return queue!(
-            self.writer,
-            SetForegroundColor(CColor::Reset),
-            SetBackgroundColor(CColor::Reset),
-            SetAttribute(CAttribute::Reset),
-        );
+            SetAttribute(CAttribute::Reset)
+        ))
     }
 
     fn hide_cursor(&mut self) -> io::Result<()> {
-        execute!(self.writer, Hide)
+        map_error(execute!(self.buffer, Hide))
     }
 
     fn show_cursor(&mut self) -> io::Result<()> {
-        execute!(self.writer, Show)
+        map_error(execute!(self.buffer, Show))
     }
 
     fn get_cursor(&mut self) -> io::Result<(u16, u16)> {
@@ -195,7 +141,7 @@ where
     }
 
     fn set_cursor(&mut self, x: u16, y: u16) -> io::Result<()> {
-        execute!(self.writer, MoveTo(x, y))
+        map_error(execute!(self.buffer, MoveTo(x, y)))
     }
 
     fn clear(&mut self) -> io::Result<()> {
@@ -203,8 +149,8 @@ where
     }
 
     fn clear_region(&mut self, clear_type: ClearType) -> io::Result<()> {
-        execute!(
-            self.writer,
+        map_error(execute!(
+            self.buffer,
             Clear(match clear_type {
                 ClearType::All => crossterm::terminal::ClearType::All,
                 ClearType::AfterCursor => crossterm::terminal::ClearType::FromCursorDown,
@@ -212,42 +158,32 @@ where
                 ClearType::CurrentLine => crossterm::terminal::ClearType::CurrentLine,
                 ClearType::UntilNewLine => crossterm::terminal::ClearType::UntilNewLine,
             })
-        )
+        ))
     }
 
     fn append_lines(&mut self, n: u16) -> io::Result<()> {
         for _ in 0..n {
-            queue!(self.writer, Print("\n"))?;
+            map_error(queue!(self.buffer, Print("\n")))?;
         }
-        self.writer.flush()
+        self.buffer.flush()
     }
 
     fn size(&self) -> io::Result<Rect> {
-        let (width, height) = terminal::size()?;
+        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 window_size(&mut self) -> Result<WindowSize, io::Error> {
-        let crossterm::terminal::WindowSize {
-            columns,
-            rows,
-            width,
-            height,
-        } = terminal::window_size()?;
-        Ok(WindowSize {
-            columns_rows: Size {
-                width: columns,
-                height: rows,
-            },
-            pixels: Size { width, height },
-        })
-    }
-
     fn flush(&mut self) -> io::Result<()> {
-        self.writer.flush()
+        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 {
@@ -277,7 +213,7 @@ impl From<Color> for CColor {
 /// The `ModifierDiff` struct is used to calculate the difference between two `Modifier`
 /// values. This is useful when updating the terminal display, as it allows for more
 /// efficient updates by only sending the necessary changes.
-#[derive(Debug, Default, Clone, Copy, Eq, PartialEq, Hash)]
+#[derive(Debug, Default, Clone, Copy)]
 struct ModifierDiff {
     pub from: Modifier,
     pub to: Modifier,
@@ -291,54 +227,54 @@ impl ModifierDiff {
         //use crossterm::Attribute;
         let removed = self.from - self.to;
         if removed.contains(Modifier::REVERSED) {
-            queue!(w, SetAttribute(CAttribute::NoReverse))?;
+            map_error(queue!(w, SetAttribute(CAttribute::NoReverse)))?;
         }
         if removed.contains(Modifier::BOLD) {
-            queue!(w, SetAttribute(CAttribute::NormalIntensity))?;
+            map_error(queue!(w, SetAttribute(CAttribute::NormalIntensity)))?;
             if self.to.contains(Modifier::DIM) {
-                queue!(w, SetAttribute(CAttribute::Dim))?;
+                map_error(queue!(w, SetAttribute(CAttribute::Dim)))?;
             }
         }
         if removed.contains(Modifier::ITALIC) {
-            queue!(w, SetAttribute(CAttribute::NoItalic))?;
+            map_error(queue!(w, SetAttribute(CAttribute::NoItalic)))?;
         }
         if removed.contains(Modifier::UNDERLINED) {
-            queue!(w, SetAttribute(CAttribute::NoUnderline))?;
+            map_error(queue!(w, SetAttribute(CAttribute::NoUnderline)))?;
         }
         if removed.contains(Modifier::DIM) {
-            queue!(w, SetAttribute(CAttribute::NormalIntensity))?;
+            map_error(queue!(w, SetAttribute(CAttribute::NormalIntensity)))?;
         }
         if removed.contains(Modifier::CROSSED_OUT) {
-            queue!(w, SetAttribute(CAttribute::NotCrossedOut))?;
+            map_error(queue!(w, SetAttribute(CAttribute::NotCrossedOut)))?;
         }
         if removed.contains(Modifier::SLOW_BLINK) || removed.contains(Modifier::RAPID_BLINK) {
-            queue!(w, SetAttribute(CAttribute::NoBlink))?;
+            map_error(queue!(w, SetAttribute(CAttribute::NoBlink)))?;
         }
 
         let added = self.to - self.from;
         if added.contains(Modifier::REVERSED) {
-            queue!(w, SetAttribute(CAttribute::Reverse))?;
+            map_error(queue!(w, SetAttribute(CAttribute::Reverse)))?;
         }
         if added.contains(Modifier::BOLD) {
-            queue!(w, SetAttribute(CAttribute::Bold))?;
+            map_error(queue!(w, SetAttribute(CAttribute::Bold)))?;
         }
         if added.contains(Modifier::ITALIC) {
-            queue!(w, SetAttribute(CAttribute::Italic))?;
+            map_error(queue!(w, SetAttribute(CAttribute::Italic)))?;
         }
         if added.contains(Modifier::UNDERLINED) {
-            queue!(w, SetAttribute(CAttribute::Underlined))?;
+            map_error(queue!(w, SetAttribute(CAttribute::Underlined)))?;
         }
         if added.contains(Modifier::DIM) {
-            queue!(w, SetAttribute(CAttribute::Dim))?;
+            map_error(queue!(w, SetAttribute(CAttribute::Dim)))?;
         }
         if added.contains(Modifier::CROSSED_OUT) {
-            queue!(w, SetAttribute(CAttribute::CrossedOut))?;
+            map_error(queue!(w, SetAttribute(CAttribute::CrossedOut)))?;
         }
         if added.contains(Modifier::SLOW_BLINK) {
-            queue!(w, SetAttribute(CAttribute::SlowBlink))?;
+            map_error(queue!(w, SetAttribute(CAttribute::SlowBlink)))?;
         }
         if added.contains(Modifier::RAPID_BLINK) {
-            queue!(w, SetAttribute(CAttribute::RapidBlink))?;
+            map_error(queue!(w, SetAttribute(CAttribute::RapidBlink)))?;
         }
 
         Ok(())

src/backend/mod.rs

@@ -0,0 +1,117 @@
+//! This module provides the backend implementations for different terminal libraries.
+//! It defines the [`Backend`] trait which is used to abstract over the specific
+//! terminal library being used.
+//!
+//! The following terminal libraries are supported:
+//! - Crossterm (with the `crossterm` feature)
+//! - Termion (with the `termion` feature)
+//! - Termwiz (with the `termwiz` feature)
+//!
+//! Additionally, a [`TestBackend`] is provided for testing purposes.
+//!
+//! # Example
+//!
+//! ```rust
+//! use ratatui::backend::{Backend, CrosstermBackend};
+//!
+//! # fn main() -> Result<(), Box<dyn std::error::Error>> {
+//! let buffer = std::io::stdout();
+//! let mut backend = CrosstermBackend::new(buffer);
+//! backend.clear()?;
+//! # Ok(())
+//! # }
+//! ```
+//!
+//! [`Backend`]: trait.Backend.html
+//! [`TestBackend`]: struct.TestBackend.html
+
+use std::io;
+
+use crate::{buffer::Cell, layout::Rect};
+
+#[cfg(feature = "termion")]
+mod termion;
+#[cfg(feature = "termion")]
+pub use self::termion::TermionBackend;
+
+#[cfg(feature = "crossterm")]
+mod crossterm;
+#[cfg(feature = "crossterm")]
+pub use self::crossterm::CrosstermBackend;
+
+#[cfg(feature = "termwiz")]
+mod termwiz;
+#[cfg(feature = "termwiz")]
+pub use self::termwiz::TermwizBackend;
+
+mod test;
+pub use self::test::TestBackend;
+
+/// Enum representing the different types of clearing operations that can be performed
+/// on the terminal screen.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum ClearType {
+    All,
+    AfterCursor,
+    BeforeCursor,
+    CurrentLine,
+    UntilNewLine,
+}
+
+/// The `Backend` trait provides an abstraction over different terminal libraries.
+/// It defines the methods required to draw content, manipulate the cursor, and
+/// clear the terminal screen.
+pub trait Backend {
+    /// Draw the given content to the terminal screen.
+    ///
+    /// The content is provided as an iterator over `(u16, u16, &Cell)` tuples,
+    /// where the first two elements represent the x and y coordinates, and the
+    /// third element is a reference to the [`Cell`] to be drawn.
+    fn draw<'a, I>(&mut self, content: I) -> Result<(), io::Error>
+    where
+        I: Iterator<Item = (u16, u16, &'a Cell)>;
+
+    /// Insert `n` line breaks to the terminal screen.
+    ///
+    /// This method is optional and may not be implemented by all backends.
+    fn append_lines(&mut self, _n: u16) -> io::Result<()> {
+        Ok(())
+    }
+
+    /// Hide the cursor on the terminal screen.
+    fn hide_cursor(&mut self) -> Result<(), io::Error>;
+
+    /// Show the cursor on the terminal screen.
+    fn show_cursor(&mut self) -> Result<(), io::Error>;
+
+    /// Get the current cursor position on the terminal screen.
+    fn get_cursor(&mut self) -> Result<(u16, u16), io::Error>;
+
+    /// Set the cursor position on the terminal screen to the given x and y coordinates.
+    fn set_cursor(&mut self, x: u16, y: u16) -> Result<(), io::Error>;
+
+    /// Clears the whole terminal screen
+    fn clear(&mut self) -> Result<(), io::Error>;
+
+    /// Clears a specific region of the terminal specified by the [`ClearType`] parameter
+    ///
+    /// This method is optional and may not be implemented by all backends.
+    fn clear_region(&mut self, clear_type: ClearType) -> Result<(), io::Error> {
+        match clear_type {
+            ClearType::All => self.clear(),
+            ClearType::AfterCursor
+            | ClearType::BeforeCursor
+            | ClearType::CurrentLine
+            | ClearType::UntilNewLine => Err(io::Error::new(
+                io::ErrorKind::Other,
+                format!("clear_type [{clear_type:?}] not supported with this backend"),
+            )),
+        }
+    }
+
+    /// Get the size of the terminal screen as a [`Rect`].
+    fn size(&self) -> Result<Rect, io::Error>;
+
+    /// Flush any buffered content to the terminal screen.
+    fn flush(&mut self) -> Result<(), io::Error>;
+}

src/backend/termion.rs

@@ -1,86 +1,51 @@
-//! This module provides the [`TermionBackend`] implementation for the [`Backend`] trait. It uses
-//! the [Termion] crate to interact with the terminal.
+//! This module provides the `TermionBackend` implementation for the [`Backend`] trait.
+//! It uses the Termion crate to interact with the terminal.
 //!
 //! [`Backend`]: crate::backend::Backend
 //! [`TermionBackend`]: crate::backend::TermionBackend
-//! [Termion]: https://docs.rs/termion
+
 use std::{
     fmt,
     io::{self, Write},
 };
 
 use crate::{
-    backend::{Backend, ClearType, WindowSize},
+    backend::{Backend, ClearType},
     buffer::Cell,
-    prelude::Rect,
+    layout::Rect,
     style::{Color, Modifier},
 };
 
-/// A [`Backend`] implementation that uses [Termion] to render to the terminal.
-///
-/// The `TermionBackend` struct is a wrapper around a writer implementing [`Write`], which is used
-/// to send commands to the terminal. It provides methods for drawing content, manipulating the
-/// cursor, and clearing the terminal screen.
-///
-/// Most applications should not call the methods on `TermionBackend` directly, but will instead
-/// use the [`Terminal`] struct, which provides a more ergonomic interface.
-///
-/// Usually applications will enable raw mode and switch to alternate screen mode when starting.
-/// This is done by calling [`IntoRawMode::into_raw_mode()`] and
-/// [`IntoAlternateScreen::into_alternate_screen()`] on the writer before creating the backend.
-/// This is not done automatically by the backend because it is possible that the application may
-/// want to use the terminal for other purposes (like showing help text) before entering alternate
-/// screen mode. This backend automatically disable raw mode and switches back to the primary
-/// screen when the writer is dropped.
+/// A backend that uses the Termion library to draw content, manipulate the cursor,
+/// and clear the terminal screen.
 ///
 /// # Example
 ///
-/// ```rust,no_run
-/// use std::io::{stdout, stderr};
-/// use ratatui::prelude::*;
-/// use termion::{raw::IntoRawMode, screen::IntoAlternateScreen};
+/// ```rust
+/// use ratatui::backend::{Backend, TermionBackend};
 ///
-/// let writer = stdout().into_raw_mode()?.into_alternate_screen()?;
-/// let mut backend = TermionBackend::new(writer);
-/// // or
-/// let writer = stderr().into_raw_mode()?.into_alternate_screen()?;
-/// let backend = TermionBackend::new(stderr());
-/// let mut terminal = Terminal::new(backend)?;
-///
-/// terminal.clear()?;
-/// terminal.draw(|frame| {
-///     // -- snip --
-/// })?;
-/// # std::io::Result::Ok(())
+/// # fn main() -> Result<(), Box<dyn std::error::Error>> {
+/// let stdout = std::io::stdout();
+/// let mut backend = TermionBackend::new(stdout);
+/// backend.clear()?;
+/// # Ok(())
+/// # }
 /// ```
-///
-/// [`IntoRawMode::into_raw_mode()`]: termion::raw::IntoRawMode
-/// [`IntoAlternateScreen::into_alternate_screen()`]: termion::screen::IntoAlternateScreen
-/// [`Terminal`]: crate::terminal::Terminal
-/// [Termion]: https://docs.rs/termion
-#[derive(Debug, Default, Clone, Eq, PartialEq, Hash)]
+#[derive(Debug, Default, Clone)]
 pub struct TermionBackend<W>
 where
     W: Write,
 {
-    writer: W,
+    stdout: W,
 }
 
 impl<W> TermionBackend<W>
 where
     W: Write,
 {
-    /// Creates a new Termion backend with the given writer.
-    ///
-    /// # Example
-    ///
-    /// ```rust,no_run
-    /// # use std::io::stdout;
-    /// # use ratatui::prelude::*;
-    /// let backend = TermionBackend::new(stdout());
-    /// ```
-    pub fn new(writer: W) -> TermionBackend<W> {
-        TermionBackend { writer }
+    /// Creates a new Termion backend with the given output.
+    pub fn new(stdout: W) -> TermionBackend<W> {
+        TermionBackend { stdout }
     }
 }
 
@@ -89,11 +54,11 @@ where
     W: Write,
 {
     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        self.writer.write(buf)
+        self.stdout.write(buf)
     }
 
     fn flush(&mut self) -> io::Result<()> {
-        self.writer.flush()
+        self.stdout.flush()
     }
 }
 
@@ -107,39 +72,39 @@ where
 
     fn clear_region(&mut self, clear_type: ClearType) -> io::Result<()> {
         match clear_type {
-            ClearType::All => write!(self.writer, "{}", termion::clear::All)?,
-            ClearType::AfterCursor => write!(self.writer, "{}", termion::clear::AfterCursor)?,
-            ClearType::BeforeCursor => write!(self.writer, "{}", termion::clear::BeforeCursor)?,
-            ClearType::CurrentLine => write!(self.writer, "{}", termion::clear::CurrentLine)?,
-            ClearType::UntilNewLine => write!(self.writer, "{}", termion::clear::UntilNewline)?,
+            ClearType::All => write!(self.stdout, "{}", termion::clear::All)?,
+            ClearType::AfterCursor => write!(self.stdout, "{}", termion::clear::AfterCursor)?,
+            ClearType::BeforeCursor => write!(self.stdout, "{}", termion::clear::BeforeCursor)?,
+            ClearType::CurrentLine => write!(self.stdout, "{}", termion::clear::CurrentLine)?,
+            ClearType::UntilNewLine => write!(self.stdout, "{}", termion::clear::UntilNewline)?,
         };
-        self.writer.flush()
+        self.stdout.flush()
     }
 
     fn append_lines(&mut self, n: u16) -> io::Result<()> {
         for _ in 0..n {
-            writeln!(self.writer)?;
+            writeln!(self.stdout)?;
         }
-        self.writer.flush()
+        self.stdout.flush()
     }
 
     fn hide_cursor(&mut self) -> io::Result<()> {
-        write!(self.writer, "{}", termion::cursor::Hide)?;
-        self.writer.flush()
+        write!(self.stdout, "{}", termion::cursor::Hide)?;
+        self.stdout.flush()
     }
 
     fn show_cursor(&mut self) -> io::Result<()> {
-        write!(self.writer, "{}", termion::cursor::Show)?;
-        self.writer.flush()
+        write!(self.stdout, "{}", termion::cursor::Show)?;
+        self.stdout.flush()
     }
 
     fn get_cursor(&mut self) -> io::Result<(u16, u16)> {
-        termion::cursor::DetectCursorPos::cursor_pos(&mut self.writer).map(|(x, y)| (x - 1, y - 1))
+        termion::cursor::DetectCursorPos::cursor_pos(&mut self.stdout).map(|(x, y)| (x - 1, y - 1))
     }
 
     fn set_cursor(&mut self, x: u16, y: u16) -> io::Result<()> {
-        write!(self.writer, "{}", termion::cursor::Goto(x + 1, y + 1))?;
-        self.writer.flush()
+        write!(self.stdout, "{}", termion::cursor::Goto(x + 1, y + 1))?;
+        self.stdout.flush()
     }
 
     fn draw<'a, I>(&mut self, content: I) -> io::Result<()>
@@ -179,10 +144,10 @@ where
                 write!(string, "{}", Bg(cell.bg)).unwrap();
                 bg = cell.bg;
             }
-            string.push_str(cell.symbol());
+            string.push_str(&cell.symbol);
         }
         write!(
-            self.writer,
+            self.stdout,
             "{string}{}{}{}",
             Fg(Color::Reset),
             Bg(Color::Reset),
@@ -195,27 +160,20 @@ where
         Ok(Rect::new(0, 0, terminal.0, terminal.1))
     }
 
-    fn window_size(&mut self) -> Result<WindowSize, io::Error> {
-        Ok(WindowSize {
-            columns_rows: termion::terminal_size()?.into(),
-            pixels: termion::terminal_size_pixels()?.into(),
-        })
-    }
-
     fn flush(&mut self) -> io::Result<()> {
-        self.writer.flush()
+        self.stdout.flush()
     }
 }
-#[derive(Debug, Default, Clone, Copy, Eq, PartialEq, Hash)]
+#[derive(Debug, Default, Clone, Copy)]
 struct Fg(Color);
 
-#[derive(Debug, Default, Clone, Copy, Eq, PartialEq, Hash)]
+#[derive(Debug, Default, Clone, Copy)]
 struct Bg(Color);
 
 /// The `ModifierDiff` struct is used to calculate the difference between two `Modifier`
 /// values. This is useful when updating the terminal display, as it allows for more
 /// efficient updates by only sending the necessary changes.
-#[derive(Debug, Default, Clone, Copy, Eq, PartialEq, Hash)]
+#[derive(Debug, Default, Clone, Copy)]
 struct ModifierDiff {
     from: Modifier,
     to: Modifier,

src/backend/termwiz.rs

@@ -1,9 +1,8 @@
-//! This module provides the `TermwizBackend` implementation for the [`Backend`] trait. It uses the
-//! [Termwiz] crate to interact with the terminal.
+//! This module provides the `TermwizBackend` implementation for the [`Backend`] trait.
+//! It uses the `termwiz` crate to interact with the terminal.
 //!
 //! [`Backend`]: trait.Backend.html
 //! [`TermwizBackend`]: crate::backend::TermionBackend
-//! [Termwiz]: https://crates.io/crates/termwiz
 
 use std::{error::Error, io};
 
@@ -12,78 +11,34 @@ use termwiz::{
     cell::{AttributeChange, Blink, Intensity, Underline},
     color::{AnsiColor, ColorAttribute, SrgbaTuple},
     surface::{Change, CursorVisibility, Position},
-    terminal::{buffered::BufferedTerminal, ScreenSize, SystemTerminal, Terminal},
+    terminal::{buffered::BufferedTerminal, SystemTerminal, Terminal},
 };
 
 use crate::{
-    backend::{Backend, WindowSize},
+    backend::Backend,
     buffer::Cell,
-    layout::Size,
-    prelude::Rect,
+    layout::Rect,
     style::{Color, Modifier},
 };
 
-/// A [`Backend`] implementation that uses [Termwiz] to render to the terminal.
-///
-/// The `TermwizBackend` struct is a wrapper around a [`BufferedTerminal`], which is used to send
-/// commands to the terminal. It provides methods for drawing content, manipulating the cursor, and
-/// clearing the terminal screen.
-///
-/// Most applications should not call the methods on `TermwizBackend` directly, but will instead
-/// use the [`Terminal`] struct, which provides a more ergonomic interface.
-///
-/// This backend automatically enables raw mode and switches to the alternate screen when it is
-/// created using the [`TermwizBackend::new`] method (and disables raw mode and returns to the main
-/// screen when dropped). Use the [`TermwizBackend::with_buffered_terminal`] to create a new
-/// instance with a custom [`BufferedTerminal`] if this is not desired.
-///
+/// Termwiz backend implementation for the [`Backend`] trait.
 /// # Example
 ///
 /// ```rust,no_run
-/// use ratatui::prelude::*;
+/// use ratatui::backend::{Backend, TermwizBackend};
 ///
-/// let backend = TermwizBackend::new()?;
-/// let mut terminal = Terminal::new(backend)?;
-///
-/// terminal.clear()?;
-/// terminal.draw(|frame| {
-///     // -- snip --
-/// })?;
-/// # std::result::Result::Ok::<(), Box<dyn std::error::Error>>(())
+/// # fn main() -> Result<(), Box<dyn std::error::Error>> {
+/// let mut backend = TermwizBackend::new()?;
+/// backend.clear()?;
+/// # Ok(())
+/// # }
 /// ```
-///
-/// See the the [examples] directory for more examples. See the [`backend`] module documentation
-/// for more details on raw mode and alternate screen.
-///
-/// [`backend`]: crate::backend
-/// [`Terminal`]: crate::terminal::Terminal
-/// [`BufferedTerminal`]: termwiz::terminal::buffered::BufferedTerminal
-/// [Termwiz]: https://crates.io/crates/termwiz
-/// [examples]: https://github.com/ratatui-org/ratatui/tree/main/examples#readme
 pub struct TermwizBackend {
     buffered_terminal: BufferedTerminal<SystemTerminal>,
 }
 
 impl TermwizBackend {
     /// Creates a new Termwiz backend instance.
-    ///
-    /// The backend will automatically enable raw mode and enter the alternate screen.
-    ///
-    /// # Errors
-    ///
-    /// Returns an error if unable to do any of the following:
-    /// - query the terminal capabilities.
-    /// - enter raw mode.
-    /// - enter the alternate screen.
-    /// - create the system or buffered terminal.
-    ///
-    /// # Example
-    ///
-    /// ```rust,no_run
-    /// # use ratatui::prelude::*;
-    /// let backend = TermwizBackend::new()?;
-    /// # Ok::<(), Box<dyn std::error::Error>>(())
-    /// ```
     pub fn new() -> Result<TermwizBackend, Box<dyn Error>> {
         let mut buffered_terminal =
             BufferedTerminal::new(SystemTerminal::new(Capabilities::new_from_env()?)?)?;
@@ -176,7 +131,7 @@ impl Backend for TermwizBackend {
                     },
                 )));
 
-            self.buffered_terminal.add_change(cell.symbol());
+            self.buffered_terminal.add_change(&cell.symbol);
         }
         Ok(())
     }
@@ -214,31 +169,22 @@ impl Backend for TermwizBackend {
     }
 
     fn size(&self) -> Result<Rect, io::Error> {
-        let (cols, rows) = self.buffered_terminal.dimensions();
-        Ok(Rect::new(0, 0, u16_max(cols), u16_max(rows)))
-    }
-
-    fn window_size(&mut self) -> Result<WindowSize, io::Error> {
-        let ScreenSize {
-            cols,
-            rows,
-            xpixel,
-            ypixel,
-        } = self
-            .buffered_terminal
-            .terminal()
-            .get_screen_size()
-            .map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;
-        Ok(WindowSize {
-            columns_rows: Size {
-                width: u16_max(cols),
-                height: u16_max(rows),
+        let (term_width, term_height) = self.buffered_terminal.dimensions();
+        let max = u16::max_value();
+        Ok(Rect::new(
+            0,
+            0,
+            if term_width > usize::from(max) {
+                max
+            } else {
+                term_width as u16
             },
-            pixels: Size {
-                width: u16_max(xpixel),
-                height: u16_max(ypixel),
+            if term_height > usize::from(max) {
+                max
+            } else {
+                term_height as u16
             },
-        })
+        ))
     }
 
     fn flush(&mut self) -> Result<(), io::Error> {
@@ -275,8 +221,3 @@ impl From<Color> for ColorAttribute {
         }
     }
 }
-
-#[inline]
-fn u16_max(i: usize) -> u16 {
-    u16::try_from(i).unwrap_or(u16::MAX)
-}

src/backend/test.rs

@@ -9,31 +9,26 @@ use std::{
 use unicode_width::UnicodeWidthStr;
 
 use crate::{
-    backend::{Backend, ClearType, WindowSize},
+    backend::Backend,
     buffer::{Buffer, Cell},
-    layout::{Rect, Size},
+    layout::Rect,
 };
 
-/// A [`Backend`] implementation used for integration testing that that renders to an in memory
-/// buffer.
-///
-/// Note: that although many of the integration and unit tests in ratatui are written using this
-/// backend, it is preferable to write unit tests for widgets directly against the buffer rather
-/// than using this backend. This backend is intended for integration tests that test the entire
-/// terminal UI.
+/// A backend used for the integration tests.
 ///
 /// # Example
 ///
 /// ```rust
-/// use ratatui::{backend::TestBackend, prelude::*};
+/// use ratatui::{backend::{Backend, TestBackend}, buffer::Buffer};
 ///
+/// # fn main() -> Result<(), Box<dyn std::error::Error>> {
 /// let mut backend = TestBackend::new(10, 2);
 /// backend.clear()?;
 /// backend.assert_buffer(&Buffer::with_lines(vec!["          "; 2]));
-/// # std::io::Result::Ok(())
+/// # Ok(())
+/// # }
 /// ```
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[derive(Debug, Clone)]
 pub struct TestBackend {
     width: u16,
     buffer: Buffer,
@@ -56,11 +51,11 @@ fn buffer_view(buffer: &Buffer) -> String {
         view.push('"');
         for (x, c) in cells.iter().enumerate() {
             if skip == 0 {
-                view.push_str(c.symbol());
+                view.push_str(&c.symbol);
             } else {
-                overwritten.push((x, c.symbol()));
+                overwritten.push((x, &c.symbol));
             }
-            skip = std::cmp::max(skip, c.symbol().width()).saturating_sub(1);
+            skip = std::cmp::max(skip, c.symbol.width()).saturating_sub(1);
         }
         view.push('"');
         if !overwritten.is_empty() {
@@ -98,7 +93,6 @@ impl TestBackend {
     /// Asserts that the TestBackend's buffer is equal to the expected buffer.
     /// If the buffers are not equal, a panic occurs with a detailed error message
     /// showing the differences between the expected and actual buffers.
-    #[track_caller]
     pub fn assert_buffer(&self, expected: &Buffer) {
         assert_eq!(expected.area, self.buffer.area);
         let diff = expected.diff(&self.buffer);
@@ -179,506 +173,11 @@ impl Backend for TestBackend {
         Ok(())
     }
 
-    fn clear_region(&mut self, clear_type: super::ClearType) -> io::Result<()> {
-        match clear_type {
-            ClearType::All => self.clear()?,
-            ClearType::AfterCursor => {
-                let index = self.buffer.index_of(self.pos.0, self.pos.1) + 1;
-                self.buffer.content[index..].fill(Cell::default());
-            }
-            ClearType::BeforeCursor => {
-                let index = self.buffer.index_of(self.pos.0, self.pos.1);
-                self.buffer.content[..index].fill(Cell::default());
-            }
-            ClearType::CurrentLine => {
-                let line_start_index = self.buffer.index_of(0, self.pos.1);
-                let line_end_index = self.buffer.index_of(self.width - 1, self.pos.1);
-                self.buffer.content[line_start_index..=line_end_index].fill(Cell::default());
-            }
-            ClearType::UntilNewLine => {
-                let index = self.buffer.index_of(self.pos.0, self.pos.1);
-                let line_end_index = self.buffer.index_of(self.width - 1, self.pos.1);
-                self.buffer.content[index..=line_end_index].fill(Cell::default());
-            }
-        }
-        Ok(())
-    }
-
-    /// Inserts n line breaks at the current cursor position.
-    ///
-    /// After the insertion, the cursor x position will be incremented by 1 (unless it's already
-    /// at the end of line). This is a common behaviour of terminals in raw mode.
-    ///
-    /// If the number of lines to append is fewer than the number of lines in the buffer after the
-    /// cursor y position then the cursor is moved down by n rows.
-    ///
-    /// If the number of lines to append is greater than the number of lines in the buffer after
-    /// the cursor y position then that number of empty lines (at most the buffer's height in this
-    /// case but this limit is instead replaced with scrolling in most backend implementations) will
-    /// be added after the current position and the cursor will be moved to the last row.
-    fn append_lines(&mut self, n: u16) -> io::Result<()> {
-        let (cur_x, cur_y) = self.get_cursor()?;
-
-        // the next column ensuring that we don't go past the last column
-        let new_cursor_x = cur_x.saturating_add(1).min(self.width.saturating_sub(1));
-
-        let max_y = self.height.saturating_sub(1);
-        let lines_after_cursor = max_y.saturating_sub(cur_y);
-        if n > lines_after_cursor {
-            let rotate_by = n.saturating_sub(lines_after_cursor).min(max_y);
-
-            if rotate_by == self.height - 1 {
-                self.clear()?;
-            }
-
-            self.set_cursor(0, rotate_by)?;
-            self.clear_region(ClearType::BeforeCursor)?;
-            self.buffer
-                .content
-                .rotate_left((self.width * rotate_by).into());
-        }
-
-        let new_cursor_y = cur_y.saturating_add(n).min(max_y);
-        self.set_cursor(new_cursor_x, new_cursor_y)?;
-
-        Ok(())
-    }
-
     fn size(&self) -> Result<Rect, io::Error> {
         Ok(Rect::new(0, 0, self.width, self.height))
     }
 
-    fn window_size(&mut self) -> Result<WindowSize, io::Error> {
-        // Some arbitrary window pixel size, probably doesn't need much testing.
-        static WINDOW_PIXEL_SIZE: Size = Size {
-            width: 640,
-            height: 480,
-        };
-        Ok(WindowSize {
-            columns_rows: (self.width, self.height).into(),
-            pixels: WINDOW_PIXEL_SIZE,
-        })
-    }
-
     fn flush(&mut self) -> Result<(), io::Error> {
         Ok(())
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn new() {
-        assert_eq!(
-            TestBackend::new(10, 2),
-            TestBackend {
-                width: 10,
-                height: 2,
-                buffer: Buffer::with_lines(vec!["          "; 2]),
-                cursor: false,
-                pos: (0, 0),
-            }
-        );
-    }
-    #[test]
-    fn test_buffer_view() {
-        let buffer = Buffer::with_lines(vec!["aaaa"; 2]);
-        assert_eq!(buffer_view(&buffer), "\"aaaa\"\n\"aaaa\"\n");
-    }
-
-    #[test]
-    fn buffer_view_with_overwrites() {
-        let multi_byte_char = "👨‍👩‍👧‍👦"; // renders 8 wide
-        let buffer = Buffer::with_lines(vec![multi_byte_char]);
-        assert_eq!(
-            buffer_view(&buffer),
-            format!(
-                r#""{multi_byte_char}" Hidden by multi-width symbols: [(1, " "), (2, " "), (3, " "), (4, " "), (5, " "), (6, " "), (7, " ")]
-"#,
-                multi_byte_char = multi_byte_char
-            )
-        );
-    }
-
-    #[test]
-    fn buffer() {
-        let backend = TestBackend::new(10, 2);
-        assert_eq!(backend.buffer(), &Buffer::with_lines(vec!["          "; 2]));
-    }
-
-    #[test]
-    fn resize() {
-        let mut backend = TestBackend::new(10, 2);
-        backend.resize(5, 5);
-        assert_eq!(backend.buffer(), &Buffer::with_lines(vec!["     "; 5]));
-    }
-
-    #[test]
-    fn assert_buffer() {
-        let backend = TestBackend::new(10, 2);
-        let buffer = Buffer::with_lines(vec!["          "; 2]);
-        backend.assert_buffer(&buffer);
-    }
-
-    #[test]
-    #[should_panic]
-    fn assert_buffer_panics() {
-        let backend = TestBackend::new(10, 2);
-        let buffer = Buffer::with_lines(vec!["aaaaaaaaaa"; 2]);
-        backend.assert_buffer(&buffer);
-    }
-
-    #[test]
-    fn display() {
-        let backend = TestBackend::new(10, 2);
-        assert_eq!(format!("{}", backend), "\"          \"\n\"          \"\n");
-    }
-
-    #[test]
-    fn draw() {
-        let mut backend = TestBackend::new(10, 2);
-        let mut cell = Cell::default();
-        cell.set_symbol("a");
-        backend.draw([(0, 0, &cell)].into_iter()).unwrap();
-        backend.draw([(0, 1, &cell)].into_iter()).unwrap();
-        backend.assert_buffer(&Buffer::with_lines(vec!["a         "; 2]));
-    }
-
-    #[test]
-    fn hide_cursor() {
-        let mut backend = TestBackend::new(10, 2);
-        backend.hide_cursor().unwrap();
-        assert!(!backend.cursor);
-    }
-
-    #[test]
-    fn show_cursor() {
-        let mut backend = TestBackend::new(10, 2);
-        backend.show_cursor().unwrap();
-        assert!(backend.cursor);
-    }
-
-    #[test]
-    fn get_cursor() {
-        let mut backend = TestBackend::new(10, 2);
-        assert_eq!(backend.get_cursor().unwrap(), (0, 0));
-    }
-
-    #[test]
-    fn set_cursor() {
-        let mut backend = TestBackend::new(10, 10);
-        backend.set_cursor(5, 5).unwrap();
-        assert_eq!(backend.pos, (5, 5));
-    }
-
-    #[test]
-    fn clear() {
-        let mut backend = TestBackend::new(10, 4);
-        let mut cell = Cell::default();
-        cell.set_symbol("a");
-        backend.draw([(0, 0, &cell)].into_iter()).unwrap();
-        backend.draw([(0, 1, &cell)].into_iter()).unwrap();
-        backend.clear().unwrap();
-        backend.assert_buffer(&Buffer::with_lines(vec![
-            "          ",
-            "          ",
-            "          ",
-            "          ",
-        ]));
-    }
-
-    #[test]
-    fn clear_region_all() {
-        let mut backend = TestBackend::new(10, 5);
-        backend.buffer = Buffer::with_lines(vec![
-            "aaaaaaaaaa",
-            "aaaaaaaaaa",
-            "aaaaaaaaaa",
-            "aaaaaaaaaa",
-            "aaaaaaaaaa",
-        ]);
-
-        backend.clear_region(ClearType::All).unwrap();
-        backend.assert_buffer(&Buffer::with_lines(vec![
-            "          ",
-            "          ",
-            "          ",
-            "          ",
-            "          ",
-        ]));
-    }
-
-    #[test]
-    fn clear_region_after_cursor() {
-        let mut backend = TestBackend::new(10, 5);
-        backend.buffer = Buffer::with_lines(vec![
-            "aaaaaaaaaa",
-            "aaaaaaaaaa",
-            "aaaaaaaaaa",
-            "aaaaaaaaaa",
-            "aaaaaaaaaa",
-        ]);
-
-        backend.set_cursor(3, 2).unwrap();
-        backend.clear_region(ClearType::AfterCursor).unwrap();
-        backend.assert_buffer(&Buffer::with_lines(vec![
-            "aaaaaaaaaa",
-            "aaaaaaaaaa",
-            "aaaa      ",
-            "          ",
-            "          ",
-        ]));
-    }
-
-    #[test]
-    fn clear_region_before_cursor() {
-        let mut backend = TestBackend::new(10, 5);
-        backend.buffer = Buffer::with_lines(vec![
-            "aaaaaaaaaa",
-            "aaaaaaaaaa",
-            "aaaaaaaaaa",
-            "aaaaaaaaaa",
-            "aaaaaaaaaa",
-        ]);
-
-        backend.set_cursor(5, 3).unwrap();
-        backend.clear_region(ClearType::BeforeCursor).unwrap();
-        backend.assert_buffer(&Buffer::with_lines(vec![
-            "          ",
-            "          ",
-            "          ",
-            "     aaaaa",
-            "aaaaaaaaaa",
-        ]));
-    }
-
-    #[test]
-    fn clear_region_current_line() {
-        let mut backend = TestBackend::new(10, 5);
-        backend.buffer = Buffer::with_lines(vec![
-            "aaaaaaaaaa",
-            "aaaaaaaaaa",
-            "aaaaaaaaaa",
-            "aaaaaaaaaa",
-            "aaaaaaaaaa",
-        ]);
-
-        backend.set_cursor(3, 1).unwrap();
-        backend.clear_region(ClearType::CurrentLine).unwrap();
-        backend.assert_buffer(&Buffer::with_lines(vec![
-            "aaaaaaaaaa",
-            "          ",
-            "aaaaaaaaaa",
-            "aaaaaaaaaa",
-            "aaaaaaaaaa",
-        ]));
-    }
-
-    #[test]
-    fn clear_region_until_new_line() {
-        let mut backend = TestBackend::new(10, 5);
-        backend.buffer = Buffer::with_lines(vec![
-            "aaaaaaaaaa",
-            "aaaaaaaaaa",
-            "aaaaaaaaaa",
-            "aaaaaaaaaa",
-            "aaaaaaaaaa",
-        ]);
-
-        backend.set_cursor(3, 0).unwrap();
-        backend.clear_region(ClearType::UntilNewLine).unwrap();
-        backend.assert_buffer(&Buffer::with_lines(vec![
-            "aaa       ",
-            "aaaaaaaaaa",
-            "aaaaaaaaaa",
-            "aaaaaaaaaa",
-            "aaaaaaaaaa",
-        ]));
-    }
-
-    #[test]
-    fn append_lines_not_at_last_line() {
-        let mut backend = TestBackend::new(10, 5);
-        backend.buffer = Buffer::with_lines(vec![
-            "aaaaaaaaaa",
-            "bbbbbbbbbb",
-            "cccccccccc",
-            "dddddddddd",
-            "eeeeeeeeee",
-        ]);
-
-        backend.set_cursor(0, 0).unwrap();
-
-        // If the cursor is not at the last line in the terminal the addition of a
-        // newline simply moves the cursor down and to the right
-
-        backend.append_lines(1).unwrap();
-        assert_eq!(backend.get_cursor().unwrap(), (1, 1));
-
-        backend.append_lines(1).unwrap();
-        assert_eq!(backend.get_cursor().unwrap(), (2, 2));
-
-        backend.append_lines(1).unwrap();
-        assert_eq!(backend.get_cursor().unwrap(), (3, 3));
-
-        backend.append_lines(1).unwrap();
-        assert_eq!(backend.get_cursor().unwrap(), (4, 4));
-
-        // As such the buffer should remain unchanged
-        backend.assert_buffer(&Buffer::with_lines(vec![
-            "aaaaaaaaaa",
-            "bbbbbbbbbb",
-            "cccccccccc",
-            "dddddddddd",
-            "eeeeeeeeee",
-        ]));
-    }
-
-    #[test]
-    fn append_lines_at_last_line() {
-        let mut backend = TestBackend::new(10, 5);
-        backend.buffer = Buffer::with_lines(vec![
-            "aaaaaaaaaa",
-            "bbbbbbbbbb",
-            "cccccccccc",
-            "dddddddddd",
-            "eeeeeeeeee",
-        ]);
-
-        // If the cursor is at the last line in the terminal the addition of a
-        // newline will scroll the contents of the buffer
-        backend.set_cursor(0, 4).unwrap();
-
-        backend.append_lines(1).unwrap();
-
-        backend.buffer = Buffer::with_lines(vec![
-            "bbbbbbbbbb",
-            "cccccccccc",
-            "dddddddddd",
-            "eeeeeeeeee",
-            "          ",
-        ]);
-
-        // It also moves the cursor to the right, as is common of the behaviour of
-        // terminals in raw-mode
-        assert_eq!(backend.get_cursor().unwrap(), (1, 4));
-    }
-
-    #[test]
-    fn append_multiple_lines_not_at_last_line() {
-        let mut backend = TestBackend::new(10, 5);
-        backend.buffer = Buffer::with_lines(vec![
-            "aaaaaaaaaa",
-            "bbbbbbbbbb",
-            "cccccccccc",
-            "dddddddddd",
-            "eeeeeeeeee",
-        ]);
-
-        backend.set_cursor(0, 0).unwrap();
-
-        // If the cursor is not at the last line in the terminal the addition of multiple
-        // newlines simply moves the cursor n lines down and to the right by 1
-
-        backend.append_lines(4).unwrap();
-        assert_eq!(backend.get_cursor().unwrap(), (1, 4));
-
-        // As such the buffer should remain unchanged
-        backend.assert_buffer(&Buffer::with_lines(vec![
-            "aaaaaaaaaa",
-            "bbbbbbbbbb",
-            "cccccccccc",
-            "dddddddddd",
-            "eeeeeeeeee",
-        ]));
-    }
-
-    #[test]
-    fn append_multiple_lines_past_last_line() {
-        let mut backend = TestBackend::new(10, 5);
-        backend.buffer = Buffer::with_lines(vec![
-            "aaaaaaaaaa",
-            "bbbbbbbbbb",
-            "cccccccccc",
-            "dddddddddd",
-            "eeeeeeeeee",
-        ]);
-
-        backend.set_cursor(0, 3).unwrap();
-
-        backend.append_lines(3).unwrap();
-        assert_eq!(backend.get_cursor().unwrap(), (1, 4));
-
-        backend.assert_buffer(&Buffer::with_lines(vec![
-            "cccccccccc",
-            "dddddddddd",
-            "eeeeeeeeee",
-            "          ",
-            "          ",
-        ]));
-    }
-
-    #[test]
-    fn append_multiple_lines_where_cursor_at_end_appends_height_lines() {
-        let mut backend = TestBackend::new(10, 5);
-        backend.buffer = Buffer::with_lines(vec![
-            "aaaaaaaaaa",
-            "bbbbbbbbbb",
-            "cccccccccc",
-            "dddddddddd",
-            "eeeeeeeeee",
-        ]);
-
-        backend.set_cursor(0, 4).unwrap();
-
-        backend.append_lines(5).unwrap();
-        assert_eq!(backend.get_cursor().unwrap(), (1, 4));
-
-        backend.assert_buffer(&Buffer::with_lines(vec![
-            "          ",
-            "          ",
-            "          ",
-            "          ",
-            "          ",
-        ]));
-    }
-
-    #[test]
-    fn append_multiple_lines_where_cursor_appends_height_lines() {
-        let mut backend = TestBackend::new(10, 5);
-        backend.buffer = Buffer::with_lines(vec![
-            "aaaaaaaaaa",
-            "bbbbbbbbbb",
-            "cccccccccc",
-            "dddddddddd",
-            "eeeeeeeeee",
-        ]);
-
-        backend.set_cursor(0, 0).unwrap();
-
-        backend.append_lines(5).unwrap();
-        assert_eq!(backend.get_cursor().unwrap(), (1, 4));
-
-        backend.assert_buffer(&Buffer::with_lines(vec![
-            "bbbbbbbbbb",
-            "cccccccccc",
-            "dddddddddd",
-            "eeeeeeeeee",
-            "          ",
-        ]));
-    }
-
-    #[test]
-    fn size() {
-        let backend = TestBackend::new(10, 2);
-        assert_eq!(backend.size().unwrap(), Rect::new(0, 0, 10, 2));
-    }
-
-    #[test]
-    fn flush() {
-        let mut backend = TestBackend::new(10, 2);
-        backend.flush().unwrap();
-    }
-}

src/buffer.rs

@@ -6,37 +6,25 @@ use std::{
 use unicode_segmentation::UnicodeSegmentation;
 use unicode_width::UnicodeWidthStr;
 
+#[allow(deprecated)]
 use crate::{
     layout::Rect,
     style::{Color, Modifier, Style},
-    text::{Line, Span},
+    text::{Line, Span, Spans},
 };
 
 /// A buffer cell
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[derive(Debug, Clone, Eq, PartialEq)]
 pub struct Cell {
-    #[deprecated(
-        since = "0.24.1",
-        note = "This field will be hidden at next major version. Use `Cell::symbol` method to get \
-                the value. Use `Cell::set_symbol` to update the field. Use `Cell::default` to \
-                create `Cell` instance"
-    )]
     pub symbol: String,
     pub fg: Color,
     pub bg: Color,
-    #[cfg(feature = "underline-color")]
+    #[cfg(feature = "crossterm")]
     pub underline_color: Color,
     pub modifier: Modifier,
-    pub skip: bool,
 }
 
-#[allow(deprecated)] // For Cell::symbol
 impl Cell {
-    pub fn symbol(&self) -> &str {
-        self.symbol.as_str()
-    }
-
     pub fn set_symbol(&mut self, symbol: &str) -> &mut Cell {
         self.symbol.clear();
         self.symbol.push_str(symbol);
@@ -66,7 +54,7 @@ impl Cell {
         if let Some(c) = style.bg {
             self.bg = c;
         }
-        #[cfg(feature = "underline-color")]
+        #[cfg(feature = "crossterm")]
         if let Some(c) = style.underline_color {
             self.underline_color = c;
         }
@@ -75,7 +63,7 @@ impl Cell {
         self
     }
 
-    #[cfg(feature = "underline-color")]
+    #[cfg(feature = "crossterm")]
     pub fn style(&self) -> Style {
         Style::default()
             .fg(self.fg)
@@ -84,7 +72,7 @@ impl Cell {
             .add_modifier(self.modifier)
     }
 
-    #[cfg(not(feature = "underline-color"))]
+    #[cfg(not(feature = "crossterm"))]
     pub fn style(&self) -> Style {
         Style::default()
             .fg(self.fg)
@@ -92,40 +80,28 @@ impl Cell {
             .add_modifier(self.modifier)
     }
 
-    /// Sets the cell to be skipped when copying (diffing) the buffer to the screen.
-    ///
-    /// This is helpful when it is necessary to prevent the buffer from overwriting a cell that is
-    /// covered by an image from some terminal graphics protocol (Sixel / iTerm / Kitty ...).
-    pub fn set_skip(&mut self, skip: bool) -> &mut Cell {
-        self.skip = skip;
-        self
-    }
-
     pub fn reset(&mut self) {
         self.symbol.clear();
         self.symbol.push(' ');
         self.fg = Color::Reset;
         self.bg = Color::Reset;
-        #[cfg(feature = "underline-color")]
+        #[cfg(feature = "crossterm")]
         {
             self.underline_color = Color::Reset;
         }
         self.modifier = Modifier::empty();
-        self.skip = false;
     }
 }
 
 impl Default for Cell {
     fn default() -> Cell {
-        #[allow(deprecated)] // For Cell::symbol
         Cell {
             symbol: " ".into(),
             fg: Color::Reset,
             bg: Color::Reset,
-            #[cfg(feature = "underline-color")]
+            #[cfg(feature = "crossterm")]
             underline_color: Color::Reset,
             modifier: Modifier::empty(),
-            skip: false,
         }
     }
 }
@@ -140,23 +116,26 @@ impl Default for Cell {
 /// # Examples:
 ///
 /// ```
-/// use ratatui::{prelude::*, buffer::Cell};
+/// use ratatui::buffer::{Buffer, Cell};
+/// use ratatui::layout::Rect;
+/// use ratatui::style::{Color, Style, Modifier};
 ///
 /// 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");
-///
+/// assert_eq!(buf.get(0, 2).symbol, "x");
 /// buf.set_string(3, 0, "string", Style::default().fg(Color::Red).bg(Color::White));
-/// let cell = buf.get_mut(5, 0);
-/// assert_eq!(cell.symbol(), "r");
-/// assert_eq!(cell.fg, Color::Red);
-/// assert_eq!(cell.bg, Color::White);
-///
+/// assert_eq!(buf.get(5, 0), &Cell{
+///     symbol: String::from("r"),
+///     fg: Color::Red,
+///     bg: Color::White,
+///     #[cfg(feature = "crossterm")]
+///     underline_color: Color::Reset,
+///     modifier: Modifier::empty()
+/// });
 /// buf.get_mut(5, 0).set_char('x');
-/// assert_eq!(buf.get(5, 0).symbol(), "x");
+/// assert_eq!(buf.get(5, 0).symbol, "x");
 /// ```
-#[derive(Default, Clone, Eq, PartialEq, Hash)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[derive(Default, Clone, Eq, PartialEq)]
 pub struct Buffer {
     /// The area represented by this buffer
     pub area: Rect,
@@ -183,16 +162,24 @@ impl Buffer {
     }
 
     /// Returns a Buffer containing the given lines
-    pub fn with_lines<'a, S>(lines: Vec<S>) -> Buffer
+    pub fn with_lines<S>(lines: Vec<S>) -> Buffer
     where
-        S: Into<Line<'a>>,
+        S: AsRef<str>,
     {
-        let lines = lines.into_iter().map(Into::into).collect::<Vec<_>>();
         let height = lines.len() as u16;
-        let width = lines.iter().map(Line::width).max().unwrap_or_default() as u16;
-        let mut buffer = Buffer::empty(Rect::new(0, 0, width, height));
+        let width = lines
+            .iter()
+            .map(|i| i.as_ref().width() as u16)
+            .max()
+            .unwrap_or_default();
+        let mut buffer = Buffer::empty(Rect {
+            x: 0,
+            y: 0,
+            width,
+            height,
+        });
         for (y, line) in lines.iter().enumerate() {
-            buffer.set_line(0, y as u16, line, width);
+            buffer.set_string(0, y as u16, line, Style::default());
         }
         buffer
     }
@@ -226,7 +213,8 @@ impl Buffer {
     /// # Examples
     ///
     /// ```
-    /// # use ratatui::prelude::*;
+    /// # use ratatui::buffer::Buffer;
+    /// # use ratatui::layout::Rect;
     /// let rect = Rect::new(200, 100, 10, 10);
     /// let buffer = Buffer::empty(rect);
     /// // Global coordinates to the top corner of this buffer's area
@@ -238,7 +226,8 @@ impl Buffer {
     /// Panics when given an coordinate that is outside of this Buffer's area.
     ///
     /// ```should_panic
-    /// # use ratatui::prelude::*;
+    /// # use ratatui::buffer::Buffer;
+    /// # use ratatui::layout::Rect;
     /// let rect = Rect::new(200, 100, 10, 10);
     /// let buffer = Buffer::empty(rect);
     /// // Top coordinate is outside of the buffer in global coordinate space, as the Buffer's area
@@ -264,7 +253,8 @@ impl Buffer {
     /// # Examples
     ///
     /// ```
-    /// # use ratatui::prelude::*;
+    /// # use ratatui::buffer::Buffer;
+    /// # use ratatui::layout::Rect;
     /// let rect = Rect::new(200, 100, 10, 10);
     /// let buffer = Buffer::empty(rect);
     /// assert_eq!(buffer.pos_of(0), (200, 100));
@@ -276,7 +266,8 @@ impl Buffer {
     /// Panics when given an index that is outside the Buffer's content.
     ///
     /// ```should_panic
-    /// # use ratatui::prelude::*;
+    /// # use ratatui::buffer::Buffer;
+    /// # use ratatui::layout::Rect;
     /// let rect = Rect::new(0, 0, 10, 10); // 100 cells in total
     /// let buffer = Buffer::empty(rect);
     /// // Index 100 is the 101th cell, which lies outside of the area of this Buffer.
@@ -342,6 +333,29 @@ impl Buffer {
         (x_offset as u16, y)
     }
 
+    #[allow(deprecated)]
+    #[deprecated(note = "Use `Buffer::set_line` instead")]
+    pub fn set_spans(&mut self, x: u16, y: u16, spans: &Spans<'_>, 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_line(&mut self, x: u16, y: u16, line: &Line<'_>, width: u16) -> (u16, u16) {
         let mut remaining_width = width;
         let mut x = x;
@@ -472,17 +486,17 @@ impl Buffer {
         // Cells invalidated by drawing/replacing preceding multi-width characters:
         let mut invalidated: usize = 0;
         // Cells from the current buffer to skip due to preceding multi-width characters taking
-        // their place (the skipped cells should be blank anyway), or due to per-cell-skipping:
+        // their place (the skipped cells should be blank anyway):
         let mut to_skip: usize = 0;
         for (i, (current, previous)) in next_buffer.iter().zip(previous_buffer.iter()).enumerate() {
-            if !current.skip && (current != previous || invalidated > 0) && to_skip == 0 {
+            if (current != previous || invalidated > 0) && to_skip == 0 {
                 let (x, y) = self.pos_of(i);
                 updates.push((x, y, &next_buffer[i]));
             }
 
-            to_skip = current.symbol().width().saturating_sub(1);
+            to_skip = current.symbol.width().saturating_sub(1);
 
-            let affected_width = std::cmp::max(current.symbol().width(), previous.symbol().width());
+            let affected_width = std::cmp::max(current.symbol.width(), previous.symbol.width());
             invalidated = std::cmp::max(affected_width, invalidated).saturating_sub(1);
         }
         updates
@@ -564,12 +578,12 @@ impl Debug for Buffer {
             f.write_str("        \"")?;
             for (x, c) in line.iter().enumerate() {
                 if skip == 0 {
-                    f.write_str(c.symbol())?;
+                    f.write_str(&c.symbol)?;
                 } else {
-                    overwritten.push((x, c.symbol()));
+                    overwritten.push((x, &c.symbol));
                 }
-                skip = std::cmp::max(skip, c.symbol().width()).saturating_sub(1);
-                #[cfg(feature = "underline-color")]
+                skip = std::cmp::max(skip, c.symbol.width()).saturating_sub(1);
+                #[cfg(feature = "crossterm")]
                 {
                     let style = (c.fg, c.bg, c.underline_color, c.modifier);
                     if last_style != Some(style) {
@@ -577,7 +591,7 @@ impl Debug for Buffer {
                         styles.push((x, y, c.fg, c.bg, c.underline_color, c.modifier));
                     }
                 }
-                #[cfg(not(feature = "underline-color"))]
+                #[cfg(not(feature = "crossterm"))]
                 {
                     let style = (c.fg, c.bg, c.modifier);
                     if last_style != Some(style) {
@@ -595,12 +609,12 @@ impl Debug for Buffer {
         }
         f.write_str("    ],\n    styles: [\n")?;
         for s in styles {
-            #[cfg(feature = "underline-color")]
+            #[cfg(feature = "crossterm")]
             f.write_fmt(format_args!(
                 "        x: {}, y: {}, fg: {:?}, bg: {:?}, underline: {:?}, modifier: {:?},\n",
                 s.0, s.1, s.2, s.3, s.4, s.5
             ))?;
-            #[cfg(not(feature = "underline-color"))]
+            #[cfg(not(feature = "crossterm"))]
             f.write_fmt(format_args!(
                 "        x: {}, y: {}, fg: {:?}, bg: {:?}, modifier: {:?},\n",
                 s.0, s.1, s.2, s.3, s.4
@@ -634,7 +648,7 @@ mod tests {
                 .bg(Color::Yellow)
                 .add_modifier(Modifier::BOLD),
         );
-        #[cfg(feature = "underline-color")]
+        #[cfg(feature = "crossterm")]
         assert_eq!(
             format!("{buf:?}"),
             indoc::indoc!(
@@ -652,7 +666,7 @@ mod tests {
                 }"
             )
         );
-        #[cfg(not(feature = "underline-color"))]
+        #[cfg(not(feature = "crossterm"))]
         assert_eq!(
             format!("{buf:?}"),
             indoc::indoc!(
@@ -900,18 +914,6 @@ mod tests {
         );
     }
 
-    #[test]
-    fn buffer_diffing_skip() {
-        let prev = Buffer::with_lines(vec!["123"]);
-        let mut next = Buffer::with_lines(vec!["456"]);
-        for i in 1..3 {
-            next.content[i].set_skip(true);
-        }
-
-        let diff = prev.diff(&next);
-        assert_eq!(diff, vec![(0, 0, &cell("4"))],);
-    }
-
     #[test]
     fn buffer_merge() {
         let mut one = Buffer::filled(
@@ -993,73 +995,4 @@ mod tests {
         };
         assert_buffer_eq!(one, merged);
     }
-
-    #[test]
-    fn buffer_merge_skip() {
-        let mut one = Buffer::filled(
-            Rect {
-                x: 0,
-                y: 0,
-                width: 2,
-                height: 2,
-            },
-            Cell::default().set_symbol("1"),
-        );
-        let two = Buffer::filled(
-            Rect {
-                x: 0,
-                y: 1,
-                width: 2,
-                height: 2,
-            },
-            Cell::default().set_symbol("2").set_skip(true),
-        );
-        one.merge(&two);
-        let skipped: Vec<bool> = one.content().iter().map(|c| c.skip).collect();
-        assert_eq!(skipped, vec![false, false, true, true, true, true]);
-    }
-
-    #[test]
-    fn buffer_merge_skip2() {
-        let mut one = Buffer::filled(
-            Rect {
-                x: 0,
-                y: 0,
-                width: 2,
-                height: 2,
-            },
-            Cell::default().set_symbol("1").set_skip(true),
-        );
-        let two = Buffer::filled(
-            Rect {
-                x: 0,
-                y: 1,
-                width: 2,
-                height: 2,
-            },
-            Cell::default().set_symbol("2"),
-        );
-        one.merge(&two);
-        let skipped: Vec<bool> = one.content().iter().map(|c| c.skip).collect();
-        assert_eq!(skipped, vec![true, true, false, false, false, false]);
-    }
-
-    #[test]
-    fn with_lines_accepts_into_lines() {
-        use crate::style::Stylize;
-        let mut buf = Buffer::empty(Rect::new(0, 0, 3, 2));
-        buf.set_string(0, 0, "foo", Style::new().red());
-        buf.set_string(0, 1, "bar", Style::new().blue());
-        assert_eq!(buf, Buffer::with_lines(vec!["foo".red(), "bar".blue()]));
-    }
-
-    #[test]
-    fn cell_symbol_field() {
-        let mut cell = Cell::default();
-        assert_eq!(cell.symbol(), " ");
-        cell.set_symbol("あ"); // Multi-byte character
-        assert_eq!(cell.symbol(), "あ");
-        cell.set_symbol("👨‍👩‍👧‍👦"); // Multiple code units combined with ZWJ
-        assert_eq!(cell.symbol(), "👨‍👩‍👧‍👦");
-    }
 }

src/layout/rect.rs

@@ -1,291 +0,0 @@
-#![warn(missing_docs)]
-use std::{
-    cmp::{max, min},
-    fmt,
-};
-
-use crate::prelude::*;
-
-/// A simple rectangle used in the computation of the layout and to give widgets a hint about the
-/// area they are supposed to render to.
-#[derive(Debug, Default, Clone, Copy, Eq, PartialEq, Hash)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
-pub struct Rect {
-    /// The x coordinate of the top left corner of the rect.
-    pub x: u16,
-    /// The y coordinate of the top left corner of the rect.
-    pub y: u16,
-    /// The width of the rect.
-    pub width: u16,
-    /// The height of the rect.
-    pub height: u16,
-}
-
-impl fmt::Display for Rect {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}x{}+{}+{}", self.width, self.height, self.x, self.y)
-    }
-}
-
-impl Rect {
-    /// Creates a new rect, with width and height limited to keep the area under max u16. If
-    /// clipped, aspect ratio will be preserved.
-    pub fn new(x: u16, y: u16, width: u16, height: u16) -> Rect {
-        let max_area = u16::max_value();
-        let (clipped_width, clipped_height) =
-            if u32::from(width) * u32::from(height) > u32::from(max_area) {
-                let aspect_ratio = f64::from(width) / f64::from(height);
-                let max_area_f = f64::from(max_area);
-                let height_f = (max_area_f / aspect_ratio).sqrt();
-                let width_f = height_f * aspect_ratio;
-                (width_f as u16, height_f as u16)
-            } else {
-                (width, height)
-            };
-        Rect {
-            x,
-            y,
-            width: clipped_width,
-            height: clipped_height,
-        }
-    }
-
-    /// The area of the rect. If the area is larger than the maximum value of u16, it will be
-    /// clamped to u16::MAX.
-    pub const fn area(self) -> u16 {
-        self.width.saturating_mul(self.height)
-    }
-
-    /// Returns true if the rect has no area.
-    pub const fn is_empty(self) -> bool {
-        self.width == 0 || self.height == 0
-    }
-
-    /// Returns the left coordinate of the rect.
-    pub const fn left(self) -> u16 {
-        self.x
-    }
-
-    /// Returns the right coordinate of the rect. This is the first coordinate outside of the rect.
-    ///
-    /// If the right coordinate is larger than the maximum value of u16, it will be clamped to
-    /// u16::MAX.
-    pub const fn right(self) -> u16 {
-        self.x.saturating_add(self.width)
-    }
-
-    /// Returns the top coordinate of the rect.
-    pub const fn top(self) -> u16 {
-        self.y
-    }
-
-    /// Returns the bottom coordinate of the rect. This is the first coordinate outside of the rect.
-    ///
-    /// If the bottom coordinate is larger than the maximum value of u16, it will be clamped to
-    /// u16::MAX.
-    pub const fn bottom(self) -> u16 {
-        self.y.saturating_add(self.height)
-    }
-
-    /// Returns a new rect inside the current one, with the given margin on each side.
-    ///
-    /// If the margin is larger than the rect, the returned rect will have no area.
-    pub fn inner(self, margin: &Margin) -> Rect {
-        let doubled_margin_horizontal = margin.horizontal.saturating_mul(2);
-        let doubled_margin_vertical = margin.vertical.saturating_mul(2);
-
-        if self.width < doubled_margin_horizontal || self.height < doubled_margin_vertical {
-            Rect::default()
-        } else {
-            Rect {
-                x: self.x.saturating_add(margin.horizontal),
-                y: self.y.saturating_add(margin.vertical),
-                width: self.width.saturating_sub(doubled_margin_horizontal),
-                height: self.height.saturating_sub(doubled_margin_vertical),
-            }
-        }
-    }
-
-    /// Returns a new rect that contains both the current one and the given one.
-    pub fn union(self, other: Rect) -> Rect {
-        let x1 = min(self.x, other.x);
-        let y1 = min(self.y, other.y);
-        let x2 = max(self.right(), other.right());
-        let y2 = max(self.bottom(), other.bottom());
-        Rect {
-            x: x1,
-            y: y1,
-            width: x2.saturating_sub(x1),
-            height: y2.saturating_sub(y1),
-        }
-    }
-
-    /// Returns a new rect that is the intersection of the current one and the given one.
-    ///
-    /// If the two rects do not intersect, the returned rect will have no area.
-    pub fn intersection(self, other: Rect) -> Rect {
-        let x1 = max(self.x, other.x);
-        let y1 = max(self.y, other.y);
-        let x2 = min(self.right(), other.right());
-        let y2 = min(self.bottom(), other.bottom());
-        Rect {
-            x: x1,
-            y: y1,
-            width: x2 - x1,
-            height: y2 - y1,
-        }
-    }
-
-    /// Returns true if the two rects intersect.
-    pub const fn intersects(self, other: Rect) -> bool {
-        self.x < other.right()
-            && self.right() > other.x
-            && self.y < other.bottom()
-            && self.bottom() > other.y
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn to_string() {
-        assert_eq!(Rect::new(1, 2, 3, 4).to_string(), "3x4+1+2");
-    }
-
-    #[test]
-    fn new() {
-        assert_eq!(
-            Rect::new(1, 2, 3, 4),
-            Rect {
-                x: 1,
-                y: 2,
-                width: 3,
-                height: 4
-            }
-        );
-    }
-
-    #[test]
-    fn area() {
-        assert_eq!(Rect::new(1, 2, 3, 4).area(), 12);
-    }
-
-    #[test]
-    fn is_empty() {
-        assert!(!Rect::new(1, 2, 3, 4).is_empty());
-        assert!(Rect::new(1, 2, 0, 4).is_empty());
-        assert!(Rect::new(1, 2, 3, 0).is_empty());
-    }
-
-    #[test]
-    fn left() {
-        assert_eq!(Rect::new(1, 2, 3, 4).left(), 1);
-    }
-
-    #[test]
-    fn right() {
-        assert_eq!(Rect::new(1, 2, 3, 4).right(), 4);
-    }
-
-    #[test]
-    fn top() {
-        assert_eq!(Rect::new(1, 2, 3, 4).top(), 2);
-    }
-
-    #[test]
-    fn bottom() {
-        assert_eq!(Rect::new(1, 2, 3, 4).bottom(), 6);
-    }
-
-    #[test]
-    fn inner() {
-        assert_eq!(
-            Rect::new(1, 2, 3, 4).inner(&Margin::new(1, 2)),
-            Rect::new(2, 4, 1, 0)
-        );
-    }
-
-    #[test]
-    fn union() {
-        assert_eq!(
-            Rect::new(1, 2, 3, 4).union(Rect::new(2, 3, 4, 5)),
-            Rect::new(1, 2, 5, 6)
-        );
-    }
-
-    #[test]
-    fn intersection() {
-        assert_eq!(
-            Rect::new(1, 2, 3, 4).intersection(Rect::new(2, 3, 4, 5)),
-            Rect::new(2, 3, 2, 3)
-        );
-    }
-
-    #[test]
-    fn intersects() {
-        assert!(Rect::new(1, 2, 3, 4).intersects(Rect::new(2, 3, 4, 5)));
-        assert!(!Rect::new(1, 2, 3, 4).intersects(Rect::new(5, 6, 7, 8)));
-    }
-
-    #[test]
-    fn size_truncation() {
-        for width in 256u16..300u16 {
-            for height in 256u16..300u16 {
-                let rect = Rect::new(0, 0, width, height);
-                rect.area(); // Should not panic.
-                assert!(rect.width < width || rect.height < height);
-                // The target dimensions are rounded down so the math will not be too precise
-                // but let's make sure the ratios don't diverge crazily.
-                assert!(
-                    (f64::from(rect.width) / f64::from(rect.height)
-                        - f64::from(width) / f64::from(height))
-                    .abs()
-                        < 1.0
-                );
-            }
-        }
-
-        // One dimension below 255, one above. Area above max u16.
-        let width = 900;
-        let height = 100;
-        let rect = Rect::new(0, 0, width, height);
-        assert_ne!(rect.width, 900);
-        assert_ne!(rect.height, 100);
-        assert!(rect.width < width || rect.height < height);
-    }
-
-    #[test]
-    fn 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);
-    }
-
-    #[test]
-    fn can_be_const() {
-        const RECT: Rect = Rect {
-            x: 0,
-            y: 0,
-            width: 10,
-            height: 10,
-        };
-        const _AREA: u16 = RECT.area();
-        const _LEFT: u16 = RECT.left();
-        const _RIGHT: u16 = RECT.right();
-        const _TOP: u16 = RECT.top();
-        const _BOTTOM: u16 = RECT.bottom();
-        assert!(RECT.intersects(RECT));
-    }
-}

src/lib.rs

@@ -1,348 +1,183 @@
 #![forbid(unsafe_code)]
 
-//! ![Demo](https://raw.githubusercontent.com/ratatui-org/ratatui/b33c878808c4c40591d7a2d9f9d94d6fee95a96f/examples/demo2.gif)
+//! [ratatui](https://github.com/ratatui-org/ratatui) is a library used to build rich
+//! terminal users interfaces and dashboards.
 //!
-//! <div align="center">
+//! ![](https://raw.githubusercontent.com/ratatui-org/ratatui/master/assets/demo.gif)
 //!
-//! [![Crate Badge]](https://crates.io/crates/ratatui) [![License Badge]](./LICENSE) [![CI
-//! Badge]](https://github.com/ratatui-org/ratatui/actions?query=workflow%3ACI+) [![Docs
-//! Badge]](https://docs.rs/crate/ratatui/)<br>
-//! [![Dependencies Badge]](https://deps.rs/repo/github/ratatui-org/ratatui) [![Codecov
-//! Badge]](https://app.codecov.io/gh/ratatui-org/ratatui) [![Discord
-//! Badge]](https://discord.gg/pMCEU9hNEj) [![Matrix
-//! Badge]](https://matrix.to/#/#ratatui:matrix.org)<br>
-//! [Documentation](https://docs.rs/ratatui) · [Ratatui Book](https://ratatui.rs) ·
-//! [Examples](https://github.com/ratatui-org/ratatui/tree/main/examples) · [Report a
-//! bug](https://github.com/ratatui-org/ratatui/issues/new?labels=bug&projects=&template=bug_report.md)
-//! · [Request a
-//! Feature](https://github.com/ratatui-org/ratatui/issues/new?labels=enhancement&projects=&template=feature_request.md)
-//! · [Send a Pull Request](https://github.com/ratatui-org/ratatui/compare)
+//! # Get started
 //!
-//! </div>
+//! ## Adding `ratatui` as a dependency
 //!
-//! # Ratatui
-//!
-//! [Ratatui] is a crate for cooking up terminal user interfaces in rust. It is a lightweight
-//! library that provides a set of widgets and utilities to build complex rust TUIs. Ratatui was
-//! forked from the [Tui-rs crate] in 2023 in order to continue its development.
-//!
-//! ## Installation
-//!
-//! Add `ratatui` and `crossterm` as dependencies to your cargo.toml:
-//!
-//! ```shell
-//! cargo add ratatui crossterm
+//! Add the following to your `Cargo.toml`:
+//! ```toml
+//! [dependencies]
+//! crossterm = "0.26"
+//! ratatui = "0.20"
 //! ```
 //!
-//! Ratatui uses [Crossterm] by default as it works on most platforms. See the [Installation]
-//! section of the [Ratatui Book] for more details on how to use other backends ([Termion] /
-//! [Termwiz]).
+//! The crate is using the `crossterm` backend by default that works on most platforms. But if for
+//! example you want to use the `termion` backend instead. This can be done by changing your
+//! dependencies specification to the following:
 //!
-//! ## Introduction
+//! ```toml
+//! [dependencies]
+//! termion = "1.5"
+//! ratatui = { version = "0.20", default-features = false, features = ['termion'] }
+//! ```
 //!
-//! Ratatui is based on the principle of immediate rendering with intermediate buffers. This means
-//! that for each frame, your app must render all widgets that are supposed to be part of the UI.
-//! This is in contrast to the retained mode style of rendering where widgets are updated and then
-//! automatically redrawn on the next frame. See the [Rendering] section of the [Ratatui Book] for
-//! more info.
+//! The same logic applies for all other available backends.
 //!
-//! ## Other documentation
+//! ### Features
 //!
-//! - [Ratatui Book] - explains the library's concepts and provides step-by-step tutorials
-//! - [Examples] - a collection of examples that demonstrate how to use the library.
-//! - [API Documentation] - the full API documentation for the library on docs.rs.
-//! - [Changelog] - generated by [git-cliff] utilizing [Conventional Commits].
-//! - [Contributing] - Please read this if you are interested in contributing to the project.
-//! - [Breaking Changes] - a list of breaking changes in the library.
+//! Widgets which add dependencies are gated behind feature flags to prevent unused transitive
+//! dependencies. The available features are:
 //!
-//! ## Quickstart
+//! * `widget-calendar` - enables [`widgets::calendar`] and adds a dependency on the [time
+//! crate](https://crates.io/crates/time).
 //!
-//! The following example demonstrates the minimal amount of code necessary to setup a terminal and
-//! render "Hello World!". The full code for this example which contains a little more detail is in
-//! [hello_world.rs]. For more guidance on different ways to structure your application see the
-//! [Application Patterns] and [Hello World tutorial] sections in the [Ratatui Book] and the various
-//! [Examples]. There are also several starter templates available:
+//! ## Creating a `Terminal`
 //!
-//! - [rust-tui-template]
-//! - [ratatui-async-template] (book and template)
-//! - [simple-tui-rs]
-//!
-//! Every application built with `ratatui` needs to implement the following steps:
-//!
-//! - Initialize the terminal
-//! - A main loop to:
-//!   - Handle input events
-//!   - Draw the UI
-//! - Restore the terminal state
-//!
-//! The library contains a [`prelude`] module that re-exports the most commonly used traits and
-//! types for convenience. Most examples in the documentation will use this instead of showing the
-//! full path of each type.
-//!
-//! ### Initialize and restore the terminal
-//!
-//! The [`Terminal`] type is the main entry point for any Ratatui application. It is a light
-//! abstraction over a choice of [`Backend`] implementations that provides functionality to draw
-//! each frame, clear the screen, hide the cursor, etc. It is parametrized over any type that
-//! implements the [`Backend`] trait which has implementations for [Crossterm], [Termion] and
-//! [Termwiz].
-//!
-//! Most applications should enter the Alternate Screen when starting and leave it when exiting and
-//! also enable raw mode to disable line buffering and enable reading key events. See the [`backend`
-//! module] and the [Backends] section of the [Ratatui Book] for more info.
-//!
-//! ### Drawing the UI
-//!
-//! The drawing logic is delegated to a closure that takes a [`Frame`] instance as argument. The
-//! [`Frame`] provides the size of the area to draw to and allows the app to render any [`Widget`]
-//! using the provided [`render_widget`] method. See the [Widgets] section of the [Ratatui Book] for
-//! more info.
-//!
-//! ### Handling events
-//!
-//! Ratatui does not include any input handling. Instead event handling can be implemented by
-//! calling backend library methods directly. See the [Handling Events] section of the [Ratatui
-//! Book] for more info. For example, if you are using [Crossterm], you can use the
-//! [`crossterm::event`] module to handle events.
-//!
-//! ### Example
+//! Every application using `ratatui` should start by instantiating a `Terminal`. It is a light
+//! abstraction over available backends that provides basic functionalities such as clearing the
+//! screen, hiding the cursor, etc.
 //!
 //! ```rust,no_run
-//! use std::io::{self, stdout};
-//! use crossterm::{
-//!     event::{self, Event, KeyCode},
-//!     ExecutableCommand,
-//!     terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen}
-//! };
-//! use ratatui::{prelude::*, widgets::*};
+//! use std::io;
+//! use ratatui::{backend::CrosstermBackend, Terminal};
 //!
-//! fn main() -> io::Result<()> {
-//!     enable_raw_mode()?;
-//!     stdout().execute(EnterAlternateScreen)?;
-//!     let mut terminal = Terminal::new(CrosstermBackend::new(stdout()))?;
-//!
-//!     let mut should_quit = false;
-//!     while !should_quit {
-//!         terminal.draw(ui)?;
-//!         should_quit = handle_events()?;
-//!     }
-//!
-//!     disable_raw_mode()?;
-//!     stdout().execute(LeaveAlternateScreen)?;
+//! fn main() -> Result<(), io::Error> {
+//!     let stdout = io::stdout();
+//!     let backend = CrosstermBackend::new(stdout);
+//!     let mut terminal = Terminal::new(backend)?;
 //!     Ok(())
 //! }
-//!
-//! fn handle_events() -> io::Result<bool> {
-//!     if event::poll(std::time::Duration::from_millis(50))? {
-//!         if let Event::Key(key) = event::read()? {
-//!             if key.kind == event::KeyEventKind::Press && key.code == KeyCode::Char('q') {
-//!                 return Ok(true);
-//!             }
-//!        }
-//!     }
-//!     Ok(false)
-//! }
-//!
-//! fn ui(frame: &mut Frame) {
-//!     frame.render_widget(
-//!         Paragraph::new("Hello World!")
-//!             .block(Block::default().title("Greeting").borders(Borders::ALL)),
-//!         frame.size(),
-//!     );
-//! }
 //! ```
 //!
-//! Running this example produces the following output:
+//! If you had previously chosen `termion` as a backend, the terminal can be created in a similar
+//! way:
 //!
-//! ![docsrs-hello]
+//! ```rust,ignore
+//! use std::io;
+//! use ratatui::{backend::TermionBackend, Terminal};
+//! use termion::raw::IntoRawMode;
+//!
+//! fn main() -> Result<(), io::Error> {
+//!     let stdout = io::stdout().into_raw_mode()?;
+//!     let backend = TermionBackend::new(stdout);
+//!     let mut terminal = Terminal::new(backend)?;
+//!     Ok(())
+//! }
+//! ```
+//!
+//! You may also refer to the examples to find out how to create a `Terminal` for each available
+//! backend.
+//!
+//! ## Building a User Interface (UI)
+//!
+//! Every component of your interface will be implementing the `Widget` trait. The library comes
+//! with a predefined set of widgets that should 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 rendered using [`Frame::render_widget`] which takes
+//! your widget instance and an area to draw to.
+//!
+//! The following example renders a block of the size of the terminal:
+//!
+//! ```rust,no_run
+//! use std::{io, thread, time::Duration};
+//! use ratatui::{
+//!     backend::CrosstermBackend,
+//!     widgets::{Block, Borders},
+//!     Terminal
+//! };
+//! use crossterm::{
+//!     event::{self, DisableMouseCapture, EnableMouseCapture},
+//!     execute,
+//!     terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
+//! };
+//!
+//! fn main() -> Result<(), io::Error> {
+//!     // setup terminal
+//!     enable_raw_mode()?;
+//!     let mut stdout = io::stdout();
+//!     execute!(stdout, EnterAlternateScreen, EnableMouseCapture)?;
+//!     let backend = CrosstermBackend::new(stdout);
+//!     let mut terminal = Terminal::new(backend)?;
+//!
+//!     terminal.draw(|f| {
+//!         let size = f.size();
+//!         let block = Block::default()
+//!             .title("Block")
+//!             .borders(Borders::ALL);
+//!         f.render_widget(block, size);
+//!     })?;
+//!
+//!     // Start a thread to discard any input events. Without handling events, the
+//!     // stdin buffer will fill up, and be read into the shell when the program exits.
+//!     thread::spawn(|| loop {
+//!         event::read();
+//!     });
+//!
+//!     thread::sleep(Duration::from_millis(5000));
+//!
+//!     // restore terminal
+//!     disable_raw_mode()?;
+//!     execute!(
+//!         terminal.backend_mut(),
+//!         LeaveAlternateScreen,
+//!         DisableMouseCapture
+//!     )?;
+//!     terminal.show_cursor()?;
+//!
+//!     Ok(())
+//! }
+//! ```
 //!
 //! ## Layout
 //!
-//! The library comes with a basic yet useful layout management object called [`Layout`] which
-//! allows you to split the available space into multiple areas and then render widgets in each
-//! area. This lets you describe a responsive terminal UI by nesting layouts. See the [Layout]
-//! section of the [Ratatui Book] for more info.
+//! The library comes with a basic yet useful layout management object called `Layout`. As you may
+//! see below and in the examples, the library makes heavy use of the builder pattern to provide
+//! full customization. And `Layout` is no exception:
 //!
 //! ```rust,no_run
-//! use ratatui::{prelude::*, widgets::*};
-//!
-//! fn ui(frame: &mut Frame) {
-//!     let main_layout = Layout::default()
+//! use ratatui::{
+//!     backend::Backend,
+//!     layout::{Constraint, Direction, Layout},
+//!     widgets::{Block, Borders},
+//!     Frame,
+//! };
+//! fn ui<B: Backend>(f: &mut Frame<B>) {
+//!    let chunks = Layout::default()
 //!         .direction(Direction::Vertical)
-//!         .constraints([
-//!             Constraint::Length(1),
-//!             Constraint::Min(0),
-//!             Constraint::Length(1),
-//!         ])
-//!         .split(frame.size());
-//!     frame.render_widget(
-//!         Block::new().borders(Borders::TOP).title("Title Bar"),
-//!         main_layout[0],
-//!     );
-//!     frame.render_widget(
-//!         Block::new().borders(Borders::TOP).title("Status Bar"),
-//!         main_layout[2],
-//!     );
-//!
-//!     let inner_layout = Layout::default()
-//!         .direction(Direction::Horizontal)
-//!         .constraints([Constraint::Percentage(50), Constraint::Percentage(50)])
-//!         .split(main_layout[1]);
-//!     frame.render_widget(
-//!         Block::default().borders(Borders::ALL).title("Left"),
-//!         inner_layout[0],
-//!     );
-//!     frame.render_widget(
-//!         Block::default().borders(Borders::ALL).title("Right"),
-//!         inner_layout[1],
-//!     );
+//!         .margin(1)
+//!         .constraints(
+//!             [
+//!                 Constraint::Percentage(10),
+//!                 Constraint::Percentage(80),
+//!                 Constraint::Percentage(10)
+//!             ].as_ref()
+//!         )
+//!         .split(f.size());
+//!     let block = Block::default()
+//!          .title("Block")
+//!          .borders(Borders::ALL);
+//!     f.render_widget(block, chunks[0]);
+//!     let block = Block::default()
+//!          .title("Block 2")
+//!          .borders(Borders::ALL);
+//!     f.render_widget(block, chunks[1]);
 //! }
 //! ```
 //!
-//! Running this example produces the following output:
-//!
-//! ![docsrs-layout]
-//!
-//! ## Text and styling
-//!
-//! The [`Text`], [`Line`] and [`Span`] types are the building blocks of the library and are used in
-//! many places. [`Text`] is a list of [`Line`]s and a [`Line`] is a list of [`Span`]s. A [`Span`]
-//! is a string with a specific style.
-//!
-//! The [`style` module] provides types that represent the various styling options. The most
-//! important one is [`Style`] which represents the foreground and background colors and the text
-//! attributes of a [`Span`]. The [`style` module] also provides a [`Stylize`] trait that allows
-//! short-hand syntax to apply a style to widgets and text. See the [Styling Text] section of the
-//! [Ratatui Book] for more info.
-//!
-//! ```rust,no_run
-//! use ratatui::{prelude::*, widgets::*};
-//!
-//! fn ui(frame: &mut Frame) {
-//!     let areas = Layout::default()
-//!         .direction(Direction::Vertical)
-//!         .constraints([
-//!             Constraint::Length(1),
-//!             Constraint::Length(1),
-//!             Constraint::Length(1),
-//!             Constraint::Length(1),
-//!             Constraint::Min(0),
-//!         ])
-//!         .split(frame.size());
-//!
-//!     let span1 = Span::raw("Hello ");
-//!     let span2 = Span::styled(
-//!         "World",
-//!         Style::new()
-//!             .fg(Color::Green)
-//!             .bg(Color::White)
-//!             .add_modifier(Modifier::BOLD),
-//!     );
-//!     let span3 = "!".red().on_light_yellow().italic();
-//!
-//!     let line = Line::from(vec![span1, span2, span3]);
-//!     let text: Text = Text::from(vec![line]);
-//!
-//!     frame.render_widget(Paragraph::new(text), areas[0]);
-//!     // or using the short-hand syntax and implicit conversions
-//!     frame.render_widget(
-//!         Paragraph::new("Hello World!".red().on_white().bold()),
-//!         areas[1],
-//!     );
-//!
-//!     // to style the whole widget instead of just the text
-//!     frame.render_widget(
-//!         Paragraph::new("Hello World!").style(Style::new().red().on_white()),
-//!         areas[2],
-//!     );
-//!     // or using the short-hand syntax
-//!     frame.render_widget(Paragraph::new("Hello World!").blue().on_yellow(), areas[3]);
-//! }
-//! ```
-//!
-//! Running this example produces the following output:
-//!
-//! ![docsrs-styling]
-#![cfg_attr(feature = "document-features", doc = "\n## Features")]
-#![cfg_attr(feature = "document-features", doc = document_features::document_features!())]
-#![cfg_attr(
-    feature = "document-features",
-    doc = "[`CrossTermBackend`]: backend::CrosstermBackend"
-)]
-#![cfg_attr(
-    feature = "document-features",
-    doc = "[`TermionBackend`]: backend::TermionBackend"
-)]
-#![cfg_attr(
-    feature = "document-features",
-    doc = "[`TermwizBackend`]: backend::TermwizBackend"
-)]
-#![cfg_attr(
-    feature = "document-features",
-    doc = "[`calendar`]: widgets::calendar::Monthly"
-)]
-//!
-//! [Ratatui Book]: https://ratatui.rs
-//! [Installation]: https://ratatui.rs/installation.html
-//! [Rendering]: https://ratatui.rs/concepts/rendering/index.html
-//! [Application Patterns]: https://ratatui.rs/concepts/application_patterns/index.html
-//! [Hello World tutorial]: https://ratatui.rs/tutorial/hello_world.html
-//! [Backends]: https://ratatui.rs/concepts/backends/index.html
-//! [Widgets]: https://ratatui.rs/how-to/widgets/index.html
-//! [Handling Events]: https://ratatui.rs/concepts/event_handling.html
-//! [Layout]: https://ratatui.rs/how-to/layout/index.html
-//! [Styling Text]: https://ratatui.rs/how-to/render/style-text.html
-//! [rust-tui-template]: https://github.com/ratatui-org/rust-tui-template
-//! [ratatui-async-template]: https://ratatui-org.github.io/ratatui-async-template/
-//! [simple-tui-rs]: https://github.com/pmsanford/simple-tui-rs
-//! [Examples]: https://github.com/ratatui-org/ratatui/tree/main/examples
-//! [git-cliff]: https://github.com/orhun/git-cliff
-//! [Conventional Commits]: https://www.conventionalcommits.org
-//! [API Documentation]: https://docs.rs/ratatui
-//! [Changelog]: https://github.com/ratatui-org/ratatui/blob/main/CHANGELOG.md
-//! [Contributing]: https://github.com/ratatui-org/ratatui/blob/main/CONTRIBUTING.md
-//! [Breaking Changes]: https://github.com/ratatui-org/ratatui/blob/main/BREAKING-CHANGES.md
-//! [docsrs-hello]: https://github.com/ratatui-org/ratatui/blob/c3c3c289b1eb8d562afb1931adb4dc719cd48490/examples/docsrs-hello.png?raw=true
-//! [docsrs-layout]: https://github.com/ratatui-org/ratatui/blob/c3c3c289b1eb8d562afb1931adb4dc719cd48490/examples/docsrs-layout.png?raw=true
-//! [docsrs-styling]: https://github.com/ratatui-org/ratatui/blob/c3c3c289b1eb8d562afb1931adb4dc719cd48490/examples/docsrs-styling.png?raw=true
-//! [`Frame`]: terminal::Frame
-//! [`render_widget`]: terminal::Frame::render_widget
-//! [`Widget`]: widgets::Widget
-//! [`Layout`]: layout::Layout
-//! [`Text`]: text::Text
-//! [`Line`]: text::Line
-//! [`Span`]: text::Span
-//! [`Style`]: style::Style
-//! [`style` module]: style
-//! [`Stylize`]: style::Stylize
-//! [`Backend`]: backend::Backend
-//! [`backend` module]: backend
-//! [`crossterm::event`]: https://docs.rs/crossterm/latest/crossterm/event/index.html
-//! [Ratatui]: https://ratatui.rs
-//! [Crossterm]: https://crates.io/crates/crossterm
-//! [Termion]: https://crates.io/crates/termion
-//! [Termwiz]: https://crates.io/crates/termwiz
-//! [Tui-rs crate]: https://crates.io/crates/tui
-//! [hello_world.rs]: https://github.com/ratatui-org/ratatui/blob/main/examples/hello_world.rs
-//! [Crate Badge]: https://img.shields.io/crates/v/ratatui?logo=rust&style=flat-square
-//! [CI Badge]:
-//!     https://img.shields.io/github/actions/workflow/status/ratatui-org/ratatui/ci.yml?style=flat-square&logo=github
-//! [Codecov Badge]:
-//!     https://img.shields.io/codecov/c/github/ratatui-org/ratatui?logo=codecov&style=flat-square&token=BAQ8SOKEST
-//! [Dependencies Badge]: https://deps.rs/repo/github/ratatui-org/ratatui/status.svg?style=flat-square
-//! [Discord Badge]:
-//!     https://img.shields.io/discord/1070692720437383208?label=discord&logo=discord&style=flat-square
-//! [Docs Badge]: https://img.shields.io/docsrs/ratatui?logo=rust&style=flat-square
-//! [License Badge]: https://img.shields.io/crates/l/ratatui?style=flat-square
-//! [Matrix Badge]:
-//!     https://img.shields.io/matrix/ratatui-general%3Amatrix.org?style=flat-square&logo=matrix&label=Matrix
+//! This let you describe responsive terminal UI by nesting layouts. You should note that by
+//! default the computed layout tries to fill the available space completely. So if for any reason
+//! you might need a blank space somewhere, try to pass an additional constraint and don't use the
+//! corresponding area.
 
 // show the feature flags in the generated documentation
 #![cfg_attr(docsrs, feature(doc_auto_cfg))]
-#![doc(
-    html_logo_url = "https://raw.githubusercontent.com/ratatui-org/ratatui/main/assets/logo.png",
-    html_favicon_url = "https://raw.githubusercontent.com/ratatui-org/ratatui/main/assets/favicon.ico"
-)]
 
 pub mod backend;
 pub mod buffer;
@@ -353,7 +188,6 @@ pub mod terminal;
 pub mod text;
 pub mod widgets;
 
-#[doc(inline)]
-pub use self::terminal::{CompletedFrame, Frame, Terminal, TerminalOptions, Viewport};
+pub use self::terminal::{Frame, Terminal, TerminalOptions, Viewport};
 
 pub mod prelude;