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

2020-11-14 15:53:33 +01:00
350 changed files with 11933 additions and 72184 deletions
--- a/.cargo/config.toml
+++ b/.cargo/config.toml
@@ -1,2 +0,0 @@
-[alias]
-xtask = "run --package xtask --"
--- a/.cz.toml
+++ b/.cz.toml
@@ -1,78 +0,0 @@
-# configuration for https://github.com/commitizen/cz-cli
-
-[tool.commitizen]
-name = "cz_customize"
-tag_format = "$version"
-version_type = "semver"
-version_provider = "cargo"
-update_changelog_on_bump = true
-major_version_zero = true
-use_shortcuts = true
-
-[tool.commitizen.customize]
-message_template = """{{change_type}}({{scope}}): {{subject}}
-
-{% if body %}\
-{{body}}\
-{% endif %}
-
-{%if is_breaking_change %}\
-BREAKING_CHANGE: \
-{% endif %}\
-{{footer}}\
-"""
-example = "feature: this feature enable customize through config file"
-schema = "<type>(<scope>): <subject>\n\n<body>\n\n<footer>"
-schema_pattern = "(build|chore|ci|docs|feat|fix|perf|refactor|revert|style|test)\\(\\w+\\):\\s(?P<subject>.*)(\\n\\n(?P<body>.*))?(\\n\\n(?P<footer>.*))?"
-
-# The order needs to be preserved, as it influences the order when executing cz commit/cz c
-
-# Change types
-[[tool.commitizen.customize.questions]]
-type = "list"
-name = "change_type"
-choices = [
-    { value = "build", name = "build: Changes that affect the build system or external dependencies (example scopes: pip, docker, npm)", key = "b" },
-    { value = "chore", name = "chore: A modification that generally does not fall into any other category", key = "c" },
-    { value = "ci", name = "ci: Changes to our CI configuration files and scripts (example scopes: GitLabCI)", key = "i" },
-    { value = "docs", name = "docs: Documentation only changes", key = "d" },
-    { value = "feat", name = "feat: A new feature.", key = "f" },
-    { value = "fix", name = "fix: A bug fix.", key = "x" },
-    { value = "perf", name = "perf: A code change that improves performance", key = "p" },
-    { value = "refactor", name = "refactor: A code change that neither fixes a bug nor adds a feature", key = "r" },
-    { value = "revert", name = "revert: Revert previous commits", key = "v" },
-    { value = "style", name = "style: Changes that do not affect the meaning of the code (white-space, formatting, missing semi-colons, etc)", key = "s" },
-    { value = "test", name = "test: Adding missing or correcting existing tests", key = "t" },
-]
-message = "Select the type of change you are committing"
-
-# The scope of the change, can be a file, class name or other context
-[[tool.commitizen.customize.questions]]
-type = "input"
-name = "scope"
-message = "What is the scope of this change? (class or file name): (press [enter] to skip)\n"
-
-# Summary of the changes
-[[tool.commitizen.customize.questions]]
-"type" = "input"
-"name" = "subject"
-"message" = "Write a short and imperative summary of the code changes: (lower case and no period)\n"
-
-# The commit body, elaborate the changes if need be.
-[[tool.commitizen.customize.questions]]
-type = "input"
-name = "body"
-message = "Provide additional contextual information about the code changes: (press [enter] to skip)\n"
-
-# Specify if the changes are breaking
-[[tool.commitizen.customize.questions]]
-type = "confirm"
-name = "is_breaking_change"
-message = "Is this a BREAKING CHANGE?"
-default = false
-
-# Reference closing issues and share other
-[[tool.commitizen.customize.questions]]
-type = "input"
-name = "footer"
-message = "Footer. Information about Breaking Changes and reference issues that this commit closes: (press [enter] to skip)"
--- a/.editorconfig
+++ b/.editorconfig
@@ -1,17 +0,0 @@
-# configuration for https://editorconfig.org
-
-root = true
-
-[*]
-charset = utf-8
-end_of_line = lf
-insert_final_newline = true
-trim_trailing_whitespace = true
-
-[*.rs]
-indent_style = space
-indent_size = 4
-
-[*.yml]
-indent_style = space
-indent_size = 2
--- a/.github/CODEOWNERS
+++ b/.github/CODEOWNERS
@@ -1,11 +0,0 @@
-# See <https://help.github.com/articles/about-codeowners/>
-
-# for more info about CODEOWNERS file
-
-# It uses the same pattern rule for gitignore file
-
-# <https://git-scm.com/docs/gitignore#_pattern_format>
-
-# Maintainers
-
-* @ratatui/maintainers
--- a/.github/FUNDING.yml
+++ b/.github/FUNDING.yml
@@ -1,2 +0,0 @@
-github: ratatui
-open_collective: ratatui
--- a/.github/ISSUE_TEMPLATE/bug_report.md
+++ b/.github/ISSUE_TEMPLATE/bug_report.md
@@ -1,56 +1,30 @@
 ---
 name: Bug report
-about: Create an issue about a bug you encountered
+about: Create a report to help us improve
 title: ''
-labels: 'Type: Bug'
+labels: bug
 assignees: ''
+
 ---

-<!--
-Hi there, sorry `ratatui` is not working as expected.
-Please fill this bug report conscientiously.
-A detailed and complete issue is more likely to be processed quickly.
-->
-
-## Description
-<!--
+**Describe the bug**
 A clear and concise description of what the bug is.
-->

-## To Reproduce
-<!--
-Try to reduce the issue to a simple code sample exhibiting the problem.
-Ideally, fork the project and add a test or an example.
-->
+**To Reproduce**
+If possible include a code sample exhibiting the problem.

-## Expected behavior
-<!--
+**Expected behavior**
 A clear and concise description of what you expected to happen.
-->

-## Screenshots
-<!--
-If applicable, add screenshots, gifs or videos to help explain your problem.
-->
+**Screenshots**
+If applicable, add screenshots to help explain your problem.

-## Environment
-<!--
-Add a description of the systems where you are observing the issue. For example:
- OS: Linux
- Terminal Emulator: xterm
- Font: Inconsolata (Patched)
- Crate version: 0.7
- Backend: termion
-->
+**Desktop (please complete the following information):**
+ - OS: [e.g. Linux,Windows]
+ - Terminal Emulator [e.g xterm, Konsole, Terminal, iTerm2, ConEmu]
+ - Font [e.g Inconsolata, Monospace]
+ - Crate version [e.g. 0.7]
+ - Backend [e.g termion, crossterm]

- OS:
- Terminal Emulator:
- Font:
- Crate version:
- Backend:
-
-## Additional context
-<!--
+**Additional context**
 Add any other context about the problem here.
-If you already looked into the issue, include all the leads you have explored.
-->
--- a/.github/ISSUE_TEMPLATE/config.yml
+++ b/.github/ISSUE_TEMPLATE/config.yml
@@ -1,14 +0,0 @@
-blank_issues_enabled: false
-contact_links:
-  - name: Frequently Asked Questions
-    url: https://ratatui.rs/faq/
-    about: Check the website FAQ section to see if your question has already been answered
-  - name: Ratatui Forum
-    url: https://forum.ratatui.rs
-    about: Ask questions about ratatui on our Forum
-  - 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
--- a/.github/ISSUE_TEMPLATE/feature_request.md
+++ b/.github/ISSUE_TEMPLATE/feature_request.md
@@ -2,31 +2,19 @@
 name: Feature request
 about: Suggest an idea for this project
 title: ''
-labels: 'Type: Enhancement'
+labels: enhancement
 assignees: ''

 ---

-## Problem
-<!--
+**Is your feature request related to a problem? Please describe.**
 A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
-->

-## Solution
-<!--
+**Describe the solution you'd like**
 A clear and concise description of what you want to happen.
-Things to consider:
- backward compatibility
- ease of use of the API (https://rust-lang.github.io/api-guidelines/)
- consistency with the rest of the crate
-->

-## Alternatives
-<!--
+**Describe alternatives you've considered**
 A clear and concise description of any alternative solutions or features you've considered.
-->

-## Additional context
-<!--
+**Additional context**
 Add any other context or screenshots about the feature request here.
-->
--- a/.github/dependabot.yml
+++ b/.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
--- a/.github/pull_request_template.md
+++ b/.github/pull_request_template.md
@@ -1 +0,0 @@
-<!-- Please read CONTRIBUTING.md before submitting any pull request. -->
--- a/.github/workflows/bench_base.yml
+++ b/.github/workflows/bench_base.yml
@@ -1,25 +0,0 @@
-name: Run Benchmarks
-
-on:
-  push:
-    branches:
-      - main
-
-jobs:
-  benchmark_base_branch:
-    name: Continuous Benchmarking with Bencher
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-      - uses: bencherdev/bencher@main
-      - name: Track base branch benchmarks with Bencher
-        run: |
-          bencher run \
-          --project ratatui-org \
-          --token '${{ secrets.BENCHER_API_TOKEN }}' \
-          --branch main \
-          --testbed ubuntu-latest \
-          --adapter rust_criterion \
-          --err \
-          cargo bench
--- a/.github/workflows/bench_run_fork_pr.yml
+++ b/.github/workflows/bench_run_fork_pr.yml
@@ -1,25 +0,0 @@
-name: Run and Cache Benchmarks
-
-on:
-  pull_request:
-    types: [opened, reopened, edited, synchronize]
-
-jobs:
-  benchmark_fork_pr_branch:
-    name: Run Fork PR Benchmarks
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-      - name: Run Benchmarks
-        run: cargo bench > benchmark_results.txt
-      - name: Upload Benchmark Results
-        uses: actions/upload-artifact@v4
-        with:
-          name: benchmark_results.txt
-          path: ./benchmark_results.txt
-      - name: Upload GitHub Pull Request Event
-        uses: actions/upload-artifact@v4
-        with:
-          name: event.json
-          path: ${{ github.event_path }}
--- a/.github/workflows/bench_track_fork_pr.yml
+++ b/.github/workflows/bench_track_fork_pr.yml
@@ -1,56 +0,0 @@
-name: Track Benchmarks with Bencher
-
-on:
-  workflow_run:
-    workflows: [Run and Cache Benchmarks]
-    types: [completed]
-
-permissions:
-  contents: read
-  pull-requests: write
-
-jobs:
-  track_fork_pr_branch:
-    if: github.event.workflow_run.conclusion == 'success'
-    runs-on: ubuntu-latest
-    env:
-      BENCHMARK_RESULTS: benchmark_results.txt
-      PR_EVENT: event.json
-    steps:
-      - name: Download Benchmark Results
-        uses: dawidd6/action-download-artifact@v7
-        with:
-          name: ${{ env.BENCHMARK_RESULTS }}
-          run_id: ${{ github.event.workflow_run.id }}
-      - name: Download PR Event
-        uses: dawidd6/action-download-artifact@v7
-        with:
-          name: ${{ env.PR_EVENT }}
-          run_id: ${{ github.event.workflow_run.id }}
-      - name: Export PR Event Data
-        uses: actions/github-script@v7
-        with:
-          script: |
-            let fs = require('fs');
-            let prEvent = JSON.parse(fs.readFileSync(process.env.PR_EVENT, {encoding: 'utf8'}));
-            core.exportVariable("PR_HEAD", prEvent.pull_request.head.ref);
-            core.exportVariable("PR_BASE", prEvent.pull_request.base.ref);
-            core.exportVariable("PR_BASE_SHA", prEvent.pull_request.base.sha);
-            core.exportVariable("PR_NUMBER", prEvent.number);
-      - uses: bencherdev/bencher@main
-      - name: Track Benchmarks with Bencher
-        run: |
-          bencher run \
-          --project ratatui-org \
-          --token '${{ secrets.BENCHER_API_TOKEN }}' \
-          --branch "$PR_HEAD" \
-          --start-point "$PR_BASE" \
-          --start-point-hash "$PR_BASE_SHA" \
-          --start-point-clone-thresholds \
-          --start-point-reset \
-          --testbed ubuntu-latest \
-          --adapter rust_criterion \
-          --err \
-          --github-actions '${{ secrets.GITHUB_TOKEN }}' \
-          --ci-number "$PR_NUMBER" \
-          --file "$BENCHMARK_RESULTS"
--- a/.github/workflows/calculate-alpha-release.bash
+++ b/.github/workflows/calculate-alpha-release.bash
@@ -1,52 +0,0 @@
-#!/bin/bash
-
-# 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
-
-last_release="$(git tag --sort=committerdate | grep -P "v0+\.\d+\.\d+$" | tail -1)"
-echo "🐭 Last release: ${last_release}"
-
-# detect breaking changes
-if [ -n "$(git log --oneline ${last_release}..HEAD | grep '!:')" ]; then
-    echo "🐭 Breaking changes detected since ${last_release}"
-    git log --oneline ${last_release}..HEAD | grep '!:'
-    # increment the minor version
-    minor="${last_release##v0.}"
-    minor="${minor%.*}"
-    next_minor="$((minor + 1))"
-    next_release="v0.${next_minor}.0"
-else
-    # increment the patch version
-    patch="${last_release##*.}"
-    next_patch="$((patch + 1))"
-    next_release="${last_release/%${patch}/${next_patch}}"
-fi
-echo "🐭 Next release: ${next_release}"
-
-suffix="alpha"
-last_tag="$(git tag --sort=committerdate | tail -1)"
-if [[ "${last_tag}" = "${next_release}-${suffix}"* ]]; then
-    echo "🐭 Last alpha release: ${last_tag}"
-    # 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}}"
-else
-    # increment the patch and start the alpha version from 0
-    # e.g. v0.22.0 -> v0.22.1-alpha.0
-    next_tag="${next_release}-${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}"
--- a/.github/workflows/check-pr.yml
+++ b/.github/workflows/check-pr.yml
@@ -1,86 +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
-    env:
-      # use an environment variable to pass untrusted input to the script
-      # see https://securitylab.github.com/research/github-actions-untrusted-input/
-      PR_TITLE: ${{ github.event.pull_request.title }}
-    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 "${PR_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@v7
-      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: ['Type: 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
--- a/.github/workflows/check-semver.yml
+++ b/.github/workflows/check-semver.yml
@@ -1,16 +0,0 @@
-name: Check Semver
-
-on:
-  pull_request:
-    branches:
-      - main
-
-jobs:
-  check-semver:
-    name: Check semver
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout the repository
-        uses: actions/checkout@v4
-      - name: Check semver
-        uses: obi1kenobi/cargo-semver-checks-action@v2
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -1,185 +1,81 @@
-name: Continuous Integration
+on: [push, pull_request]

-on:
-  # Allows you to run this workflow manually from the Actions tab
-  workflow_dispatch:
-  push:
-    branches:
-      - main
-  pull_request:
-    branches:
-      - main
+name: CI

-# ensure that the workflow is only triggered once per PR,  subsequent pushes to the PR will cancel
-# and restart the workflow. See https://docs.github.com/en/actions/using-jobs/using-concurrency
-concurrency:
-  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
-  cancel-in-progress: true
-
-# lint, clippy and coverage jobs are intentionally early in the workflow to catch simple formatting,
-# typos, and missing tests as early as possible. This allows us to fix these and resubmit the PR
-# without having to wait for the comprehensive matrix of tests to complete.
 jobs:
-  # Lint the formatting of the codebase.
-  lint-formatting:
-    name: Check Formatting
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: dtolnay/rust-toolchain@nightly
-        with: { components: rustfmt }
-      - run: cargo xtask lint-formatting
-
-  # Check for typos in the codebase.
-  # See <https://github.com/crate-ci/typos/>
-  lint-typos:
-    name: Check Typos
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: crate-ci/typos@master
-
-  # Check for any disallowed dependencies in the codebase due to license / security issues.
-  # See <https://github.com/EmbarkStudios/cargo-deny>
-  dependencies:
-    name: Check Dependencies
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: EmbarkStudios/cargo-deny-action@v2
-
-  # Check for any unused dependencies in the codebase.
-  # See <https://github.com/bnjbvr/cargo-machete/>
-  cargo-machete:
-    name: Check Unused Dependencies
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: Swatinem/rust-cache@v2
-      - uses: bnjbvr/cargo-machete@v0.7.0
-
-  # Run cargo clippy.
-  lint-clippy:
-    name: Check Clippy
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: dtolnay/rust-toolchain@stable
-        with: { components: clippy }
-      - uses: Swatinem/rust-cache@v2
-      - run: cargo xtask lint-clippy
-
-  # Run markdownlint on all markdown files in the repository.
-  lint-markdown:
-    name: Check Markdown
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: DavidAnson/markdownlint-cli2-action@v18
-        with:
-          globs: |
-            '**/*.md'
-            '!target'
-
-  # Run cargo coverage. This will generate a coverage report and upload it to codecov.
-  # <https://app.codecov.io/gh/ratatui/ratatui>
-  coverage:
-    name: Coverage Report
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: dtolnay/rust-toolchain@stable
-        with:
-          components: llvm-tools
-      - uses: taiki-e/install-action@cargo-llvm-cov
-      - uses: Swatinem/rust-cache@v2
-      - run: cargo xtask coverage
-      - uses: codecov/codecov-action@v5
-        with:
-          token: ${{ secrets.CODECOV_TOKEN }}
-          fail_ci_if_error: true
-
-  # Run cargo check. This is a fast way to catch any obvious errors in the code.
-  check:
-    name: Check ${{ matrix.os }} ${{ matrix.toolchain }}
-    strategy:
-      fail-fast: false
-      matrix:
-        os: [ubuntu-latest, windows-latest, macos-latest]
-        toolchain: ["1.74.0", "stable"]
-    runs-on: ${{ matrix.os }}
-    steps:
-      - uses: actions/checkout@v4
-      - uses: dtolnay/rust-toolchain@master
-        with:
-          toolchain: ${{ matrix.toolchain }}
-      - uses: Swatinem/rust-cache@v2
-      - run: cargo xtask check
-
-  # Check if README.md is up-to-date with the crate's documentation.
-  check-readme:
-    name: Check README
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: Swatinem/rust-cache@v2
-      - uses: taiki-e/install-action@cargo-rdme
-      - run: cargo xtask check-readme
-
-  # Run cargo rustdoc with the same options that would be used by docs.rs, taking into account the
-  # package.metadata.docs.rs configured in Cargo.toml. https://github.com/dtolnay/cargo-docs-rs
-  lint-docs:
-    name: Check Docs
-    runs-on: ubuntu-latest
-    env:
-      RUSTDOCFLAGS: -Dwarnings
-    steps:
-      - uses: actions/checkout@v4
-      - uses: dtolnay/rust-toolchain@nightly
-      - uses: dtolnay/install@cargo-docs-rs
-      - uses: Swatinem/rust-cache@v2
-      - run: cargo xtask lint-docs
-
-  # Run cargo test on the documentation of the crate. This will catch any code examples that don't
-  # compile, or any other issues in the documentation.
-  test-docs:
-    name: Test Docs
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: dtolnay/rust-toolchain@stable
-      - uses: Swatinem/rust-cache@v2
-      - run: cargo xtask test-docs
-
-  # Run cargo test on the libraries of the crate.
-  test-libs:
-    name: Test Libs ${{ matrix.toolchain }}
+  linux:
+    name: Linux
    runs-on: ubuntu-latest
    strategy:
-      fail-fast: false
      matrix:
-        toolchain: ["1.74.0", "stable"]
+        rust: ["1.44.0", "stable"]
    steps:
-      - uses: actions/checkout@v4
-      - uses: dtolnay/rust-toolchain@stable
-      - uses: Swatinem/rust-cache@v2
-      - run: cargo xtask test-libs
-
-  # Run cargo test on all the backends.
-  test-backends:
-    name: Test ${{matrix.backend}} on ${{ matrix.os }}
-    runs-on: ${{ matrix.os }}
+      - name: "Install dependencies"
+        run: sudo apt-get install libncurses5-dev
+      - uses: actions/checkout@v1
+      - uses: actions-rs/toolchain@v1
+        with:
+          profile: default
+          toolchain: ${{ matrix.rust }}
+          override: true
+      - name: "Format"
+        uses: actions-rs/cargo@v1
+        with:
+          command: fmt
+          args: --all -- --check
+      - name: "Check"
+        uses: actions-rs/cargo@v1
+        with:
+          command: check
+          args: --examples
+      - name: "Check (crossterm)"
+        uses: actions-rs/cargo@v1
+        with:
+          command: check
+          args: --no-default-features --features=crossterm --example crossterm_demo
+      - name: "Check (rustbox)"
+        uses: actions-rs/cargo@v1
+        with:
+          command: test
+          args: --no-default-features --features=rustbox --example rustbox_demo
+      - name: "Check (curses)"
+        uses: actions-rs/cargo@v1
+        with:
+          command: check
+          args: --no-default-features --features=curses --example curses_demo
+      - name: "Test"
+        uses: actions-rs/cargo@v1
+        with:
+          command: test
+        env:
+          RUST_BACKTRACE: full
+      - name: "Clippy"
+        uses: actions-rs/cargo@v1
+        with:
+          command: clippy
+          args: --all-targets --all-features -- -D warnings
+  windows:
+    name: Windows
+    runs-on: windows-latest
    strategy:
-      fail-fast: false
      matrix:
-        os: [ubuntu-latest, windows-latest, macos-latest]
-        backend: [crossterm, termion, termwiz]
-        exclude:
-          # termion is not supported on windows
-          - os: windows-latest
-            backend: termion
+        rust: ["1.44.0", "stable"]
    steps:
-      - uses: actions/checkout@v4
-      - uses: dtolnay/rust-toolchain@stable
-      - uses: Swatinem/rust-cache@v2
-      - run: cargo xtask test-backend ${{ matrix.backend }}
+      - uses: actions/checkout@v1
+      - uses: actions-rs/toolchain@v1
+        with:
+          profile: default
+          toolchain: ${{ matrix.rust }}
+          override: true
+      - name: "Check (crossterm)"
+        uses: actions-rs/cargo@v1
+        with:
+          command: check
+          args: --no-default-features --features=crossterm --example crossterm_demo
+      - name: "Test (crossterm)"
+        uses: actions-rs/cargo@v1
+        with:
+          command: test
+          args: --no-default-features --features=crossterm --tests --examples
+        env:
+          RUST_BACKTRACE: full
--- a/.github/workflows/release-alpha.yml
+++ b/.github/workflows/release-alpha.yml
@@ -1,48 +0,0 @@
-name: Release alpha version
-
-on:
-  workflow_dispatch:
-  schedule:
-    # At 00:00 on Saturday
-    # https://crontab.guru/#0_0_*_*_6
-    - cron: "0 0 * * 6"
-
-defaults:
-  run:
-    shell: bash
-
-jobs:
-  publish-alpha:
-    name: Create an alpha release
-    runs-on: ubuntu-latest
-    permissions:
-      contents: write
-    steps:
-      - name: Checkout the repository
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-
-      - name: Calculate the next release
-        run: .github/workflows/calculate-alpha-release.bash
-
-      - name: Install Rust stable
-        uses: dtolnay/rust-toolchain@stable
-
-      - name: Publish
-        run: cargo publish --allow-dirty --token ${{ secrets.CARGO_TOKEN }}
-
-      - name: Generate a changelog
-        uses: orhun/git-cliff-action@v4
-        with:
-          config: cliff.toml
-          args: --unreleased --tag ${{ env.NEXT_TAG }} --strip header
-        env:
-          OUTPUT: BODY.md
-
-      - name: Publish on GitHub
-        uses: ncipollo/release-action@v1
-        with:
-          tag: ${{ env.NEXT_TAG }}
-          prerelease: true
-          bodyFile: BODY.md
--- a/.github/workflows/release-stable.yml
+++ b/.github/workflows/release-stable.yml
@@ -1,45 +0,0 @@
-name: Release stable version
-
-on:
-  push:
-    tags:
-      - "v*.*.*"
-
-jobs:
-  publish-stable:
-    name: Create an stable release
-    runs-on: ubuntu-latest
-    permissions:
-      contents: write
-    steps:
-      - name: Checkout the repository
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-
-      - name: Generate a changelog
-        uses: orhun/git-cliff-action@v4
-        with:
-          config: cliff.toml
-          args: --latest --strip header
-        env:
-          OUTPUT: BODY.md
-
-      - name: Publish on GitHub
-        uses: ncipollo/release-action@v1
-        with:
-          prerelease: false
-          bodyFile: BODY.md
-
-  publish-crate:
-    name: Publish crate
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout the repository
-        uses: actions/checkout@v4
-
-      - name: Install Rust stable
-        uses: dtolnay/rust-toolchain@stable
-
-      - name: Publish
-        run: cargo publish --token ${{ secrets.CARGO_TOKEN }}
--- a/.gitignore
+++ b/.gitignore
@@ -1,4 +1,5 @@
 target
+Cargo.lock
 *.log
 *.rs.rustfmt
 .gdb_history
--- a/.markdownlint.yaml
+++ b/.markdownlint.yaml
@@ -1,15 +0,0 @@
-# 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
--- a/BREAKING-CHANGES.md
+++ b/BREAKING-CHANGES.md
@@ -1,913 +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 compiled manually from the commit history and changelog. We also tag PRs on
-GitHub with a [breaking change] label.
-
-[breaking change]: (https://github.com/ratatui/ratatui/issues?q=label%3A%22breaking+change%22)
-
-## Summary
-
-This is a quick summary of the sections below:
-
- [Unreleased](#unreleased)
-  - The `From` impls for backend types are now replaced with more specific traits
-  - `FrameExt` trait for `unstable-widget-ref` feature
- [v0.29.0](#v0290)
-  - `Sparkline::data` takes `IntoIterator<Item = SparklineBar>` instead of `&[u64]` and is no longer const
-  - Removed public fields from `Rect` iterators
-  - `Line` now implements `From<Cow<str>`
-  - `Table::highlight_style` is now `Table::row_highlight_style`
-  - `Tabs::select` now accepts `Into<Option<usize>>`
-  - `Color::from_hsl` is now behind the `palette` feature
- [v0.28.0](#v0280)
-  - `Backend::size` returns `Size` instead of `Rect`
-  - `Backend` trait migrates to `get/set_cursor_position`
-  - Ratatui now requires Crossterm 0.28.0
-  - `Axis::labels` now accepts `IntoIterator<Into<Line>>`
-  - `Layout::init_cache` no longer returns bool and takes a `NonZeroUsize` instead of `usize`
-  - `ratatui::terminal` module is now private
-  - `ToText` no longer has a lifetime
-  - `Frame::size` is deprecated and renamed to `Frame::area`
- [v0.27.0](#v0270)
-  - List no clamps the selected index to list
-  - Prelude items added / removed
-  - 'termion' updated to 4.0
-  - `Rect::inner` takes `Margin` directly instead of reference
-  - `Buffer::filled` takes `Cell` directly instead of reference
-  - `Stylize::bg()` now accepts `Into<Color>`
-  - Removed deprecated `List::start_corner`
-  - `LineGauge::gauge_style` is deprecated
- [v0.26.0](#v0260)
-  - `Flex::Start` is the new default flex mode for `Layout`
-  - `patch_style` & `reset_style` now consume and return `Self`
-  - Removed deprecated `Block::title_on_bottom`
-  - `Line` now has an extra `style` field which applies the style to the entire line
-  - `Block` style methods cannot be created in a const context
-  - `Tabs::new()` now accepts `IntoIterator<Item: Into<Line<'a>>>`
-  - `Table::new` now accepts `IntoIterator<Item: Into<Row<'a>>>`.
- [v0.25.0](#v0250)
-  - Removed `Axis::title_style` and `Buffer::set_background`
-  - `List::new()` now accepts `IntoIterator<Item = Into<ListItem<'a>>>`
-  - `Table::new()` now requires specifying the widths
-  - `Table::widths()` now accepts `IntoIterator<Item = AsRef<Constraint>>`
-  - Layout::new() now accepts direction and constraint parameters
-  - The default `Tabs::highlight_style` is now `Style::new().reversed()`
- [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 (0.30.0)
-
-### `FrameExt` trait for `unstable-widget-ref` feature ([#1530])
-
-[#1530]: https://github.com/ratatui/ratatui/pull/1530
-
-To call `Frame::render_widget_ref()` or `Frame::render_stateful_widget_ref()` you now need to:
-
-1. Import the `FrameExt` trait from `ratatui::widgets`.
-2. Enable the `unstable-widget-ref` feature.
-
-For example:
-
-```rust
-use ratatui::{
-    layout::Rect,
-    widgets::{Block, FrameExt},
-};
-
-let block = Block::new();
-let area = Rect::new(0, 0, 5, 5);
-frame.render_widget_ref(&block, area);
-```
-
-### `WidgetRef` no longer has a blanket implementation of Widget
-
-Previously there was a blanket implementation of Widget for WidgetRef. This has been reversed to
-instead be a blanket implementation of WidgetRef for all &W where W: Widget. Any widgets that
-previously implemented WidgetRef directly should now instead implement Widget for a reference to the
-type.
-
-```diff
-impl WidgetRef for Foo {
-    fn render_ref(&self, area: Rect, buf: &mut Buffer)
-+impl Widget for &Foo {
-+    fn render(self, area: Rect, buf: &mut Buffer)
-}
-```
-
-### The `From` impls for backend types are now replaced with more specific traits [#1464]
-
-[#1464]: https://github.com/ratatui/ratatui/pull/1464
-
-Crossterm gains `ratatui::backend::crossterm::{FromCrossterm, IntoCrossterm}`
-Termwiz gains `ratatui::backend::termwiz::{FromTermwiz, IntoTermwiz}`
-
-This is necessary in order to avoid the orphan rule when implementing `From` for crossterm types
-once the crossterm types are moved to a separate crate.
-
-```diff
-+ use ratatui::backend::crossterm::{FromCrossterm, IntoCrossterm};
-
-let crossterm_color = crossterm::style::Color::Black;
- let ratatui_color = crossterm_color.into();
- let ratatui_color = ratatui::style::Color::from(crossterm_color);
-+ let ratatui_color = ratatui::style::Color::from_crossterm(crossterm_color);
- let crossterm_color = ratatui_color.into();
- let crossterm_color = crossterm::style::Color::from(ratatui_color);
-+ let crossterm_color = ratatui_color.into_crossterm();
-
-let crossterm_attribute = crossterm::style::types::Attribute::Bold;
- let ratatui_modifier = crossterm_attribute.into();
- let ratatui_modifier = ratatui::style::Modifier::from(crossterm_attribute);
-+ let ratatui_modifier = ratatui::style::Modifier::from_crossterm(crossterm_attribute);
- let crossterm_attribute = ratatui_modifier.into();
- let crossterm_attribute = crossterm::style::types::Attribute::from(ratatui_modifier);
-+ let crossterm_attribute = ratatui_modifier.into_crossterm();
-```
-
-Similar conversions for `ContentStyle` -> `Style` and `Attributes` -> `Modifier` exist for
-Crossterm and the various Termion and Termwiz types as well.
-
-### `Bar::label()` and `BarGroup::label()` now accepts `Into<Line<'a>>`. ([#1471])
-
-[#1471]: https://github.com/ratatui/ratatui/pull/1471
-
-Previously `Bar::label()` and `BarGroup::label()` accepted `Line<'a>`, but they now accepts `Into<Line<'a>>`.
-
-for `Bar::label()`:
-
-```diff
- Bar::default().label("foo".into());
-+ Bar::default().label("foo");
-```
-
-for `BarGroup::label()`:
-
-```diff
- BarGroup::default().label("bar".into());
-+ BarGroup::default().label("bar");
-```
-
-### `Bar::text_value` now accepts `Into<String>` ([#1471])
-
-Previously `Bar::text_value` accepted `String`, but now it accepts `Into<String>`.
-
-for `Bar::text_value()`:
-
-```diff
- Bar::default().text_value("foobar".into());
-+ Bar::default().text_value("foobar");
-```
-
-## [v0.29.0](https://github.com/ratatui/ratatui/releases/tag/v0.29.0)
-
-### `Sparkline::data` takes `IntoIterator<Item = SparklineBar>` instead of `&[u64]` and is no longer const ([#1326])
-
-[#1326]: https://github.com/ratatui/ratatui/pull/1326
-
-The `Sparkline::data` method has been modified to accept `IntoIterator<Item = SparklineBar>`
-instead of `&[u64]`.
-
-`SparklineBar` is a struct that contains an `Option<u64>` value, which represents an possible
-_absent_ value, as distinct from a `0` value. This change allows the `Sparkline` to style
-data points differently, depending on whether they are present or absent.
-
-`SparklineBar` also contains an `Option<Style>` that will be used to apply a style the bar in
-addition to any other styling applied to the `Sparkline`.
-
-Several `From` implementations have been added to `SparklineBar` to support existing callers who
-provide `&[u64]` and other types that can be converted to `SparklineBar`, such as `Option<u64>`.
-
-If you encounter any type inference issues, you may need to provide an explicit type for the data
-passed to `Sparkline::data`. For example, if you are passing a single value, you may need to use
-`into()` to convert it to form that can be used as a `SparklineBar`:
-
-```diff
-let value = 1u8;
- Sparkline::default().data(&[value.into()]);
-+ Sparkline::default().data(&[u64::from(value)]);
-```
-
-As a consequence of this change, the `data` method is no longer a `const fn`.
-
-### `Color::from_hsl` is now behind the `palette` feature and accepts `palette::Hsl` ([#1418])
-
-[#1418]: https://github.com/ratatui/ratatui/pull/1418
-
-Previously `Color::from_hsl` accepted components as individual f64 parameters. It now accepts a
-single `palette::Hsl` value and is gated behind a `palette` feature flag.
-
-```diff
- Color::from_hsl(360.0, 100.0, 100.0)
-+ Color::from_hsl(Hsl::new(360.0, 100.0, 100.0))
-```
-
-### Removed public fields from `Rect` iterators ([#1358], [#1424])
-
-[#1358]: https://github.com/ratatui/ratatui/pull/1358
-[#1424]: https://github.com/ratatui/ratatui/pull/1424
-
-The `pub` modifier has been removed from fields on the `Columns`,`Rows`, and `Positions` iterators.
-These fields were not intended to be public and should not have been accessed directly.
-
-### `Rect::area()` now returns u32 instead of u16 ([#1378])
-
-[#1378]: https://github.com/ratatui/ratatui/pull/1378
-
-This is likely to impact anything which relies on `Rect::area` maxing out at u16::MAX. It can now
-return up to u16::MAX * u16::MAX (2^32 - 2^17 + 1).
-
-### `Line` now implements `From<Cow<str>` ([#1373])
-
-[#1373]: https://github.com/ratatui/ratatui/pull/1373
-
-As this adds an extra conversion, ambiguous inferred expressions may no longer compile.
-
-```rust
-// given:
-struct Foo { ... }
-impl From<Foo> for String { ... }
-impl From<Foo> for Cow<str> { ... }
-
-let foo = Foo { ... };
-let line = Line::from(foo); // now fails due to now ambiguous inferred type
-// replace with e.g.
-let line = Line::from(String::from(foo));
-```
-
-### `Tabs::select()` now accepts `Into<Option<usize>>` ([#1413])
-
-[#1413]: https://github.com/ratatui/ratatui/pull/1413
-
-Previously `Tabs::select()` accepted `usize`, but it now accepts `Into<Option<usize>>`. This breaks
-any code already using parameter type inference:
-
-```diff
-let selected = 1u8;
- let tabs = Tabs::new(["A", "B"]).select(selected.into())
-+ let tabs = Tabs::new(["A", "B"]).select(selected as usize)
-```
-
-### `Table::highlight_style` is now `Table::row_highlight_style` ([#1331])
-
-[#1331]: https://github.com/ratatui/ratatui/pull/1331
-
-The `Table::highlight_style` is now deprecated in favor of `Table::row_highlight_style`.
-
-Also, the serialized output of the `TableState` will now include the "selected_column" field.
-Software that manually parse the serialized the output (with anything other than the `Serialize`
-implementation on `TableState`) may have to be refactored if the "selected_column" field is not
-accounted for. This does not affect users who rely on the `Deserialize`, or `Serialize`
-implementation on the state.
-
-## [v0.28.0](https://github.com/ratatui/ratatui/releases/tag/v0.28.0)
-
-### `Backend::size` returns `Size` instead of `Rect` ([#1254])
-
-[#1254]: https://github.com/ratatui/ratatui/pull/1254
-
-The `Backend::size` method returns a `Size` instead of a `Rect`.
-There is no need for the position here as it was always 0,0.
-
-### `Backend` trait migrates to `get/set_cursor_position` ([#1284])
-
-[#1284]: https://github.com/ratatui/ratatui/pull/1284
-
-If you just use the types implementing the `Backend` trait, you will see deprecation hints but
-nothing is a breaking change for you.
-
-If you implement the Backend trait yourself, you need to update the implementation and add the
-`get/set_cursor_position` method. You can remove the `get/set_cursor` methods as they are deprecated
-and a default implementation for them exists.
-
-### Ratatui now requires Crossterm 0.28.0 ([#1278])
-
-[#1278]: https://github.com/ratatui/ratatui/pull/1278
-
-Crossterm is updated to version 0.28.0, which is a semver incompatible version with the previous
-version (0.27.0). Ratatui re-exports the version of crossterm that it is compatible with under
-`ratatui::crossterm`, which can be used to avoid incompatible versions in your dependency list.
-
-### `Axis::labels()` now accepts `IntoIterator<Into<Line>>` ([#1273] and [#1283])
-
-[#1273]: https://github.com/ratatui/ratatui/pull/1173
-[#1283]: https://github.com/ratatui/ratatui/pull/1283
-
-Previously Axis::labels accepted `Vec<Span>`. Any code that uses conversion methods that infer the
-type will need to be rewritten as the compiler cannot infer the correct type.
-
-```diff
- Axis::default().labels(vec!["a".into(), "b".into()])
-+ Axis::default().labels(["a", "b"])
-```
-
-### `Layout::init_cache` no longer returns bool and takes a `NonZeroUsize` instead of `usize` ([#1245])
-
-[#1245]: https://github.com/ratatui/ratatui/pull/1245
-
-```diff
- let is_initialized = Layout::init_cache(100);
-+ Layout::init_cache(NonZeroUsize::new(100).unwrap());
-```
-
-### `ratatui::terminal` module is now private ([#1160])
-
-[#1160]: https://github.com/ratatui/ratatui/pull/1160
-
-The `terminal` module is now private and can not be used directly. The types under this module are
-exported from the root of the crate. This reduces clashes with other modules in the backends that
-are also named terminal, and confusion about module exports for newer Rust users.
-
-```diff
- use ratatui::terminal::{CompletedFrame, Frame, Terminal, TerminalOptions, ViewPort};
-+ use ratatui::{CompletedFrame, Frame, Terminal, TerminalOptions, ViewPort};
-```
-
-### `ToText` no longer has a lifetime ([#1234])
-
-[#1234]: https://github.com/ratatui/ratatui/pull/1234
-
-This change simplifies the trait and makes it easier to implement.
-
-### `Frame::size` is deprecated and renamed to `Frame::area` ([#1293])
-
-[#1293]: https://github.com/ratatui/ratatui/pull/1293
-
-`Frame::size` is renamed to `Frame::area` as it's the more correct name.
-
-## [v0.27.0](https://github.com/ratatui/ratatui/releases/tag/v0.27.0)
-
-### List no clamps the selected index to list ([#1159])
-
-[#1149]: https://github.com/ratatui/ratatui/pull/1149
-
-The `List` widget now clamps the selected index to the bounds of the list when navigating with
-`first`, `last`, `previous`, and `next`, as well as when setting the index directly with `select`.
-
-Previously selecting an index past the end of the list would show treat the list as having a
-selection which was not visible. Now the last item in the list will be selected instead.
-
-### Prelude items added / removed ([#1149])
-
-The following items have been removed from the prelude:
-
- `style::Styled` - this trait is useful for widgets that want to
-  support the Stylize trait, but it adds complexity as widgets have two
-  `style` methods and a `set_style` method.
- `symbols::Marker` - this item is used by code that needs to draw to
-  the `Canvas` widget, but it's not a common item that would be used by
-  most users of the library.
- `terminal::{CompletedFrame, TerminalOptions, Viewport}` - these items
-  are rarely used by code that needs to interact with the terminal, and
-  they're generally only ever used once in any app.
-
-The following items have been added to the prelude:
-
- `layout::{Position, Size}` - these items are used by code that needs
-  to interact with the layout system. These are newer items that were
-  added in the last few releases, which should be used more liberally.
-  This may cause conflicts for types defined elsewhere with a similar
-  name.
-
-To update your app:
-
-```diff
-// if your app uses Styled::style() or Styled::set_style():
-use ratatui::prelude::*;
-+use ratatui::{prelude::*, style::Styled};
-
-// if your app uses symbols::Marker:
-use ratatui::prelude::*;
-+use ratatui::{prelude::*, symbols::Marker}
-
-// if your app uses terminal::{CompletedFrame, TerminalOptions, Viewport}
-use ratatui::prelude::*;
-+use ratatui::{prelude::*, terminal::{CompletedFrame, TerminalOptions, Viewport}};
-
-// to disambiguate existing types named Position or Size:
- use some_crate::{Position, Size};
- let size: Size = ...;
- let position: Position = ...;
-+ let size: some_crate::Size = ...;
-+ let position: some_crate::Position = ...;
-```
-
-### Termion is updated to 4.0 [#1106]
-
-Changelog: <https://gitlab.redox-os.org/redox-os/termion/-/blob/master/CHANGELOG.md>
-
-A change is only necessary if you were matching on all variants of the `MouseEvent` enum without a
-wildcard. In this case, you need to either handle the two new variants, `MouseLeft` and
-`MouseRight`, or add a wildcard.
-
-[#1106]: https://github.com/ratatui/ratatui/pull/1106
-
-### `Rect::inner` takes `Margin` directly instead of reference ([#1008])
-
-[#1008]: https://github.com/ratatui/ratatui/pull/1008
-
-`Margin` needs to be passed without reference now.
-
-```diff
-let area = area.inner(&Margin {
-+let area = area.inner(Margin {
-     vertical: 0,
-     horizontal: 2,
- });
-```
-
-### `Buffer::filled` takes `Cell` directly instead of reference ([#1148])
-
-[#1148]: https://github.com/ratatui/ratatui/pull/1148
-
-`Buffer::filled` moves the `Cell` instead of taking a reference.
-
-```diff
-Buffer::filled(area, &Cell::new("X"));
-+Buffer::filled(area, Cell::new("X"));
-```
-
-### `Stylize::bg()` now accepts `Into<Color>` ([#1103])
-
-[#1103]: https://github.com/ratatui/ratatui/pull/1103
-
-Previously, `Stylize::bg()` accepted `Color` but now accepts `Into<Color>`. This allows more
-flexible types from calling scopes, though it can break some type inference in the calling scope.
-
-### Remove deprecated `List::start_corner` and `layout::Corner` ([#759])
-
-[#759]: https://github.com/ratatui/ratatui/pull/759
-
-`List::start_corner` was deprecated in v0.25. Use `List::direction` and `ListDirection` instead.
-
-```diff
- list.start_corner(Corner::TopLeft);
- list.start_corner(Corner::TopRight);
-// This is not an error, BottomRight rendered top to bottom previously
- list.start_corner(Corner::BottomRight);
-// all becomes
-+ list.direction(ListDirection::TopToBottom);
-```
-
-```diff
- list.start_corner(Corner::BottomLeft);
-// becomes
-+ list.direction(ListDirection::BottomToTop);
-```
-
-`layout::Corner` was removed entirely.
-
-### `LineGauge::gauge_style` is deprecated ([#565])
-
-[#565]: https://github.com/ratatui/ratatui/pull/1148
-
-`LineGauge::gauge_style` is deprecated and replaced with `LineGauge::filled_style` and `LineGauge::unfilled_style`:
-
-```diff
-let gauge = LineGauge::default()
- .gauge_style(Style::default().fg(Color::Red).bg(Color::Blue)
-+ .filled_style(Style::default().fg(Color::Green))
-+ .unfilled_style(Style::default().fg(Color::White));
-```
-
-## [v0.26.0](https://github.com/ratatui/ratatui/releases/tag/v0.26.0)
-
-### `Flex::Start` is the new default flex mode for `Layout` ([#881])
-
-[#881]: https://github.com/ratatui/ratatui/pull/881
-
-Previously, constraints would stretch to fill all available space, violating constraints if
-necessary.
-
-With v0.26.0, `Flex` modes are introduced, and the default is `Flex::Start`, which will align
-areas associated with constraints to be beginning of the area. With v0.26.0, additionally,
-`Min` constraints grow to fill excess space. These changes will allow users to build layouts
-more easily.
-
-With v0.26.0, users will most likely not need to change what constraints they use to create
-existing layouts with `Flex::Start`. However, to get old behavior, use `Flex::Legacy`.
-
-```diff
- let rects = Layout::horizontal([Length(1), Length(2)]).split(area);
-// becomes
-+ let rects = Layout::horizontal([Length(1), Length(2)]).flex(Flex::Legacy).split(area);
-```
-
-### `Table::new()` now accepts `IntoIterator<Item: Into<Row<'a>>>` ([#774])
-
-[#774]: https://github.com/ratatui/ratatui/pull/774
-
-Previously, `Table::new()` accepted `IntoIterator<Item=Row<'a>>`. The argument change to
-`IntoIterator<Item: Into<Row<'a>>>`, This allows more flexible types from calling scopes, though it
-can some break type inference in the calling scope for empty containers.
-
-This can be resolved either by providing an explicit type (e.g. `Vec::<Row>::new()`), or by using
-`Table::default()`.
-
-```diff
- let table = Table::new(vec![], widths);
-// becomes
-+ let table = Table::default().widths(widths);
-```
-
-### `Tabs::new()` now accepts `IntoIterator<Item: Into<Line<'a>>>` ([#776])
-
-[#776]: https://github.com/ratatui/ratatui/pull/776
-
-Previously, `Tabs::new()` accepted `Vec<T>` where `T: Into<Line<'a>>`. This allows more flexible
-types from calling scopes, though it can break some type inference in the calling scope.
-
-This typically occurs when collecting an iterator prior to calling `Tabs::new`, and can be resolved
-by removing the call to `.collect()`.
-
-```diff
- let tabs = Tabs::new((0.3).map(|i| format!("{i}")).collect());
-// becomes
-+ let tabs = Tabs::new((0.3).map(|i| format!("{i}")));
-```
-
-### Table::default() now sets segment_size to None and column_spacing to ([#751])
-
-[#751]: https://github.com/ratatui/ratatui/pull/751
-
-The default() implementation of Table now sets the column_spacing field to 1 and the segment_size
-field to `SegmentSize::None`. This will affect the rendering of a small amount of apps.
-
-To use the previous default values, call `table.segment_size(Default::default())` and
-`table.column_spacing(0)`.
-
-### `patch_style` & `reset_style` now consumes and returns `Self` ([#754])
-
-[#754]: https://github.com/ratatui/ratatui/pull/754
-
-Previously, `patch_style` and `reset_style` in `Text`, `Line` and `Span` were using a mutable
-reference to `Self`. To be more consistent with the rest of `ratatui`, which is using fluent
-setters, these now take ownership of `Self` and return it.
-
-The following example shows how to migrate for `Line`, but the same applies for `Text` and `Span`.
-
-```diff
- let mut line = Line::from("foobar");
- line.patch_style(style);
-// becomes
-+ let line = Line::new("foobar").patch_style(style);
-```
-
-### Remove deprecated `Block::title_on_bottom` ([#757])
-
-`Block::title_on_bottom` was deprecated in v0.22. Use `Block::title` and `Title::position` instead.
-
-```diff
- block.title("foobar").title_on_bottom();
-+ block.title(Title::from("foobar").position(Position::Bottom));
-```
-
-### `Block` style methods cannot be used in a const context ([#720])
-
-[#720]: https://github.com/ratatui/ratatui/pull/720
-
-Previously the `style()`, `border_style()` and `title_style()` methods could be used to create a
-`Block` in a constant context. These now accept `Into<Style>` instead of `Style`. These methods no
-longer can be called from a constant context.
-
-### `Line` now has a `style` field that applies to the entire line ([#708])
-
-[#708]: https://github.com/ratatui/ratatui/pull/708
-
-Previously the style of a `Line` was stored in the `Span`s that make up the line. Now the `Line`
-itself has a `style` field, which can be set with the `Line::styled` method. Any code that creates
-`Line`s using the struct initializer instead of constructors will fail to compile due to the added
-field. This can be easily fixed by adding `..Default::default()` to the field list or by using a
-constructor method (`Line::styled()`, `Line::raw()`) or conversion method (`Line::from()`).
-
-Each `Span` contained within the line will no longer have the style that is applied to the line in
-the `Span::style` field.
-
-```diff
-  let line = Line {
-      spans: vec!["".into()],
-      alignment: Alignment::Left,
-+     ..Default::default()
-  };
-
-  // or
-
-  let line = Line::raw(vec!["".into()])
-      .alignment(Alignment::Left);
-```
-
-## [v0.25.0](https://github.com/ratatui/ratatui/releases/tag/v0.25.0)
-
-### Removed `Axis::title_style` and `Buffer::set_background` ([#691])
-
-[#691]: https://github.com/ratatui/ratatui/pull/691
-
-These items were deprecated since 0.10.
-
- You should use styling capabilities of [`text::Line`] given as argument of [`Axis::title`]
-  instead of `Axis::title_style`
- You should use styling capabilities of [`Buffer::set_style`] instead of `Buffer::set_background`
-
-[`text::Line`]: https://docs.rs/ratatui/latest/ratatui/text/struct.Line.html
-[`Axis::title`]: https://docs.rs/ratatui/latest/ratatui/widgets/struct.Axis.html#method.title
-[`Buffer::set_style`]: https://docs.rs/ratatui/latest/ratatui/buffer/struct.Buffer.html#method.set_style
-
-### `List::new()` now accepts `IntoIterator<Item = Into<ListItem<'a>>>` ([#672])
-
-[#672]: https://github.com/ratatui/ratatui/pull/672
-
-Previously `List::new()` took `Into<Vec<ListItem<'a>>>`. This change will throw a compilation
-error for `IntoIterator`s with an indeterminate item (e.g. empty vecs).
-
-E.g.
-
-```diff
- let list = List::new(vec![]);
-// becomes
-+ let list = List::default();
-```
-
-### The default `Tabs::highlight_style` is now `Style::new().reversed()` ([#635])
-
-[#635]: https://github.com/ratatui/ratatui/pull/635
-
-Previously the default highlight style for tabs was `Style::default()`, which meant that a `Tabs`
-widget in the default configuration would not show any indication of the selected tab.
-
-### The default `Tabs::highlight_style` is now `Style::new().reversed()` ([#635])
-
-Previously the default highlight style for tabs was `Style::default()`, which meant that a `Tabs`
-widget in the default configuration would not show any indication of the selected tab.
-
-### `Table::new()` now requires specifying the widths of the columns ([#664])
-
-[#664]: https://github.com/ratatui/ratatui/pull/664
-
-Previously `Table`s could be constructed without `widths`. In almost all cases this is an error.
-A new `widths` parameter is now mandatory on `Table::new()`. Existing code of the form:
-
-```diff
- Table::new(rows).widths(widths)
-```
-
-Should be updated to:
-
-```diff
-+ Table::new(rows, widths)
-```
-
-For ease of automated replacement in cases where the amount of code broken by this change is large
-or complex, it may be convenient to replace `Table::new` with `Table::default().rows`.
-
-```diff
- Table::new(rows).block(block).widths(widths);
-// becomes
-+ Table::default().rows(rows).widths(widths)
-```
-
-### `Table::widths()` now accepts `IntoIterator<Item = AsRef<Constraint>>` ([#663])
-
-[#663]: https://github.com/ratatui/ratatui/pull/663
-
-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.
-
-```diff
- let table = Table::new(rows).widths(&[Constraint::Length(1)]);
-// becomes
-+ let table = Table::new(rows, [Constraint::Length(1)]);
-```
-
-### Layout::new() now accepts direction and constraint parameters ([#557])
-
-[#557]: https://github.com/ratatui/ratatui/pull/557
-
-Previously layout new took no parameters. Existing code should either use `Layout::default()` or
-the new constructor.
-
-```rust
-let layout = layout::new()
-  .direction(Direction::Vertical)
-  .constraints([Constraint::Min(1), Constraint::Max(2)]);
-// becomes either
-let layout = layout::default()
-  .direction(Direction::Vertical)
-  .constraints([Constraint::Min(1), Constraint::Max(2)]);
-// or
-let layout = layout::new(Direction::Vertical, [Constraint::Min(1), Constraint::Max(2)]);
-```
-
-## [v0.24.0](https://github.com/ratatui/ratatui/releases/tag/v0.24.0)
-
-### `ScrollbarState` field type changed from `u16` to `usize` ([#456])
-
-[#456]: https://github.com/ratatui/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/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.:
-
-```diff
- 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/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.:
-
-```diff
- 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/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.
-
-```diff
- 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/ratatui/issues/426
-
-`Spans` was replaced with `Line` in 0.21.0. `Buffer::set_spans` was replaced with
-`Buffer::set_line`.
-
-```diff
- 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/ratatui/releases/tag/v0.23.0)
-
-### `Scrollbar::track_symbol()` now takes an `Option<&str>` instead of `&str` ([#360])
-
-[#360]: https://github.com/ratatui/ratatui/issues/360
-
-The track symbol of `Scrollbar` is now optional, this method now takes an optional value.
-
-```diff
- 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/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.:
-
-```diff
- 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/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/ratatui/releases/tag/v0.22.0)
-
-### `bitflags` updated to 2.3 ([#205])
-
-[#205]: https://github.com/ratatui/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/ratatui/releases/tag/v0.21.0)
-
-### MSRV is 1.65.0 ([#171])
-
-[#171]: https://github.com/ratatui/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/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.
-
-```diff
-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/ratatui/issues/168
-
-A new type `Masked` was introduced that implements `From<Text<'a>>`. This causes any code that
-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.:
-
-```diff
- 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/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.
-
-```diff
- let canvas = Canvas::default().marker(Marker::Block);
-// becomes
-+ let canvas = Canvas::default().marker(Marker::Bar);
-```
-
-## [v0.20.0](https://github.com/ratatui/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/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/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"),
-];
-```
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
--- a/CODE_OF_CONDUCT.md
+++ b/CODE_OF_CONDUCT.md
@@ -1,128 +0,0 @@
-# Contributor Covenant Code of Conduct
-
-## Our Pledge
-
-We as members, contributors, and leaders pledge to make participation in our
-community a harassment-free experience for everyone, regardless of age, body
-size, visible or invisible disability, ethnicity, sex characteristics, gender
-identity and expression, level of experience, education, socio-economic status,
-nationality, personal appearance, race, religion, or sexual identity
-and orientation.
-
-We pledge to act and interact in ways that contribute to an open, welcoming,
-diverse, inclusive, and healthy community.
-
-## Our Standards
-
-Examples of behavior that contributes to a positive environment for our
-community include:
-
-* Demonstrating empathy and kindness toward other people
-* Being respectful of differing opinions, viewpoints, and experiences
-* Giving and gracefully accepting constructive feedback
-* Accepting responsibility and apologizing to those affected by our mistakes,
-  and learning from the experience
-* Focusing on what is best not just for us as individuals, but for the
-  overall community
-
-Examples of unacceptable behavior include:
-
-* The use of sexualized language or imagery, and sexual attention or
-  advances of any kind
-* Trolling, insulting or derogatory comments, and personal or political attacks
-* Public or private harassment
-* Publishing others' private information, such as a physical or email
-  address, without their explicit permission
-* Other conduct which could reasonably be considered inappropriate in a
-  professional setting
-
-## Enforcement Responsibilities
-
-Community leaders are responsible for clarifying and enforcing our standards of
-acceptable behavior and will take appropriate and fair corrective action in
-response to any behavior that they deem inappropriate, threatening, offensive,
-or harmful.
-
-Community leaders have the right and responsibility to remove, edit, or reject
-comments, commits, code, wiki edits, issues, and other contributions that are
-not aligned to this Code of Conduct, and will communicate reasons for moderation
-decisions when appropriate.
-
-## Scope
-
-This Code of Conduct applies within all community spaces, and also applies when
-an individual is officially representing the community in public spaces.
-Examples of representing our community include using an official e-mail address,
-posting via an official social media account, or acting as an appointed
-representative at an online or offline event.
-
-## Enforcement
-
-Instances of abusive, harassing, or otherwise unacceptable behavior may be
-reported to the community leaders responsible for enforcement at
-https://forum.ratatui.rs/ or https://discord.gg/pMCEU9hNEj.
-All complaints will be reviewed and investigated promptly and fairly.
-
-All community leaders are obligated to respect the privacy and security of the
-reporter of any incident.
-
-## Enforcement Guidelines
-
-Community leaders will follow these Community Impact Guidelines in determining
-the consequences for any action they deem in violation of this Code of Conduct:
-
-### 1. Correction
-
-**Community Impact**: Use of inappropriate language or other behavior deemed
-unprofessional or unwelcome in the community.
-
-**Consequence**: A private, written warning from community leaders, providing
-clarity around the nature of the violation and an explanation of why the
-behavior was inappropriate. A public apology may be requested.
-
-### 2. Warning
-
-**Community Impact**: A violation through a single incident or series
-of actions.
-
-**Consequence**: A warning with consequences for continued behavior. No
-interaction with the people involved, including unsolicited interaction with
-those enforcing the Code of Conduct, for a specified period of time. This
-includes avoiding interactions in community spaces as well as external channels
-like social media. Violating these terms may lead to a temporary or
-permanent ban.
-
-### 3. Temporary Ban
-
-**Community Impact**: A serious violation of community standards, including
-sustained inappropriate behavior.
-
-**Consequence**: A temporary ban from any sort of interaction or public
-communication with the community for a specified period of time. No public or
-private interaction with the people involved, including unsolicited interaction
-with those enforcing the Code of Conduct, is allowed during this period.
-Violating these terms may lead to a permanent ban.
-
-### 4. Permanent Ban
-
-**Community Impact**: Demonstrating a pattern of violation of community
-standards, including sustained inappropriate behavior,  harassment of an
-individual, or aggression toward or disparagement of classes of individuals.
-
-**Consequence**: A permanent ban from any sort of public interaction within
-the community.
-
-## Attribution
-
-This Code of Conduct is adapted from the [Contributor Covenant][homepage],
-version 2.0, available at
-https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.
-
-Community Impact Guidelines were inspired by [Mozilla's code of conduct
-enforcement ladder](https://github.com/mozilla/diversity).
-
-[homepage]: https://www.contributor-covenant.org
-
-For answers to common questions about this code of conduct, see the FAQ at
-https://www.contributor-covenant.org/faq. Translations are available at
-https://www.contributor-covenant.org/translations.
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -1,211 +0,0 @@
-# Contribution guidelines
-
-First off, thank you for considering contributing to Ratatui.
-
-If your contribution is not straightforward, please first discuss the change you wish to make by
-creating a new issue before making the change, or starting a discussion on
-[discord](https://discord.gg/pMCEU9hNEj).
-
-## Reporting issues
-
-Before reporting an issue on the [issue tracker](https://github.com/ratatui/ratatui/issues),
-please check that it has not already been reported by searching for some related keywords. Please
-also check [`tui-rs` issues](https://github.com/fdehau/tui-rs/issues/) and link any related issues
-found.
-
-## Pull requests
-
-All contributions are obviously welcome. Please include as many details as possible in your PR
-description to help the reviewer (follow the provided template). Make sure to highlight changes
-which may need additional attention, or you are uncertain about. Any idea with a large scale impact
-on the crate or its users should ideally be discussed in a "Feature Request" issue beforehand.
-
-### Keep PRs small, intentional, and focused
-
-Try to do one pull request per change. The time taken to review a PR grows exponential with the size
-of the change. Small focused PRs will generally be much more faster to review. PRs that include both
-refactoring (or reformatting) with actual changes are more difficult to review as every line of the
-change becomes a place where a bug may have been introduced. Consider splitting refactoring /
-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 xtask 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
-history of the project. Please search, read, link, and summarize any relevant
-[issues](https://github.com/fdehau/tui-rs/issues/),
-[discussions](https://github.com/fdehau/tui-rs/discussions/) and [pull
-requests](https://github.com/fdehau/tui-rs/pulls).
-
-### Use conventional commits
-
-We use [conventional commits](https://www.conventionalcommits.org/en/v1.0.0/) and check for them as
-a lint build step. To help adhere to the format, we recommend to install
-[Commitizen](https://commitizen-tools.github.io/commitizen/). By using this tool you automatically
-follow the configuration defined in [.cz.toml](.cz.toml). Your commit messages should have enough
-information to help someone reading the [CHANGELOG](./CHANGELOG.md) understand what is new just from
-the title. The summary helps expand on that to provide information that helps provide more context,
-describes the nature of the problem that the commit is solving and any unintuitive effects of the
-change. It's rare that code changes can easily communicate intent, so make sure this is clearly
-documented.
-
-### Run CI tests before pushing a PR
-
-Running `cargo xtask ci` before pushing will perform the same checks that we do in the CI process.
-It's not mandatory to do this before pushing, however it may save you time to do so instead of
-waiting for GitHub to run the checks.
-
-### Sign your commits
-
-We use commit signature verification, which will block commits from being merged via the UI unless
-they are signed. To set up your machine to sign commits, see [managing commit signature
-verification](https://docs.github.com/en/authentication/managing-commit-signature-verification/about-commit-signature-verification)
-in GitHub docs.
-
-## Implementation Guidelines
-
-### Setup
-
-TL;DR: Clone the repo and build it using `cargo xtask`.
-
-Ratatui is an ordinary Rust project where common tasks are managed with
-[cargo-xtask](https://github.com/matklad/cargo-xtask). It wraps common `cargo` commands with sane
-defaults depending on your platform of choice. Building the project should be as easy as running
-`cargo xtask build`.
-
-```shell
-git clone https://github.com/ratatui/ratatui.git
-cd ratatui
-cargo xtask build
-```
-
-### Tests
-
-The [test coverage](https://app.codecov.io/gh/ratatui/ratatui) of the crate is reasonably
-good, but this can always be improved. Focus on keeping the tests simple and obvious and write unit
-tests for all new or modified code. Beside the usual doc and unit tests, one of the most valuable
-test you can write for Ratatui is a test against the `TestBackend`. It allows you to assert the
-content of the output buffer that would have been flushed to the terminal after a given draw call.
-See `widgets_block_renders` in [tests/widgets_block.rs](./tests/widget_block.rs) for an example.
-
-When writing tests, generally prefer to write unit tests and doc tests directly in the code file
-being tested rather than integration tests in the `tests/` folder.
-
-If an area that you're making a change in is not tested, write tests to characterize the existing
-behavior before changing it. This helps ensure that we don't introduce bugs to existing software
-using Ratatui (and helps make it easy to migrate apps still using `tui-rs`).
-
-For coverage, we have two [bacon](https://dystroy.org/bacon/) jobs (one for all tests, and one for
-unit tests, keyboard shortcuts `v` and `u` respectively) that run
-[cargo-llvm-cov](https://github.com/taiki-e/cargo-llvm-cov) to report the coverage. Several plugins
-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 [VS Code 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]``
-
-### Deprecation notice
-
-We generally want to wait at least two versions before removing deprecated items, so users have
-time to update. However, if a deprecation is blocking for us to implement a new feature we may
-*consider* removing it in a one version notice.
-
-### 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
-may be specific cases that this becomes necessary in order to avoid slowness. Please see [this
-discussion](https://github.com/ratatui/ratatui/discussions/66) for more about the decision.
-
-## Continuous Integration
-
-We use GitHub Actions for the CI where we perform the following checks:
-
- The code should compile on `stable` and the Minimum Supported Rust Version (MSRV).
- The tests (docs, lib, tests and examples) should pass.
- The code should conform to the default format enforced by `rustfmt`.
- The code should not contain common style issues `clippy`.
-
-You can also check most of those things yourself locally using `cargo xtask ci` which will offer you
-a shorter feedback loop than pushing to github.
-
-## Relationship with `tui-rs`
-
-This project was forked from [`tui-rs`](https://github.com/fdehau/tui-rs/) in February 2023, with the
-[blessing of the original author](https://github.com/fdehau/tui-rs/issues/654), Florian Dehau
-([@fdehau](https://github.com/fdehau)).
-
-The original repository contains all the issues, PRs, and discussion that were raised originally, and
-it is useful to refer to when contributing code, documentation, or issues with Ratatui.
-
-We imported all the PRs from the original repository, implemented many of the smaller ones, and
-made notes on the leftovers. These are marked as draft PRs and labelled as [imported from
-tui](https://github.com/ratatui/ratatui/pulls?q=is%3Apr+is%3Aopen+label%3A%22imported+from+tui%22).
-We have documented the current state of those PRs, and anyone is welcome to pick them up and
-continue the work on them.
-
-We have not imported all issues opened on the previous repository. For that reason, anyone wanting
-to **work on or discuss** an issue will have to follow the following workflow:
-
- Recreate the issue
- Start by referencing the **original issue**: ```Referencing issue #[<issue number>](<original
-  issue link>)```
- Then, paste the original issues **opening** text
-
-You can then resume the conversation by replying to this new issue you have created.
--- a/Cargo.lock
+++ b/Cargo.lock
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,97 +1,126 @@
-[workspace]
-resolver = "2"
-members = ["ratatui", "ratatui-*", "xtask", "examples/apps/*"]
-default-members = [
-    "ratatui",
-    "ratatui-core",
-    "ratatui-crossterm",
-    # this is not included as it doesn't compile on windows
-    # "ratatui-termion",
-    "ratatui-termwiz",
-    "ratatui-widgets",
-    "examples/apps/*",
-]
-
-[workspace.package]
-authors = ["Florian Dehau <work@fdehau.com>", "The Ratatui Developers"]
-documentation = "https://docs.rs/ratatui/latest/ratatui/"
-repository = "https://github.com/ratatui/ratatui"
-homepage = "https://ratatui.rs"
+[package]
+name = "tui"
+version = "0.12.0"
+authors = ["Florian Dehau <work@fdehau.com>"]
+description = """
+A library to build rich terminal user interfaces or dashboards
+"""
+documentation = "https://docs.rs/tui/0.10.0/tui/"
 keywords = ["tui", "terminal", "dashboard"]
-categories = ["command-line-interface"]
-readme = "README.md"
+repository = "https://github.com/fdehau/tui-rs"
 license = "MIT"
-exclude = ["assets/*", ".github", "Makefile.toml", "CONTRIBUTING.md", "*.log", "tags"]
-edition = "2021"
-rust-version = "1.74.0"
+exclude = ["assets/*", ".github"]
+autoexamples = true
+edition = "2018"

-[workspace.dependencies]
-bitflags = "2.6.0"
-color-eyre = "0.6.3"
-crossterm = "0.28.1"
-document-features = "0.2.7"
-indoc = "2.0.5"
-instability = "0.3.5"
-itertools = "0.13.0"
-pretty_assertions = "1.4.1"
-ratatui = { path = "ratatui", version = "0.30.0-alpha.0" }
-ratatui-core = { path = "ratatui-core", version = "0.1.0-alpha.0" }
-ratatui-crossterm = { path = "ratatui-crossterm", version = "0.1.0-alpha.0" }
-ratatui-termion = { path = "ratatui-termion", version = "0.1.0-alpha.0" }
-ratatui-termwiz = { path = "ratatui-termwiz", version = "0.1.0-alpha.0" }
-ratatui-widgets = { path = "ratatui-widgets", version = "0.3.0-alpha.0" }
-rstest = "0.23.0"
-serde = { version = "1.0.216", features = ["derive"] }
-serde_json = "1.0.134"
-strum = { version = "0.26.3", features = ["derive"] }
-termwiz = { version = "0.22.0" }
-unicode-segmentation = "1.12.0"
-# See <https://github.com/ratatui/ratatui/issues/1271> for information about why we pin unicode-width
-unicode-width = "=0.2.0"
-termion = "4.0.0"
+[badges]

-# Improve benchmark consistency
-[profile.bench]
-codegen-units = 1
-lto = true
+[features]
+default = ["termion"]
+curses = ["easycurses", "pancurses"]

-[workspace.lints.rust]
-unsafe_code = "forbid"
+[dependencies]
+bitflags = "1.0"
+cassowary = "0.3"
+unicode-segmentation = "1.2"
+unicode-width = "0.1"
+termion = { version = "1.5", optional = true }
+rustbox = { version = "0.11", optional = true }
+crossterm = { version = "0.18", optional = true }
+easycurses = { version = "0.12.2", optional = true }
+pancurses = { version = "0.16.1", optional = true, features = ["win32a"] }
+serde = { version = "1", "optional" = true, features = ["derive"]}

-[workspace.lints.clippy]
-pedantic = { level = "warn", priority = -1 }
-cast_possible_truncation = "allow"
-cast_possible_wrap = "allow"
-cast_precision_loss = "allow"
-cast_sign_loss = "allow"
-missing_errors_doc = "allow"
-missing_panics_doc = "allow"
-module_name_repetitions = "allow"
-must_use_candidate = "allow"
+[dev-dependencies]
+rand = "0.7"
+argh = "0.1"

-# we often split up a module into multiple files with the main type in a file named after the
-# module, so we want to allow this pattern
-module_inception = "allow"
+[[example]]
+name = "canvas"
+path = "examples/canvas.rs"
+required-features = ["termion"]

-# nursery or restricted
-as_underscore = "warn"
-deref_by_slicing = "warn"
-else_if_without_else = "warn"
-empty_line_after_doc_comments = "warn"
-equatable_if_let = "warn"
-fn_to_numeric_cast_any = "warn"
-format_push_string = "warn"
-map_err_ignore = "warn"
-missing_const_for_fn = "warn"
-mixed_read_write_in_expression = "warn"
-mod_module_files = "warn"
-needless_pass_by_ref_mut = "warn"
-needless_raw_strings = "warn"
-or_fun_call = "warn"
-redundant_type_annotations = "warn"
-rest_pat_in_fully_bound_structs = "warn"
-string_lit_chars_any = "warn"
-string_slice = "warn"
-string_to_string = "warn"
-unnecessary_self_imports = "warn"
-use_self = "warn"
+[[example]]
+name = "user_input"
+path = "examples/user_input.rs"
+required-features = ["termion"]
+
+[[example]]
+name = "gauge"
+path = "examples/gauge.rs"
+required-features = ["termion"]
+
+[[example]]
+name = "barchart"
+path = "examples/barchart.rs"
+required-features = ["termion"]
+
+[[example]]
+name = "chart"
+path = "examples/chart.rs"
+required-features = ["termion"]
+
+[[example]]
+name = "paragraph"
+path = "examples/paragraph.rs"
+required-features = ["termion"]
+
+[[example]]
+name = "list"
+path = "examples/list.rs"
+required-features = ["termion"]
+
+[[example]]
+name = "table"
+path = "examples/table.rs"
+required-features = ["termion"]
+
+[[example]]
+name = "tabs"
+path = "examples/tabs.rs"
+required-features = ["termion"]
+
+[[example]]
+name = "custom_widget"
+path = "examples/custom_widget.rs"
+required-features = ["termion"]
+
+[[example]]
+name = "layout"
+path = "examples/layout.rs"
+required-features = ["termion"]
+
+[[example]]
+name = "popup"
+path = "examples/popup.rs"
+required-features = ["termion"]
+
+[[example]]
+name = "block"
+path = "examples/block.rs"
+required-features = ["termion"]
+
+[[example]]
+name = "sparkline"
+path = "examples/sparkline.rs"
+required-features = ["termion"]
+
+[[example]]
+name = "termion_demo"
+path = "examples/termion_demo.rs"
+required-features = ["termion"]
+
+[[example]]
+name = "rustbox_demo"
+path = "examples/rustbox_demo.rs"
+required-features = ["rustbox"]
+
+[[example]]
+name = "crossterm_demo"
+path = "examples/crossterm_demo.rs"
+required-features = ["crossterm"]
+
+[[example]]
+name = "curses_demo"
+path = "examples/curses_demo.rs"
+required-features = ["curses"]
--- a/FUNDING.json
+++ b/FUNDING.json
@@ -1,7 +0,0 @@
-{
-  "drips": {
-    "ethereum": {
-      "ownedBy": "0x6053C8984f4F214Ad12c4653F28514E1E09213B5"
-    }
-  }
-}
--- a/3
+++ b/3
@@ -1,7 +1,6 @@
 The MIT License (MIT)

-Copyright (c) 2016-2022 Florian Dehau
-Copyright (c) 2023-2024 The Ratatui Developers
+Copyright (c) 2016 Florian Dehau

 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
--- a/MAINTAINERS.md
+++ b/MAINTAINERS.md
@@ -1,15 +0,0 @@
-# Maintainers
-
-This file documents current and past maintainers.
-
- [orhun](https://github.com/orhun)
- [joshka](https://github.com/joshka)
- [kdheepak](https://github.com/kdheepak)
- [Valentin271](https://github.com/Valentin271)
-
-## Past Maintainers
-
- [fdehau](https://github.com/fdehau)
- [mindoodoo](https://github.com/mindoodoo)
- [sayanarijit](https://github.com/sayanarijit)
- [EdJoPaTo](https://github.com/EdJoPaTo)
--- a/116
+++ b/116
@@ -0,0 +1,116 @@
+SHELL=/bin/bash
+
+# ================================ Cargo ======================================
+
+
+RUST_CHANNEL ?= stable
+CARGO_FLAGS =
+RUSTUP_INSTALLED = $(shell command -v rustup 2> /dev/null)
+TEST_FILTER ?=
+
+ifndef RUSTUP_INSTALLED
+  CARGO = cargo
+else
+  ifdef CI
+    CARGO = cargo
+  else
+    CARGO = rustup run $(RUST_CHANNEL) cargo
+  endif
+endif
+
+
+# ================================ Help =======================================
+
+.PHONY: help
+help: ## Print all the available commands
+	@grep -E '^[a-zA-Z_-]+:.*?## .*$$' $(MAKEFILE_LIST) | \
+	  awk 'BEGIN {FS = ":.*?## "}; {printf "\033[36m%-20s\033[0m %s\n", $$1, $$2}'
+
+
+# =============================== Build =======================================
+
+.PHONY: check
+check: ## Validate the project code
+	$(CARGO) check
+
+.PHONY: build
+build: ## Build the project in debug mode
+	$(CARGO) build $(CARGO_FLAGS)
+
+.PHONY: release
+release: CARGO_FLAGS += --release
+release: build ## Build the project in release mode
+
+
+# ================================ Lint =======================================
+
+.PHONY: lint
+lint: fmt clippy ## Lint project files
+
+.PHONY: fmt
+fmt: ## Check the format of the source code
+	cargo fmt --all -- --check
+
+.PHONY: clippy
+clippy: ## Check the style of the source code and catch common errors
+	$(CARGO) clippy --all-targets --all-features -- -D warnings
+
+
+# ================================ Test =======================================
+
+.PHONY: test
+test: ## Run the tests
+	$(CARGO) test --all-features $(TEST_FILTER)
+
+# =============================== Examples ====================================
+
+.PHONY: build-examples
+build-examples: ## Build all examples
+	@$(CARGO) build --release --examples --all-features
+
+.PHONY: run-examples
+run-examples: build-examples ## Run all examples
+	@for file in examples/*.rs; do \
+	  name=$$(basename $${file/.rs/}); \
+	  $(CARGO) run --all-features --release --example $$name; \
+	  done;
+
+# ================================ Doc ========================================
+
+
+.PHONY: doc
+doc: RUST_CHANNEL = nightly
+doc: ## Build the documentation (available at ./target/doc)
+	$(CARGO) doc
+
+
+# ================================= Watch =====================================
+
+# Requires watchman and watchman-make (https://facebook.github.io/watchman/docs/install.html)
+
+.PHONY: watch
+watch: ## Watch file changes and build the project if any
+	watchman-make -p 'src/**/*.rs' -t check build
+
+.PHONY: watch-test
+watch-test: ## Watch files changes and run the tests if any
+	watchman-make -p 'src/**/*.rs' 'tests/**/*.rs' 'examples/**/*.rs' -t test
+
+.PHONY: watch-doc
+watch-doc: RUST_CHANNEL = nightly
+watch-doc: ## Watch file changes and rebuild the documentation if any
+	$(CARGO) watch -x doc -x 'test --doc'
+
+# ================================= Pipelines =================================
+
+.PHONY: stable
+stable: RUST_CHANNEL = stable
+stable: build lint test ## Run build and tests for stable
+
+.PHONY: beta
+beta: RUST_CHANNEL = beta
+beta: build lint test ## Run build and tests for beta
+
+.PHONY: nightly
+nightly: RUST_CHANNEL = nightly
+nightly: build lint test ## Run build, lint and tests for nightly
--- a/README.md
+++ b/README.md
@@ -1,171 +1,118 @@
-<details>
-<summary>Table of Contents</summary>
+# tui-rs

- [Quickstart](#quickstart)
- [Documentation](#documentation)
- [Templates](#templates)
- [Built with Ratatui](#built-with-ratatui)
- [Alternatives](#alternatives)
- [Contributing](#contributing)
- [Acknowledgements](#acknowledgements)
- [License](#license)
+[![Build Status](https://github.com/fdehau/tui-rs/workflows/CI/badge.svg)](https://github.com/fdehau/tui-rs/actions?query=workflow%3ACI+)
+[![Crate Status](https://img.shields.io/crates/v/tui.svg)](https://crates.io/crates/tui)
+[![Docs Status](https://docs.rs/tui/badge.svg)](https://docs.rs/crate/tui/)

-</details>
+<img src="./assets/demo.gif" alt="Demo cast under Linux Termite with Inconsolata font 12pt">

-![Demo](https://github.com/ratatui/ratatui/blob/87ae72dbc756067c97f6400d3e2a58eeb383776e/examples/demo2-destroy.gif?raw=true)
+`tui-rs` is a [Rust](https://www.rust-lang.org) library to build rich terminal
+user interfaces and dashboards. It is heavily inspired by the `Javascript`
+library [blessed-contrib](https://github.com/yaronn/blessed-contrib) and the
+`Go` library [termui](https://github.com/gizak/termui).

-<div align="center">
+The library itself supports four different backends to draw to the terminal. You
+can either choose from:

-[![Crate Badge]][Crate] [![Docs Badge]][API Docs] [![CI Badge]][CI Workflow] [![Deps.rs
-Badge]][Deps.rs]<br> [![Codecov Badge]][Codecov] [![License Badge]](./LICENSE) [![Sponsors
-Badge]][GitHub Sponsors]<br>
-[Ratatui Website] · [API Docs] · [Widget Examples] · [App Examples] · [Changelog]<br>
-[Breaking Changes] · [Contributing] · [Report a bug] · [Request a Feature]
+  - [termion](https://github.com/ticki/termion)
+  - [rustbox](https://github.com/gchp/rustbox)
+  - [crossterm](https://github.com/crossterm-rs/crossterm)
+  - [pancurses](https://github.com/ihalila/pancurses)

-</div>
+However, some features may only be available in one of the four.

-[Ratatui][Ratatui Website] (_ˌræ.təˈtu.i_) is a Rust crate for cooking up terminal user interfaces
-(TUIs). It provides a simple and flexible way to create text-based user interfaces in the terminal,
-which can be used for command-line applications, dashboards, and other interactive console programs.
+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.

-## Quickstart
+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.

-Ratatui has [templates] available to help you get started quickly. You can use the
-[`cargo-generate`] command to create a new project with Ratatui:
+### Rust version requirements

-```shell
-cargo install --locked cargo-generate
-cargo generate ratatui/templates
+Since version 0.10.0, `tui` requires **rustc version 1.44.0 or greater**.
+
+### [Documentation](https://docs.rs/tui)
+
+### Demo
+
+The demo shown in the gif can be run with all available backends
+(`examples/*_demo.rs` files). For example to see the `termion` version one could
+run:
+
+```
+cargo run --example termion_demo --release -- --tick-rate 200
 ```

-Selecting the Hello World template produces the following application:
+where `tick-rate` is the UI refresh rate in ms.

-```rust
-use color_eyre::Result;
-use crossterm::event::{self, Event};
-use ratatui::{DefaultTerminal, Frame};
+The UI code is in [examples/demo/ui.rs](examples/demo/ui.rs) while the
+application state is in [examples/demo/app.rs](examples/demo/app.rs).

-fn main() -> Result<()> {
-    color_eyre::install()?;
-    let terminal = ratatui::init();
-    let result = run(terminal);
-    ratatui::restore();
-    result
-}
+Beware that the `termion_demo` only works on Unix platforms. If you are a Windows user,
+you can see the same demo using the `crossterm` backend with the following command:

-fn run(mut terminal: DefaultTerminal) -> Result<()> {
-    loop {
-        terminal.draw(render)?;
-        if matches!(event::read()?, Event::Key(_)) {
-            break Ok(());
-        }
-    }
-}
-
-fn render(frame: &mut Frame) {
-    frame.render_widget("hello world", frame.area());
-}
+```
+cargo run --example crossterm_demo --no-default-features --features="crossterm" --release -- --tick-rate 200
 ```

-See the [documentation](#documentation) for more examples and tutorials.
+If the user interface contains glyphs that are not displayed correctly by your terminal, you may want to run
+the demo without those symbols:

-## Documentation
-
- [Ratatui Website] - explains the library's concepts and provides step-by-step tutorials.
- [Ratatui Forum][Forum] - a place to ask questions and discuss the library.
- [API Docs] - the full API documentation for the library on docs.rs.
- [Widget Examples] - a collection of examples that demonstrate how to use the library.
- [App Examples] - a collection of more complex examples that demonstrate how to build apps.
- [Changelog] - generated by [git-cliff] utilizing [Conventional Commits].
- [Breaking Changes] - a list of breaking changes in the library.
-
-You can also watch the [EuroRust 2024 talk] to learn about common concepts in Ratatui and what's
-possible to build with it.
-
-## Templates
-
-If you're looking to get started quickly, you can use one of the available templates from the
-[templates] repository using [`cargo-generate`]:
-
-```shell
-cargo generate ratatui/templates
+```
+cargo run --example crossterm_demo --no-default-features --features="crossterm" --release -- --tick-rate 200 --enhanced-graphics false
 ```

-## Built with Ratatui
+### Widgets

-[![Awesome](https://awesome.re/badge-flat2.svg)][awesome-ratatui]
+The library comes with the following list of widgets:

-Check out the [showcase] section of the website, or the [awesome-ratatui] repository for a curated
-list of awesome apps and libraries built with Ratatui!
+  * [Block](examples/block.rs)
+  * [Gauge](examples/gauge.rs)
+  * [Sparkline](examples/sparkline.rs)
+  * [Chart](examples/chart.rs)
+  * [BarChart](examples/barchart.rs)
+  * [List](examples/list.rs)
+  * [Table](examples/table.rs)
+  * [Paragraph](examples/paragraph.rs)
+  * [Canvas (with line, point cloud, map)](examples/canvas.rs)
+  * [Tabs](examples/tabs.rs)

-## Alternatives
+Click on each item to see the source of the example. Run the examples with with 
+cargo (e.g. to run the demo `cargo run --example demo`), and quit by pressing `q`.

- [Cursive](https://crates.io/crates/cursive) - a ncurses-based TUI library.
- [iocraft](https://crates.io/crates/iocraft) - a declarative TUI library.
+You can run all examples by running `make run-examples`.

-## Contributing
+### Third-party widgets

-[![Discord Badge]][Discord Server] [![Matrix Badge]][Matrix]
-[![Forum Badge]][Forum]<br>
+* [tui-logger](https://github.com/gin66/tui-logger)

-Feel free to join our [Discord server](https://discord.gg/pMCEU9hNEj) for discussions and questions!
-There is also a [Matrix](https://matrix.org/) bridge available at
-[#ratatui:matrix.org](https://matrix.to/#/#ratatui:matrix.org). We have also recently launched the
-[Ratatui Forum][Forum].
+### Apps using tui

-We rely on GitHub for [bugs][Report a bug] and [feature requests][Request a Feature].
+* [spotify-tui](https://github.com/Rigellute/spotify-tui)
+* [bandwhich](https://github.com/imsnif/bandwhich)
+* [kmon](https://github.com/orhun/kmon)
+* [ytop](https://github.com/cjbassi/ytop)
+* [zenith](https://github.com/bvaisvil/zenith)
+* [bottom](https://github.com/ClementTsang/bottom)
+* [oha](https://github.com/hatoo/oha)
+* [gitui](https://github.com/extrawurst/gitui)
+* [rust-sadari-cli](https://github.com/24seconds/rust-sadari-cli)
+* [desed](https://github.com/SoptikHa2/desed)
+* [diskonaut](https://github.com/imsnif/diskonaut)
+* [tickrs](https://github.com/tarkah/tickrs)
+* [rusty-krab-manager](https://github.com/aryakaul/rusty-krab-manager)
+* [termchat](https://github.com/lemunozm/termchat)

-Please make sure you read the [contributing](./CONTRIBUTING.md) guidelines before [creating a pull
-request][Create a Pull Request].
+### Alternatives

-## Acknowledgements
-
-Ratatui was forked from the [tui-rs] crate in 2023 in order to continue its development. None of
-this could be possible without [Florian Dehau] who originally created [tui-rs] which inspired many
-Rust TUIs.
-
-Special thanks to [Pavel Fomchenkov] for his work in designing an awesome logo for the Ratatui
-project and organization.
+You might want to checkout [Cursive](https://github.com/gyscos/Cursive) for an
+alternative solution to build text user interfaces in Rust.

 ## License

-[MIT](./LICENSE)
-
-[Ratatui Website]: https://ratatui.rs/
-[Forum]: https://forum.ratatui.rs
-[API Docs]: https://docs.rs/ratatui
-[Widget Examples]: https://github.com/ratatui/ratatui/tree/main/ratatui-widgets/examples
-[App Examples]: https://github.com/ratatui/ratatui/tree/main/examples
-[Changelog]: https://github.com/ratatui/ratatui/blob/main/CHANGELOG.md
-[git-cliff]: https://git-cliff.org
-[Conventional Commits]: https://www.conventionalcommits.org
-[Breaking Changes]: https://github.com/ratatui/ratatui/blob/main/BREAKING-CHANGES.md
-[EuroRust 2024 talk]: https://www.youtube.com/watch?v=hWG51Mc1DlM
-[Report a bug]: https://github.com/ratatui/ratatui/issues/new?labels=bug&projects=&template=bug_report.md
-[Request a Feature]: https://github.com/ratatui/ratatui/issues/new?labels=enhancement&projects=&template=feature_request.md
-[Create a Pull Request]: https://github.com/ratatui/ratatui/compare
-[Contributing]: https://github.com/ratatui/ratatui/blob/main/CONTRIBUTING.md
-[Crate]: https://crates.io/crates/ratatui
-[tui-rs]: https://crates.io/crates/tui
-[GitHub Sponsors]: https://github.com/sponsors/ratatui
-[Crate Badge]: https://img.shields.io/crates/v/ratatui?logo=rust&style=flat-square&logoColor=E05D44&color=E05D44
-[License Badge]: https://img.shields.io/crates/l/ratatui?style=flat-square&color=1370D3
-[CI Badge]: https://img.shields.io/github/actions/workflow/status/ratatui/ratatui/ci.yml?style=flat-square&logo=github
-[CI Workflow]: https://github.com/ratatui/ratatui/actions/workflows/ci.yml
-[Codecov Badge]: https://img.shields.io/codecov/c/github/ratatui/ratatui?logo=codecov&style=flat-square&token=BAQ8SOKEST&color=C43AC3&logoColor=C43AC3
-[Codecov]: https://app.codecov.io/gh/ratatui/ratatui
-[Deps.rs Badge]: https://deps.rs/repo/github/ratatui/ratatui/status.svg?path=ratatui&style=flat-square
-[Deps.rs]: https://deps.rs/repo/github/ratatui/ratatui?path=ratatui
-[Discord Badge]: https://img.shields.io/discord/1070692720437383208?label=discord&logo=discord&style=flat-square&color=1370D3&logoColor=1370D3
-[Discord Server]: https://discord.gg/pMCEU9hNEj
-[Docs Badge]: https://img.shields.io/docsrs/ratatui?logo=rust&style=flat-square&logoColor=E05D44
-[Matrix Badge]: https://img.shields.io/matrix/ratatui-general%3Amatrix.org?style=flat-square&logo=matrix&label=Matrix&color=C43AC3
-[Matrix]: https://matrix.to/#/#ratatui:matrix.org
-[Forum Badge]: https://img.shields.io/discourse/likes?server=https%3A%2F%2Fforum.ratatui.rs&style=flat-square&logo=discourse&label=forum&color=C43AC3
-[Sponsors Badge]: https://img.shields.io/github/sponsors/ratatui?logo=github&style=flat-square&color=1370D3
-[templates]: https://github.com/ratatui/templates/
-[showcase]: https://ratatui.rs/showcase/
-[awesome-ratatui]: https://github.com/ratatui/awesome-ratatui
-[Pavel Fomchenkov]: https://github.com/nawok
-[Florian Dehau]: https://github.com/fdehau
-[`cargo-generate`]: https://crates.io/crates/cargo-generate
+[MIT](LICENSE)
--- a/RELEASE.md
+++ b/RELEASE.md
@@ -1,51 +0,0 @@
-# Creating a Release
-
-Our release strategy is:
-
-> Release major versions with detailed summaries when necessary, while releasing minor versions
-> weekly or as needed without extensive announcements.
->
-> Versioning scheme being `0.x.y`, where `x` is the major version and `y` is the minor version.
-
-[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).
-
-   ```shell
-   cargo build --example demo2
-   vhs examples/demo2.tape
-   ```
-
-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/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.
-
-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[0.x.y]`
-1. Push the tag: `git push --tags`
-1. Wait for [Continuous Deployment](https://github.com/ratatui/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/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/ratatui/issues/147) and
-[#359](https://github.com/ratatui/ratatui/pull/359) for more info on the alpha release process.
--- a/SECURITY.md
+++ b/SECURITY.md
@@ -1,9 +0,0 @@
-# Security Policy
-
-## Supported Versions
-
-We only support the latest version of this crate.
-
-## Reporting a Vulnerability
-
-To report secuirity vulnerability, please use the form at <https://github.com/ratatui/ratatui/security/advisories/new>
--- a/assets/demo.gif
+++ b/assets/demo.gif
--- a/assets/favicon.ico
+++ b/assets/favicon.ico
--- a/assets/logo.png
+++ b/assets/logo.png
--- a/bacon.toml
+++ b/bacon.toml
@@ -1,137 +0,0 @@
-# This is a configuration file for the bacon tool
-#
-# Bacon repository: https://github.com/Canop/bacon
-# Complete help on configuration: https://dystroy.org/bacon/config/
-# You can also check bacon's own bacon.toml file
-#  as an example: https://github.com/Canop/bacon/blob/main/bacon.toml
-
-default_job = "check"
-
-[jobs.check]
-command = ["cargo", "check", "--all-features"]
-need_stdout = false
-
-[jobs.check-all]
-command = ["cargo", "check", "--all-targets", "--all-features"]
-need_stdout = false
-
-[jobs.check-crossterm]
-command = [
-    "cargo",
-    "check",
-    "--all-targets",
-    "--no-default-features",
-    "--features",
-    "crossterm",
-]
-need_stdout = false
-
-[jobs.check-termion]
-command = [
-    "cargo",
-    "check",
-    "--all-targets",
-    "--no-default-features",
-    "--features",
-    "termion",
-]
-need_stdout = false
-
-[jobs.check-termwiz]
-command = [
-    "cargo",
-    "check",
-    "--all-targets",
-    "--no-default-features",
-    "--features",
-    "termwiz",
-]
-need_stdout = false
-
-[jobs.clippy]
-command = ["cargo", "clippy", "--all-targets"]
-need_stdout = false
-
-[jobs.test]
-command = ["cargo", "test", "--all-features"]
-need_stdout = true
-
-[jobs.test-unit]
-command = ["cargo", "test", "--lib", "--all-features"]
-need_stdout = true
-
-[jobs.doc]
-command = [
-    "cargo",
-    "+nightly",
-    "doc",
-    "-Zunstable-options",
-    "-Zrustdoc-scrape-examples",
-    "--all-features",
-    "--no-deps",
-]
-env.RUSTDOCFLAGS = "--cfg docsrs"
-need_stdout = false
-
-# If the doc compiles, then it opens in your browser and bacon switches
-# to the previous job
-[jobs.doc-open]
-command = [
-    "cargo",
-    "+nightly",
-    "doc",
-    "-Zunstable-options",
-    "-Zrustdoc-scrape-examples",
-    "--all-features",
-    "--no-deps",
-    "--open",
-]
-env.RUSTDOCFLAGS = "--cfg docsrs"
-need_stdout = false
-on_success = "job:doc" # so that we don't open the browser at each change
-
-[jobs.coverage]
-command = [
-    "cargo",
-    "llvm-cov",
-    "--lcov",
-    "--output-path",
-    "target/lcov.info",
-    "--all-features",
-]
-
-[jobs.coverage-unit-tests-only]
-command = [
-    "cargo",
-    "llvm-cov",
-    "--lcov",
-    "--output-path",
-    "target/lcov.info",
-    "--lib",
-    "--all-features",
-]
-
-[jobs.hack]
-command = [
-    "cargo",
-    "hack",
-    "test",
-    "--lib",
-    "--each-feature",
-    # "--all-targets",
-    "--workspace",
-]
-
-# You may define here keybindings that would be specific to
-# a project, for example a shortcut to launch a specific job.
-# Shortcuts to internal functions (scrolling, toggling, etc.)
-# should go in your personal global prefs.toml file instead.
-[keybindings]
-ctrl-h = "job:hack"
-ctrl-c = "job:check-crossterm"
-ctrl-t = "job:check-termion"
-ctrl-w = "job:check-termwiz"
-v = "job:coverage"
-ctrl-v = "job:coverage-unit-tests-only"
-u = "job:test-unit"
-n = "job:nextest"
--- a/cliff.toml
+++ b/cliff.toml
@@ -1,138 +0,0 @@
-# git-cliff ~ configuration file
-# https://git-cliff.org/docs/configuration
-
-[remote.github]
-owner = "ratatui"
-repo = "ratatui"
-
-[changelog]
-# changelog header
-header = """
-# Changelog
-
-All notable changes to this project will be documented in this file.
-<!-- ignore lint rules that are often triggered by content generated from commits / git-cliff -->
-<!-- markdownlint-disable line-length no-bare-urls ul-style emphasis-style -->
-"""
-# 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.
-body = """
-{%- if not version %}
-## [unreleased]
-{% else -%}
-## [{{ version }}](https://github.com/ratatui/ratatui/releases/tag/{{ version }}) - {{ timestamp | date(format="%Y-%m-%d") }}
-{% endif -%}
-
-{% macro commit(commit) -%}
- [{{ commit.id | truncate(length=7, end="") }}]({{ "https://github.com/ratatui/ratatui/commit/" ~ commit.id }}) \
-  *({{commit.scope | default(value = "uncategorized") | lower }})* {{ commit.message | upper_first | trim }}\
-  {% if commit.remote.username %} by @{{ commit.remote.username }}{%- endif -%}\
-  {% if commit.remote.pr_number %} in [#{{ commit.remote.pr_number }}]({{ self::remote_url() }}/pull/{{ commit.remote.pr_number }}){%- endif %}\
-{%- if commit.breaking %} [**breaking**]{% endif %}
-{% endmacro -%}
-
-{% 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 %}
-
-{% if github.contributors | filter(attribute="is_first_time", value=true) | length != 0 %}
-### New Contributors
-{%- endif %}\
-{% for contributor in github.contributors | filter(attribute="is_first_time", value=true) %}
-* @{{ contributor.username }} made their first contribution
-{%- if contributor.pr_number %} in \
-[#{{ contributor.pr_number }}]({{ self::remote_url() }}/pull/{{ contributor.pr_number }}) \
-{%- endif %}
-{%- endfor -%}
-
-{% if version %}
-{% if previous.version %}
-**Full Changelog**: {{ self::remote_url() }}/compare/{{ previous.version }}...{{ version }}
-{% endif %}
-{% else -%}
-  {% raw %}\n{% endraw %}
-{% endif %}
-
-{%- macro remote_url() -%}
-https://github.com/{{ remote.github.owner }}/{{ remote.github.repo }}\
-{% endmacro %}
-"""
-
-
-# remove the leading and trailing whitespace from the template
-trim = false
-# changelog footer
-footer = """
-<!-- generated by git-cliff -->
-"""
-postprocessors = [
-  { pattern = '<!-- Please read CONTRIBUTING.md before submitting any pull request. -->', replace = "" },
-  { pattern = '>---+\n', replace = '' },
-  { pattern = ' +\n', replace = "\n" },
-]
-
-[git]
-# parse the commits based on https://www.conventionalcommits.org
-conventional_commits = true
-# filter out the commits that are not conventional
-filter_unconventional = true
-# process each line of a commit as an individual commit
-split_commits = false
-# regex for preprocessing the commit messages
-commit_preprocessors = [
-  { pattern = '\((\w+\s)?#([0-9]+)\)', replace = "" },
-  { 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" },
-]
-
-# protect breaking changes from being skipped due to matching a skipping commit_parser
-protect_breaking_commits = false
-# filter out the commits that are not matched by commit parsers
-filter_commits = false
-# glob pattern for matching git tags
-tag_pattern = "v[0-9]*"
-# regex for skipping tags
-skip_tags = "v0.1.0-rc.1"
-# regex for ignoring tags
-ignore_tags = "alpha"
-# sort the tags topologically
-topo_order = false
-# sort the commits inside sections by oldest/newest order
-sort_commits = "newest"
--- a/clippy.toml
+++ b/clippy.toml
@@ -1 +0,0 @@
-avoid-breaking-exported-api = false
--- a/codecov.yml
+++ b/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
--- a/committed.toml
+++ b/committed.toml
@@ -1,30 +0,0 @@
-# configuration for https://github.com/crate-ci/committed
-
-# https://www.conventionalcommits.org
-style = "conventional"
-# disallow merge commits
-merge_commit = false
-# subject is not required to be capitalized
-subject_capitalized = false
-# subject should start with an imperative verb
-imperative_subject = true
-# subject should not end with a punctuation
-subject_not_punctuated = true
-# disable line length
-line_length = 0
-# disable subject length
-subject_length = 0
-# default allowed_types [ "chore", "docs", "feat", "fix", "perf", "refactor", "style", "test" ]
-allowed_types = [
-  "build",
-  "chore",
-  "ci",
-  "docs",
-  "feat",
-  "fix",
-  "perf",
-  "refactor",
-  "revert",
-  "style",
-  "test",
-]
--- a/deny.toml
+++ b/deny.toml
@@ -1,40 +0,0 @@
-# configuration for https://github.com/EmbarkStudios/cargo-deny
-
-[licenses]
-version = 2
-confidence-threshold = 0.8
-allow = [
-    "Apache-2.0",
-    "BSD-2-Clause",
-    "BSD-3-Clause",
-    "ISC",
-    "MIT",
-    "OpenSSL",
-    "Unicode-3.0",
-    "Unicode-DFS-2016",
-    "WTFPL",
-    "Zlib",
-]
-
-[advisories]
-version = 2
-
-[bans]
-multiple-versions = "allow"
-
-[sources]
-unknown-registry = "deny"
-unknown-git = "warn"
-allow-registry = ["https://github.com/rust-lang/crates.io-index"]
-
-[[licenses.clarify]]
-crate = "ring"
-# SPDX considers OpenSSL to encompass both the OpenSSL and SSLeay licenses
-# https://spdx.org/licenses/OpenSSL.html
-# ISC - Both BoringSSL and ring use this for their new files
-# MIT - "Files in third_party/ have their own licenses, as described therein. The MIT
-# license, for third_party/fiat, which, unlike other third_party directories, is
-# compiled into non-test libraries, is included below."
-# OpenSSL - Obviously
-expression = "ISC AND MIT AND OpenSSL"
-license-files = [{ path = "LICENSE", hash = 0xbd0eed23 }]
--- a/examples/README.md
+++ b/examples/README.md
@@ -1,66 +0,0 @@
-# Examples
-
-This folder contains examples that are more app focused. There are also other examples in example
-folders under each crate folder e.g. [ratatui examples], [ratatui-widgets examples].
-
-[ratatui examples]: ../ratatui/examples
-[ratatui-widgets examples]: ../ratatui-widgets/examples
-
-You can run these examples using:
-
-```shell
-cargo run -p example-name
-```
-
-This folder might use unreleased code. Consider viewing the examples in the `latest` branch instead
-of the `main` branch for code which is guaranteed to work with the released ratatui version.
-
-> [!WARNING]
->
-> There may be backwards incompatible changes in these examples, as they are designed to compile
-> against the `main` branch.
->
-> There are a few workaround for this problem:
->
-> - View the examples as they were when the latest version was release by selecting the tag that
->   matches that version. E.g. <https://github.com/ratatui/ratatui/tree/v0.26.1/examples>.
-> - If you're viewing this file on GitHub, there is a combo box at the top of this page which
->   allows you to select any previous tagged version.
-> - To view the code locally, checkout the tag. E.g. `git switch --detach v0.26.1`.
-> - Use the latest [alpha version of Ratatui] in your app. These are released weekly on Saturdays.
-> - Compile your code against the main branch either locally by adding e.g. `path = "../ratatui"` to
->   the dependency, or remotely by adding `git = "https://github.com/ratatui/ratatui"`
->
-> For a list of unreleased breaking changes, see [BREAKING-CHANGES.md].
->
-> We don't keep the CHANGELOG updated with unreleased changes, check the git commit history or run
-> `git-cliff -u` against a cloned version of this repository.
-
-## Demo
-
-This is the original demo example from the main README. It is available for each of the backends.
-[Source](./apps/demo/).
-
-![Demo](https://github.com/ratatui/ratatui/blob/images/examples/demo.gif?raw=true)
-
-## Demo2
-
-This is the demo example from the main README and crate page. [Source](./apps/demo2/).
-
-![Demo2](https://github.com/ratatui/ratatui/blob/images/examples/demo2.gif?raw=true)
-
-## Mouse Drawing demo
-
-Shows how to handle mouse events. [Source](./apps/mouse-drawing/).
-
-## Async GitHub demo
-
-Shows how to fetch data from GitHub API asynchronously. [Source](./apps/async-github/).
-
-## Weather demo
-
-Shows how to render weather data using barchart widget. [Source](./apps/weather/).
-
-## Calendar explorer demo
-
-Shows how to render a calendar with different styles. [Source](./apps/calendar-explorer/).
--- a/examples/apps/async-github/Cargo.toml
+++ b/examples/apps/async-github/Cargo.toml
@@ -1,22 +0,0 @@
-[package]
-name = "async-github"
-version = "0.1.0"
-authors.workspace = true
-documentation.workspace = true
-repository.workspace = true
-homepage.workspace = true
-keywords.workspace = true
-categories.workspace = true
-readme.workspace = true
-license.workspace = true
-exclude.workspace = true
-edition.workspace = true
-rust-version.workspace = true
-
-[dependencies]
-color-eyre = "0.6.3"
-crossterm = { workspace = true, features = ["event-stream"] }
-octocrab = "0.42.1"
-ratatui.workspace = true
-tokio = { version = "1.42.0", features = ["rt-multi-thread", "macros"] }
-tokio-stream = "0.1.17"
--- a/examples/apps/async-github/README.md
+++ b/examples/apps/async-github/README.md
@@ -1,9 +0,0 @@
-# Async GitHub demo
-
-This example demonstrates how to use Ratatui with widgets that fetch data from GitHub API asynchronously.
-
-To run this demo:
-
-```shell
-cargo run -p async-github
-```
--- a/examples/apps/async-github/src/main.rs
+++ b/examples/apps/async-github/src/main.rs
@@ -1,243 +0,0 @@
-//! # [Ratatui] Async example
-//!
-//! This example demonstrates how to use Ratatui with widgets that fetch data asynchronously. It
-//! uses the `octocrab` crate to fetch a list of pull requests from the GitHub API.
-//!
-//! <https://docs.github.com/en/authentication/keeping-your-account-and-data-secure/managing-your-personal-access-tokens#creating-a-fine-grained-personal-access-token>
-//! <https://github.com/settings/tokens/new> to create a new token (select classic, and no scopes)
-//!
-//! This example does not cover message passing between threads, it only demonstrates how to manage
-//! shared state between the main thread and a background task, which acts mostly as a one-shot
-//! fetcher. For more complex scenarios, you may need to use channels or other synchronization
-//! primitives.
-//!
-//! A simple app might have multiple widgets that fetch data from different sources, and each widget
-//! would have its own background task to fetch the data. The main thread would then render the
-//! widgets with the latest data.
-//!
-//! The latest version of this example is available in the [examples] folder in the repository.
-//!
-//! Please note that the examples are designed to be run against the `main` branch of the Github
-//! repository. This means that you may not be able to compile with the latest release version on
-//! crates.io, or the one that you have installed locally.
-//!
-//! See the [examples readme] for more information on finding examples that match the version of the
-//! library you are using.
-//!
-//! [Ratatui]: https://github.com/ratatui/ratatui
-//! [examples]: https://github.com/ratatui/ratatui/blob/main/examples
-//! [examples readme]: https://github.com/ratatui/ratatui/blob/main/examples/README.md
-use std::{
-    sync::{Arc, RwLock},
-    time::Duration,
-};
-
-use color_eyre::Result;
-use octocrab::{
-    params::{pulls::Sort, Direction},
-    Page,
-};
-use ratatui::{
-    buffer::Buffer,
-    crossterm::event::{Event, EventStream, KeyCode, KeyEventKind},
-    layout::{Constraint, Layout, Rect},
-    style::{Style, Stylize},
-    text::Line,
-    widgets::{Block, HighlightSpacing, Row, StatefulWidget, Table, TableState, Widget},
-    DefaultTerminal, Frame,
-};
-use tokio_stream::StreamExt;
-
-#[tokio::main]
-async fn main() -> Result<()> {
-    color_eyre::install()?;
-    let terminal = ratatui::init();
-    let app_result = App::default().run(terminal).await;
-    ratatui::restore();
-    app_result
-}
-
-#[derive(Debug, Default)]
-struct App {
-    should_quit: bool,
-    pull_requests: PullRequestListWidget,
-}
-
-impl App {
-    const FRAMES_PER_SECOND: f32 = 60.0;
-
-    pub async fn run(mut self, mut terminal: DefaultTerminal) -> Result<()> {
-        self.pull_requests.run();
-
-        let period = Duration::from_secs_f32(1.0 / Self::FRAMES_PER_SECOND);
-        let mut interval = tokio::time::interval(period);
-        let mut events = EventStream::new();
-
-        while !self.should_quit {
-            tokio::select! {
-                _ = interval.tick() => { terminal.draw(|frame| self.draw(frame))?; },
-                Some(Ok(event)) = events.next() => self.handle_event(&event),
-            }
-        }
-        Ok(())
-    }
-
-    fn draw(&self, frame: &mut Frame) {
-        let vertical = Layout::vertical([Constraint::Length(1), Constraint::Fill(1)]);
-        let [title_area, body_area] = vertical.areas(frame.area());
-        let title = Line::from("Ratatui async example").centered().bold();
-        frame.render_widget(title, title_area);
-        frame.render_widget(&self.pull_requests, body_area);
-    }
-
-    fn handle_event(&mut self, event: &Event) {
-        if let Event::Key(key) = event {
-            if key.kind == KeyEventKind::Press {
-                match key.code {
-                    KeyCode::Char('q') | KeyCode::Esc => self.should_quit = true,
-                    KeyCode::Char('j') | KeyCode::Down => self.pull_requests.scroll_down(),
-                    KeyCode::Char('k') | KeyCode::Up => self.pull_requests.scroll_up(),
-                    _ => {}
-                }
-            }
-        }
-    }
-}
-
-/// A widget that displays a list of pull requests.
-///
-/// This is an async widget that fetches the list of pull requests from the GitHub API. It contains
-/// an inner `Arc<RwLock<PullRequestListState>>` that holds the state of the widget. Cloning the
-/// widget will clone the Arc, so you can pass it around to other threads, and this is used to spawn
-/// a background task to fetch the pull requests.
-#[derive(Debug, Clone, Default)]
-struct PullRequestListWidget {
-    state: Arc<RwLock<PullRequestListState>>,
-}
-
-#[derive(Debug, Default)]
-struct PullRequestListState {
-    pull_requests: Vec<PullRequest>,
-    loading_state: LoadingState,
-    table_state: TableState,
-}
-
-#[derive(Debug, Clone)]
-struct PullRequest {
-    id: String,
-    title: String,
-    url: String,
-}
-
-#[derive(Debug, Clone, Default, PartialEq, Eq)]
-enum LoadingState {
-    #[default]
-    Idle,
-    Loading,
-    Loaded,
-    Error(String),
-}
-
-impl PullRequestListWidget {
-    /// Start fetching the pull requests in the background.
-    ///
-    /// This method spawns a background task that fetches the pull requests from the GitHub API.
-    /// The result of the fetch is then passed to the `on_load` or `on_err` methods.
-    fn run(&self) {
-        let this = self.clone(); // clone the widget to pass to the background task
-        tokio::spawn(this.fetch_pulls());
-    }
-
-    async fn fetch_pulls(self) {
-        // this runs once, but you could also run this in a loop, using a channel that accepts
-        // messages to refresh on demand, or with an interval timer to refresh every N seconds
-        self.set_loading_state(LoadingState::Loading);
-        match octocrab::instance()
-            .pulls("ratatui", "ratatui")
-            .list()
-            .sort(Sort::Updated)
-            .direction(Direction::Descending)
-            .send()
-            .await
-        {
-            Ok(page) => self.on_load(&page),
-            Err(err) => self.on_err(&err),
-        }
-    }
-    fn on_load(&self, page: &Page<OctoPullRequest>) {
-        let prs = page.items.iter().map(Into::into);
-        let mut state = self.state.write().unwrap();
-        state.loading_state = LoadingState::Loaded;
-        state.pull_requests.extend(prs);
-        if !state.pull_requests.is_empty() {
-            state.table_state.select(Some(0));
-        }
-    }
-
-    fn on_err(&self, err: &octocrab::Error) {
-        self.set_loading_state(LoadingState::Error(err.to_string()));
-    }
-
-    fn set_loading_state(&self, state: LoadingState) {
-        self.state.write().unwrap().loading_state = state;
-    }
-
-    fn scroll_down(&self) {
-        self.state.write().unwrap().table_state.scroll_down_by(1);
-    }
-
-    fn scroll_up(&self) {
-        self.state.write().unwrap().table_state.scroll_up_by(1);
-    }
-}
-
-type OctoPullRequest = octocrab::models::pulls::PullRequest;
-
-impl From<&OctoPullRequest> for PullRequest {
-    fn from(pr: &OctoPullRequest) -> Self {
-        Self {
-            id: pr.number.to_string(),
-            title: pr.title.as_ref().unwrap().to_string(),
-            url: pr
-                .html_url
-                .as_ref()
-                .map(ToString::to_string)
-                .unwrap_or_default(),
-        }
-    }
-}
-
-impl Widget for &PullRequestListWidget {
-    fn render(self, area: Rect, buf: &mut Buffer) {
-        let mut state = self.state.write().unwrap();
-
-        // a block with a right aligned title with the loading state on the right
-        let loading_state = Line::from(format!("{:?}", state.loading_state)).right_aligned();
-        let block = Block::bordered()
-            .title("Pull Requests")
-            .title(loading_state)
-            .title_bottom("j/k to scroll, q to quit");
-
-        // a table with the list of pull requests
-        let rows = state.pull_requests.iter();
-        let widths = [
-            Constraint::Length(5),
-            Constraint::Fill(1),
-            Constraint::Max(49),
-        ];
-        let table = Table::new(rows, widths)
-            .block(block)
-            .highlight_spacing(HighlightSpacing::Always)
-            .highlight_symbol(">>")
-            .row_highlight_style(Style::new().on_blue());
-
-        StatefulWidget::render(table, area, buf, &mut state.table_state);
-    }
-}
-
-impl From<&PullRequest> for Row<'_> {
-    fn from(pr: &PullRequest) -> Self {
-        let pr = pr.clone();
-        Row::new(vec![pr.id, pr.title, pr.url])
-    }
-}
--- a/examples/apps/calendar-explorer/Cargo.toml
+++ b/examples/apps/calendar-explorer/Cargo.toml
@@ -1,15 +0,0 @@
-[package]
-name = "calendar-explorer"
-publish = false
-license.workspace = true
-edition.workspace = true
-rust-version.workspace = true
-
-[dependencies]
-color-eyre.workspace = true
-crossterm.workspace = true
-ratatui.workspace = true
-time = { version = "0.3.37", features = ["formatting", "parsing"] }
-
-[lints]
-workspace = true
--- a/examples/apps/calendar-explorer/README.md
+++ b/examples/apps/calendar-explorer/README.md
@@ -1,9 +0,0 @@
-# Calendar explorer demo
-
-This example shows how to render a calendar with different styles.
-
-To run this demo:
-
-```shell
-cargo run -p calendar-explorer
-```
--- a/examples/apps/calendar-explorer/src/main.rs
+++ b/examples/apps/calendar-explorer/src/main.rs
@@ -1,248 +0,0 @@
-//! A Ratatui example that demonstrates how to render calendar with different styles.
-//!
-//! Marks the holidays and seasons on the calendar.
-//!
-//! This example runs with the Ratatui library code in the branch that you are currently reading.
-//! See the [`latest`] branch for the code which works with the most recent Ratatui release.
-//!
-//! [`latest`]: https://github.com/ratatui/ratatui/tree/latest
-//! [`BarChart`]: https://docs.rs/ratatui/latest/ratatui/widgets/struct.BarChart.html
-
-use std::fmt;
-
-use color_eyre::Result;
-use crossterm::event::{self, Event, KeyCode, KeyEventKind};
-use ratatui::{
-    layout::{Constraint, Layout, Margin, Rect},
-    style::{Color, Modifier, Style, Stylize},
-    text::{Line, Text},
-    widgets::calendar::{CalendarEventStore, Monthly},
-    DefaultTerminal, Frame,
-};
-use time::{ext::NumericalDuration, Date, Month, OffsetDateTime};
-
-fn main() -> Result<()> {
-    color_eyre::install()?;
-    let terminal = ratatui::init();
-    let result = run(terminal);
-    ratatui::restore();
-    result
-}
-
-/// Run the application.
-fn run(mut terminal: DefaultTerminal) -> Result<()> {
-    let mut selected_date = OffsetDateTime::now_local()?.date();
-    let mut calendar_style = StyledCalendar::Default;
-    loop {
-        terminal.draw(|frame| render(frame, calendar_style, selected_date))?;
-        if let Event::Key(key) = event::read()? {
-            if key.kind == KeyEventKind::Press {
-                match key.code {
-                    KeyCode::Char('q') => break Ok(()),
-                    KeyCode::Char('s') => calendar_style = calendar_style.next(),
-                    KeyCode::Char('n') | KeyCode::Tab => selected_date = next_month(selected_date),
-                    KeyCode::Char('p') | KeyCode::BackTab => {
-                        selected_date = previous_month(selected_date);
-                    }
-                    KeyCode::Char('h') | KeyCode::Left => selected_date -= 1.days(),
-                    KeyCode::Char('j') | KeyCode::Down => selected_date += 1.weeks(),
-                    KeyCode::Char('k') | KeyCode::Up => selected_date -= 1.weeks(),
-                    KeyCode::Char('l') | KeyCode::Right => selected_date += 1.days(),
-                    _ => {}
-                }
-            }
-        }
-    }
-}
-
-fn next_month(date: Date) -> Date {
-    if date.month() == Month::December {
-        date.replace_month(Month::January)
-            .unwrap()
-            .replace_year(date.year() + 1)
-            .unwrap()
-    } else {
-        date.replace_month(date.month().next()).unwrap()
-    }
-}
-
-fn previous_month(date: Date) -> Date {
-    if date.month() == Month::January {
-        date.replace_month(Month::December)
-            .unwrap()
-            .replace_year(date.year() - 1)
-            .unwrap()
-    } else {
-        date.replace_month(date.month().previous()).unwrap()
-    }
-}
-
-/// Draw the UI with a calendar.
-fn render(frame: &mut Frame, calendar_style: StyledCalendar, selected_date: Date) {
-    let header = Text::from_iter([
-        Line::from("Calendar Example".bold()),
-        Line::from(
-            "<q> Quit | <s> Change Style | <n> Next Month | <p> Previous Month, <hjkl> Move",
-        ),
-        Line::from(format!(
-            "Current date: {selected_date} | Current style: {calendar_style}"
-        )),
-    ]);
-
-    let vertical = Layout::vertical([
-        Constraint::Length(header.height() as u16),
-        Constraint::Fill(1),
-    ]);
-    let [text_area, area] = vertical.areas(frame.area());
-    frame.render_widget(header.centered(), text_area);
-    calendar_style
-        .render_year(frame, area, selected_date)
-        .unwrap();
-}
-
-#[derive(Debug, Clone, Copy)]
-enum StyledCalendar {
-    Default,
-    Surrounding,
-    WeekdaysHeader,
-    SurroundingAndWeekdaysHeader,
-    MonthHeader,
-    MonthAndWeekdaysHeader,
-}
-
-impl StyledCalendar {
-    // Cycle through the different styles.
-    const fn next(self) -> Self {
-        match self {
-            Self::Default => Self::Surrounding,
-            Self::Surrounding => Self::WeekdaysHeader,
-            Self::WeekdaysHeader => Self::SurroundingAndWeekdaysHeader,
-            Self::SurroundingAndWeekdaysHeader => Self::MonthHeader,
-            Self::MonthHeader => Self::MonthAndWeekdaysHeader,
-            Self::MonthAndWeekdaysHeader => Self::Default,
-        }
-    }
-}
-
-impl fmt::Display for StyledCalendar {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Self::Default => write!(f, "Default"),
-            Self::Surrounding => write!(f, "Show Surrounding"),
-            Self::WeekdaysHeader => write!(f, "Show Weekdays Header"),
-            Self::SurroundingAndWeekdaysHeader => write!(f, "Show Surrounding and Weekdays Header"),
-            Self::MonthHeader => write!(f, "Show Month Header"),
-            Self::MonthAndWeekdaysHeader => write!(f, "Show Month Header and Weekdays Header"),
-        }
-    }
-}
-
-impl StyledCalendar {
-    fn render_year(self, frame: &mut Frame, area: Rect, date: Date) -> Result<()> {
-        let events = events(date)?;
-
-        let area = area.inner(Margin {
-            vertical: 1,
-            horizontal: 1,
-        });
-        let rows = Layout::vertical([Constraint::Ratio(1, 3); 3]).split(area);
-        let areas = rows.iter().flat_map(|row| {
-            Layout::horizontal([Constraint::Ratio(1, 4); 4])
-                .split(*row)
-                .to_vec()
-        });
-        for (i, area) in areas.enumerate() {
-            let month = date
-                .replace_day(1)
-                .unwrap()
-                .replace_month(Month::try_from(i as u8 + 1).unwrap())
-                .unwrap();
-            self.render_month(frame, area, month, &events);
-        }
-        Ok(())
-    }
-
-    fn render_month(self, frame: &mut Frame, area: Rect, date: Date, events: &CalendarEventStore) {
-        let calendar = match self {
-            Self::Default => Monthly::new(date, events)
-                .default_style(Style::new().bold().bg(Color::Rgb(50, 50, 50)))
-                .show_month_header(Style::default()),
-            Self::Surrounding => Monthly::new(date, events)
-                .default_style(Style::new().bold().bg(Color::Rgb(50, 50, 50)))
-                .show_month_header(Style::default())
-                .show_surrounding(Style::new().dim()),
-            Self::WeekdaysHeader => Monthly::new(date, events)
-                .default_style(Style::new().bold().bg(Color::Rgb(50, 50, 50)))
-                .show_month_header(Style::default())
-                .show_weekdays_header(Style::new().bold().green()),
-            Self::SurroundingAndWeekdaysHeader => Monthly::new(date, events)
-                .default_style(Style::new().bold().bg(Color::Rgb(50, 50, 50)))
-                .show_month_header(Style::default())
-                .show_surrounding(Style::new().dim())
-                .show_weekdays_header(Style::new().bold().green()),
-            Self::MonthHeader => Monthly::new(date, events)
-                .default_style(Style::new().bold().bg(Color::Rgb(50, 50, 50)))
-                .show_month_header(Style::default())
-                .show_month_header(Style::new().bold().green()),
-            Self::MonthAndWeekdaysHeader => Monthly::new(date, events)
-                .default_style(Style::new().bold().bg(Color::Rgb(50, 50, 50)))
-                .show_month_header(Style::default())
-                .show_weekdays_header(Style::new().bold().dim().light_yellow()),
-        };
-        frame.render_widget(calendar, area);
-    }
-}
-
-/// Makes a list of dates for the current year.
-fn events(selected_date: Date) -> Result<CalendarEventStore> {
-    const SELECTED: Style = Style::new()
-        .fg(Color::White)
-        .bg(Color::Red)
-        .add_modifier(Modifier::BOLD);
-    const HOLIDAY: Style = Style::new()
-        .fg(Color::Red)
-        .add_modifier(Modifier::UNDERLINED);
-    const SEASON: Style = Style::new()
-        .fg(Color::Green)
-        .bg(Color::Black)
-        .add_modifier(Modifier::UNDERLINED);
-
-    let mut list = CalendarEventStore::today(
-        Style::default()
-            .add_modifier(Modifier::BOLD)
-            .bg(Color::Blue),
-    );
-    let y = selected_date.year();
-
-    // new year's
-    list.add(Date::from_calendar_date(y, Month::January, 1)?, HOLIDAY);
-    // next new_year's for December "show surrounding"
-    list.add(Date::from_calendar_date(y + 1, Month::January, 1)?, HOLIDAY);
-    // groundhog day
-    list.add(Date::from_calendar_date(y, Month::February, 2)?, HOLIDAY);
-    // april fool's
-    list.add(Date::from_calendar_date(y, Month::April, 1)?, HOLIDAY);
-    // earth day
-    list.add(Date::from_calendar_date(y, Month::April, 22)?, HOLIDAY);
-    // star wars day
-    list.add(Date::from_calendar_date(y, Month::May, 4)?, HOLIDAY);
-    // festivus
-    list.add(Date::from_calendar_date(y, Month::December, 23)?, HOLIDAY);
-    // new year's eve
-    list.add(Date::from_calendar_date(y, Month::December, 31)?, HOLIDAY);
-
-    // seasons
-    // spring equinox
-    list.add(Date::from_calendar_date(y, Month::March, 22)?, SEASON);
-    // summer solstice
-    list.add(Date::from_calendar_date(y, Month::June, 21)?, SEASON);
-    // fall equinox
-    list.add(Date::from_calendar_date(y, Month::September, 22)?, SEASON);
-    // winter solstice
-    list.add(Date::from_calendar_date(y, Month::December, 21)?, SEASON);
-
-    // selected date
-    list.add(selected_date, SELECTED);
-
-    Ok(list)
-}
--- a/examples/apps/canvas/Cargo.toml
+++ b/examples/apps/canvas/Cargo.toml
@@ -1,15 +0,0 @@
-[package]
-name = "canvas"
-publish = false
-license.workspace = true
-edition.workspace = true
-rust-version.workspace = true
-
-[dependencies]
-color-eyre.workspace = true
-crossterm.workspace = true
-itertools.workspace = true
-ratatui.workspace = true
-
-[lints]
-workspace = true
--- a/examples/apps/canvas/README.md
+++ b/examples/apps/canvas/README.md
@@ -1,9 +0,0 @@
-# Canvas demo
-
-This example shows how to render various shapes and a map on a canvas.
-
-To run this demo:
-
-```shell
-cargo run -p canvas
-```
--- a/examples/apps/canvas/src/main.rs
+++ b/examples/apps/canvas/src/main.rs
@@ -1,265 +0,0 @@
-/// A Ratatui example that demonstrates how to draw on a canvas.
-///
-/// This example demonstrates how to draw various shapes such as rectangles, circles, and lines
-/// on a canvas. It also demonstrates how to draw a map.
-///
-/// This example runs with the Ratatui library code in the branch that you are currently
-/// reading. See the [`latest`] branch for the code which works with the most recent Ratatui
-/// release.
-///
-/// [`latest`]: https://github.com/ratatui/ratatui/tree/latest
-use std::{
-    io::stdout,
-    time::{Duration, Instant},
-};
-
-use color_eyre::Result;
-use crossterm::{
-    event::{DisableMouseCapture, EnableMouseCapture, KeyEventKind},
-    ExecutableCommand,
-};
-use itertools::Itertools;
-use ratatui::{
-    crossterm::event::{self, Event, KeyCode, MouseEventKind},
-    layout::{Constraint, Layout, Position, Rect},
-    style::{Color, Stylize},
-    symbols::Marker,
-    text::Text,
-    widgets::{
-        canvas::{Canvas, Circle, Map, MapResolution, Points, Rectangle},
-        Block, Widget,
-    },
-    DefaultTerminal, Frame,
-};
-
-fn main() -> Result<()> {
-    color_eyre::install()?;
-    stdout().execute(EnableMouseCapture)?;
-    let terminal = ratatui::init();
-    let app_result = App::new().run(terminal);
-    ratatui::restore();
-    stdout().execute(DisableMouseCapture)?;
-    app_result
-}
-
-struct App {
-    exit: bool,
-    x: f64,
-    y: f64,
-    ball: Circle,
-    playground: Rect,
-    vx: f64,
-    vy: f64,
-    marker: Marker,
-    points: Vec<Position>,
-    is_drawing: bool,
-}
-
-impl App {
-    const fn new() -> Self {
-        Self {
-            exit: false,
-            x: 0.0,
-            y: 0.0,
-            ball: Circle {
-                x: 20.0,
-                y: 40.0,
-                radius: 10.0,
-                color: Color::Yellow,
-            },
-            playground: Rect::new(10, 10, 200, 100),
-            vx: 1.0,
-            vy: 1.0,
-            marker: Marker::Dot,
-            points: vec![],
-            is_drawing: false,
-        }
-    }
-
-    pub fn run(mut self, mut terminal: DefaultTerminal) -> Result<()> {
-        let tick_rate = Duration::from_millis(16);
-        let mut last_tick = Instant::now();
-        while !self.exit {
-            terminal.draw(|frame| self.draw(frame))?;
-            let timeout = tick_rate.saturating_sub(last_tick.elapsed());
-            if event::poll(timeout)? {
-                match event::read()? {
-                    Event::Key(key) => self.handle_key_press(key),
-                    Event::Mouse(event) => self.handle_mouse_event(event),
-                    _ => (),
-                }
-            }
-
-            if last_tick.elapsed() >= tick_rate {
-                self.on_tick();
-                last_tick = Instant::now();
-            }
-        }
-        Ok(())
-    }
-
-    fn handle_key_press(&mut self, key: event::KeyEvent) {
-        if key.kind != KeyEventKind::Press {
-            return;
-        }
-        match key.code {
-            KeyCode::Char('q') => self.exit = true,
-            KeyCode::Down | KeyCode::Char('j') => self.y += 1.0,
-            KeyCode::Up | KeyCode::Char('k') => self.y -= 1.0,
-            KeyCode::Right | KeyCode::Char('l') => self.x += 1.0,
-            KeyCode::Left | KeyCode::Char('h') => self.x -= 1.0,
-            KeyCode::Enter => {
-                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,
-                };
-            }
-            _ => {}
-        }
-    }
-
-    fn handle_mouse_event(&mut self, event: event::MouseEvent) {
-        match event.kind {
-            MouseEventKind::Down(_) => self.is_drawing = true,
-            MouseEventKind::Up(_) => self.is_drawing = false,
-            MouseEventKind::Drag(_) => {
-                self.points.push(Position::new(event.column, event.row));
-            }
-            _ => {}
-        }
-    }
-
-    fn on_tick(&mut self) {
-        // bounce the ball by flipping the velocity vector
-        let ball = &self.ball;
-        let playground = self.playground;
-        if ball.x - ball.radius < f64::from(playground.left())
-            || ball.x + ball.radius > f64::from(playground.right())
-        {
-            self.vx = -self.vx;
-        }
-        if ball.y - ball.radius < f64::from(playground.top())
-            || ball.y + ball.radius > f64::from(playground.bottom())
-        {
-            self.vy = -self.vy;
-        }
-        self.ball.x += self.vx;
-        self.ball.y += self.vy;
-    }
-
-    fn draw(&self, frame: &mut Frame) {
-        let header = Text::from_iter([
-            "Canvas Example".bold(),
-            "<q> Quit | <enter> Change Marker | <hjkl> Move".into(),
-        ]);
-
-        let vertical = Layout::vertical([
-            Constraint::Length(header.height() as u16),
-            Constraint::Percentage(50),
-            Constraint::Percentage(50),
-        ]);
-        let [text_area, up, down] = vertical.areas(frame.area());
-        frame.render_widget(header.centered(), text_area);
-
-        let horizontal =
-            Layout::horizontal([Constraint::Percentage(50), Constraint::Percentage(50)]);
-        let [draw, pong] = horizontal.areas(up);
-        let [map, boxes] = horizontal.areas(down);
-
-        frame.render_widget(self.map_canvas(), map);
-        frame.render_widget(self.draw_canvas(draw), draw);
-        frame.render_widget(self.pong_canvas(), pong);
-        frame.render_widget(self.boxes_canvas(boxes), boxes);
-    }
-
-    fn map_canvas(&self) -> impl Widget + '_ {
-        Canvas::default()
-            .block(Block::bordered().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 draw_canvas(&self, area: Rect) -> impl Widget + '_ {
-        Canvas::default()
-            .block(Block::bordered().title("Draw here"))
-            .marker(self.marker)
-            .x_bounds([0.0, f64::from(area.width)])
-            .y_bounds([0.0, f64::from(area.height)])
-            .paint(move |ctx| {
-                let points = self
-                    .points
-                    .iter()
-                    .map(|p| {
-                        (
-                            f64::from(p.x) - f64::from(area.left()),
-                            f64::from(area.bottom()) - f64::from(p.y),
-                        )
-                    })
-                    .collect_vec();
-                ctx.draw(&Points {
-                    coords: &points,
-                    color: Color::White,
-                });
-            })
-    }
-
-    fn pong_canvas(&self) -> impl Widget + '_ {
-        Canvas::default()
-            .block(Block::bordered().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 = 0.0;
-        let right = f64::from(area.width);
-        let bottom = 0.0;
-        let top = f64::from(area.height).mul_add(2.0, -4.0);
-        Canvas::default()
-            .block(Block::bordered().title("Rects"))
-            .marker(self.marker)
-            .x_bounds([left, right])
-            .y_bounds([bottom, top])
-            .paint(|ctx| {
-                for i in 0..=11 {
-                    ctx.draw(&Rectangle {
-                        x: f64::from(i * i + 3 * i) / 2.0 + 2.0,
-                        y: 2.0,
-                        width: f64::from(i),
-                        height: f64::from(i),
-                        color: Color::Red,
-                    });
-                    ctx.draw(&Rectangle {
-                        x: f64::from(i * i + 3 * i) / 2.0 + 2.0,
-                        y: 21.0,
-                        width: f64::from(i),
-                        height: f64::from(i),
-                        color: Color::Blue,
-                    });
-                }
-                for i in 0..100 {
-                    if i % 10 != 0 {
-                        ctx.print(f64::from(i) + 1.0, 0.0, format!("{i}", i = i % 10));
-                    }
-                    if i % 2 == 0 && i % 10 != 0 {
-                        ctx.print(0.0, f64::from(i), format!("{i}", i = i % 10));
-                    }
-                }
-            })
-    }
-}
--- a/examples/apps/chart/Cargo.toml
+++ b/examples/apps/chart/Cargo.toml
@@ -1,14 +0,0 @@
-[package]
-name = "chart"
-publish = false
-license.workspace = true
-edition.workspace = true
-rust-version.workspace = true
-
-[dependencies]
-color-eyre.workspace = true
-crossterm.workspace = true
-ratatui.workspace = true
-
-[lints]
-workspace = true
--- a/examples/apps/chart/README.md
+++ b/examples/apps/chart/README.md
@@ -1,9 +0,0 @@
-# Chart demo
-
-This example shows how to render line, bar, and scatter charts.
-
-To run this demo:
-
-```shell
-cargo run -p chart
-```
--- a/examples/apps/chart/src/main.rs
+++ b/examples/apps/chart/src/main.rs
@@ -1,354 +0,0 @@
-/// A Ratatui example that demonstrates how to handle charts.
-///
-/// This example demonstrates how to draw various types of charts such as line, bar, and
-/// scatter charts.
-///
-/// This example runs with the Ratatui library code in the branch that you are currently
-/// reading. See the [`latest`] branch for the code which works with the most recent Ratatui
-/// release.
-///
-/// [`latest`]: https://github.com/ratatui/ratatui/tree/latest
-use std::time::{Duration, Instant};
-
-use color_eyre::Result;
-use ratatui::{
-    crossterm::event::{self, Event, KeyCode},
-    layout::{Constraint, Layout, Rect},
-    style::{Color, Modifier, Style, Stylize},
-    symbols::{self, Marker},
-    text::{Line, Span},
-    widgets::{Axis, Block, Chart, Dataset, GraphType, LegendPosition},
-    DefaultTerminal, Frame,
-};
-
-fn main() -> Result<()> {
-    color_eyre::install()?;
-    let terminal = ratatui::init();
-    let app_result = App::new().run(terminal);
-    ratatui::restore();
-    app_result
-}
-
-struct App {
-    signal1: SinSignal,
-    data1: Vec<(f64, f64)>,
-    signal2: SinSignal,
-    data2: Vec<(f64, f64)>,
-    window: [f64; 2],
-}
-
-#[derive(Clone)]
-struct SinSignal {
-    x: f64,
-    interval: f64,
-    period: f64,
-    scale: f64,
-}
-
-impl SinSignal {
-    const fn new(interval: f64, period: f64, scale: f64) -> Self {
-        Self {
-            x: 0.0,
-            interval,
-            period,
-            scale,
-        }
-    }
-}
-
-impl Iterator for SinSignal {
-    type Item = (f64, f64);
-    fn next(&mut self) -> Option<Self::Item> {
-        let point = (self.x, (self.x * 1.0 / self.period).sin() * self.scale);
-        self.x += self.interval;
-        Some(point)
-    }
-}
-
-impl App {
-    fn new() -> Self {
-        let mut signal1 = SinSignal::new(0.2, 3.0, 18.0);
-        let mut signal2 = SinSignal::new(0.1, 2.0, 10.0);
-        let data1 = signal1.by_ref().take(200).collect::<Vec<(f64, f64)>>();
-        let data2 = signal2.by_ref().take(200).collect::<Vec<(f64, f64)>>();
-        Self {
-            signal1,
-            data1,
-            signal2,
-            data2,
-            window: [0.0, 20.0],
-        }
-    }
-
-    fn run(mut self, mut terminal: DefaultTerminal) -> Result<()> {
-        let tick_rate = Duration::from_millis(250);
-        let mut last_tick = Instant::now();
-        loop {
-            terminal.draw(|frame| self.draw(frame))?;
-
-            let timeout = tick_rate.saturating_sub(last_tick.elapsed());
-            if event::poll(timeout)? {
-                if let Event::Key(key) = event::read()? {
-                    if key.code == KeyCode::Char('q') {
-                        return Ok(());
-                    }
-                }
-            }
-            if last_tick.elapsed() >= tick_rate {
-                self.on_tick();
-                last_tick = Instant::now();
-            }
-        }
-    }
-
-    fn on_tick(&mut self) {
-        self.data1.drain(0..5);
-        self.data1.extend(self.signal1.by_ref().take(5));
-
-        self.data2.drain(0..10);
-        self.data2.extend(self.signal2.by_ref().take(10));
-
-        self.window[0] += 1.0;
-        self.window[1] += 1.0;
-    }
-
-    fn draw(&self, frame: &mut Frame) {
-        let [top, bottom] = Layout::vertical([Constraint::Fill(1); 2]).areas(frame.area());
-        let [animated_chart, bar_chart] =
-            Layout::horizontal([Constraint::Fill(1), Constraint::Length(29)]).areas(top);
-        let [line_chart, scatter] = Layout::horizontal([Constraint::Fill(1); 2]).areas(bottom);
-
-        self.render_animated_chart(frame, animated_chart);
-        render_barchart(frame, bar_chart);
-        render_line_chart(frame, line_chart);
-        render_scatter(frame, scatter);
-    }
-
-    fn render_animated_chart(&self, frame: &mut Frame, area: Rect) {
-        let x_labels = vec![
-            Span::styled(
-                format!("{}", self.window[0]),
-                Style::default().add_modifier(Modifier::BOLD),
-            ),
-            Span::raw(format!("{}", (self.window[0] + self.window[1]) / 2.0)),
-            Span::styled(
-                format!("{}", self.window[1]),
-                Style::default().add_modifier(Modifier::BOLD),
-            ),
-        ];
-        let datasets = vec![
-            Dataset::default()
-                .name("data2")
-                .marker(symbols::Marker::Dot)
-                .style(Style::default().fg(Color::Cyan))
-                .data(&self.data1),
-            Dataset::default()
-                .name("data3")
-                .marker(symbols::Marker::Braille)
-                .style(Style::default().fg(Color::Yellow))
-                .data(&self.data2),
-        ];
-
-        let chart = Chart::new(datasets)
-            .block(Block::bordered())
-            .x_axis(
-                Axis::default()
-                    .title("X Axis")
-                    .style(Style::default().fg(Color::Gray))
-                    .labels(x_labels)
-                    .bounds(self.window),
-            )
-            .y_axis(
-                Axis::default()
-                    .title("Y Axis")
-                    .style(Style::default().fg(Color::Gray))
-                    .labels(["-20".bold(), "0".into(), "20".bold()])
-                    .bounds([-20.0, 20.0]),
-            );
-
-        frame.render_widget(chart, area);
-    }
-}
-
-fn render_barchart(frame: &mut Frame, bar_chart: Rect) {
-    let dataset = Dataset::default()
-        .marker(symbols::Marker::HalfBlock)
-        .style(Style::new().fg(Color::Blue))
-        .graph_type(GraphType::Bar)
-        // a bell curve
-        .data(&[
-            (0., 0.4),
-            (10., 2.9),
-            (20., 13.5),
-            (30., 41.1),
-            (40., 80.1),
-            (50., 100.0),
-            (60., 80.1),
-            (70., 41.1),
-            (80., 13.5),
-            (90., 2.9),
-            (100., 0.4),
-        ]);
-
-    let chart = Chart::new(vec![dataset])
-        .block(Block::bordered().title_top(Line::from("Bar chart").cyan().bold().centered()))
-        .x_axis(
-            Axis::default()
-                .style(Style::default().gray())
-                .bounds([0.0, 100.0])
-                .labels(["0".bold(), "50".into(), "100.0".bold()]),
-        )
-        .y_axis(
-            Axis::default()
-                .style(Style::default().gray())
-                .bounds([0.0, 100.0])
-                .labels(["0".bold(), "50".into(), "100.0".bold()]),
-        )
-        .hidden_legend_constraints((Constraint::Ratio(1, 2), Constraint::Ratio(1, 2)));
-
-    frame.render_widget(chart, bar_chart);
-}
-
-fn render_line_chart(frame: &mut Frame, area: Rect) {
-    let datasets = vec![Dataset::default()
-        .name("Line from only 2 points".italic())
-        .marker(symbols::Marker::Braille)
-        .style(Style::default().fg(Color::Yellow))
-        .graph_type(GraphType::Line)
-        .data(&[(1., 1.), (4., 4.)])];
-
-    let chart = Chart::new(datasets)
-        .block(Block::bordered().title(Line::from("Line chart").cyan().bold().centered()))
-        .x_axis(
-            Axis::default()
-                .title("X Axis")
-                .style(Style::default().gray())
-                .bounds([0.0, 5.0])
-                .labels(["0".bold(), "2.5".into(), "5.0".bold()]),
-        )
-        .y_axis(
-            Axis::default()
-                .title("Y Axis")
-                .style(Style::default().gray())
-                .bounds([0.0, 5.0])
-                .labels(["0".bold(), "2.5".into(), "5.0".bold()]),
-        )
-        .legend_position(Some(LegendPosition::TopLeft))
-        .hidden_legend_constraints((Constraint::Ratio(1, 2), Constraint::Ratio(1, 2)));
-
-    frame.render_widget(chart, area);
-}
-
-fn render_scatter(frame: &mut Frame, area: Rect) {
-    let datasets = vec![
-        Dataset::default()
-            .name("Heavy")
-            .marker(Marker::Dot)
-            .graph_type(GraphType::Scatter)
-            .style(Style::new().yellow())
-            .data(&HEAVY_PAYLOAD_DATA),
-        Dataset::default()
-            .name("Medium".underlined())
-            .marker(Marker::Braille)
-            .graph_type(GraphType::Scatter)
-            .style(Style::new().magenta())
-            .data(&MEDIUM_PAYLOAD_DATA),
-        Dataset::default()
-            .name("Small")
-            .marker(Marker::Dot)
-            .graph_type(GraphType::Scatter)
-            .style(Style::new().cyan())
-            .data(&SMALL_PAYLOAD_DATA),
-    ];
-
-    let chart = Chart::new(datasets)
-        .block(Block::bordered().title(Line::from("Scatter chart").cyan().bold().centered()))
-        .x_axis(
-            Axis::default()
-                .title("Year")
-                .bounds([1960., 2020.])
-                .style(Style::default().fg(Color::Gray))
-                .labels(["1960", "1990", "2020"]),
-        )
-        .y_axis(
-            Axis::default()
-                .title("Cost")
-                .bounds([0., 75000.])
-                .style(Style::default().fg(Color::Gray))
-                .labels(["0", "37 500", "75 000"]),
-        )
-        .hidden_legend_constraints((Constraint::Ratio(1, 2), Constraint::Ratio(1, 2)));
-
-    frame.render_widget(chart, area);
-}
-
-// Data from https://ourworldindata.org/space-exploration-satellites
-const HEAVY_PAYLOAD_DATA: [(f64, f64); 9] = [
-    (1965., 8200.),
-    (1967., 5400.),
-    (1981., 65400.),
-    (1989., 30800.),
-    (1997., 10200.),
-    (2004., 11600.),
-    (2014., 4500.),
-    (2016., 7900.),
-    (2018., 1500.),
-];
-
-const MEDIUM_PAYLOAD_DATA: [(f64, f64); 29] = [
-    (1963., 29500.),
-    (1964., 30600.),
-    (1965., 177_900.),
-    (1965., 21000.),
-    (1966., 17900.),
-    (1966., 8400.),
-    (1975., 17500.),
-    (1982., 8300.),
-    (1985., 5100.),
-    (1988., 18300.),
-    (1990., 38800.),
-    (1990., 9900.),
-    (1991., 18700.),
-    (1992., 9100.),
-    (1994., 10500.),
-    (1994., 8500.),
-    (1994., 8700.),
-    (1997., 6200.),
-    (1999., 18000.),
-    (1999., 7600.),
-    (1999., 8900.),
-    (1999., 9600.),
-    (2000., 16000.),
-    (2001., 10000.),
-    (2002., 10400.),
-    (2002., 8100.),
-    (2010., 2600.),
-    (2013., 13600.),
-    (2017., 8000.),
-];
-
-const SMALL_PAYLOAD_DATA: [(f64, f64); 23] = [
-    (1961., 118_500.),
-    (1962., 14900.),
-    (1975., 21400.),
-    (1980., 32800.),
-    (1988., 31100.),
-    (1990., 41100.),
-    (1993., 23600.),
-    (1994., 20600.),
-    (1994., 34600.),
-    (1996., 50600.),
-    (1997., 19200.),
-    (1997., 45800.),
-    (1998., 19100.),
-    (2000., 73100.),
-    (2003., 11200.),
-    (2008., 12600.),
-    (2010., 30500.),
-    (2012., 20000.),
-    (2013., 10600.),
-    (2013., 34500.),
-    (2015., 10600.),
-    (2018., 23100.),
-    (2019., 17300.),
-];
--- a/examples/apps/color-explorer/Cargo.toml
+++ b/examples/apps/color-explorer/Cargo.toml
@@ -1,15 +0,0 @@
-[package]
-name = "color-explorer"
-publish = false
-license.workspace = true
-edition.workspace = true
-rust-version.workspace = true
-
-[dependencies]
-color-eyre.workspace = true
-crossterm.workspace = true
-itertools.workspace = true
-ratatui.workspace = true
-
-[lints]
-workspace = true
--- a/examples/apps/color-explorer/README.md
+++ b/examples/apps/color-explorer/README.md
@@ -1,9 +0,0 @@
-# Color explorer demo
-
-This example shows how to handle the supported colors.
-
-To run this demo:
-
-```shell
-cargo run -p color-explorer
-```
--- a/examples/apps/color-explorer/src/main.rs
+++ b/examples/apps/color-explorer/src/main.rs
@@ -1,241 +0,0 @@
-//! A Ratatui example that demonstrates how to handle colors.
-//!
-//! This example shows all the colors supported by Ratatui. It will render a grid of foreground
-//! and background colors with their names and indexes.
-//!
-//! This example runs with the Ratatui library code in the branch that you are currently reading.
-//! See the [`latest`] branch for the code which works with the most recent Ratatui release.
-//!
-//! [`latest`]: https://github.com/ratatui/ratatui/tree/latest
-
-use color_eyre::Result;
-use itertools::Itertools;
-use ratatui::{
-    crossterm::event::{self, Event, KeyCode, KeyEventKind},
-    layout::{Alignment, Constraint, Layout, Rect},
-    style::{Color, Style, Stylize},
-    text::Line,
-    widgets::{Block, Borders, Paragraph},
-    DefaultTerminal, Frame,
-};
-
-fn main() -> Result<()> {
-    color_eyre::install()?;
-    let terminal = ratatui::init();
-    let app_result = run(terminal);
-    ratatui::restore();
-    app_result
-}
-
-fn run(mut terminal: DefaultTerminal) -> Result<()> {
-    loop {
-        terminal.draw(draw)?;
-        if let Event::Key(key) = event::read()? {
-            if key.kind == KeyEventKind::Press && key.code == KeyCode::Char('q') {
-                return Ok(());
-            }
-        }
-    }
-}
-
-fn draw(frame: &mut Frame) {
-    let layout = Layout::vertical([
-        Constraint::Length(30),
-        Constraint::Length(17),
-        Constraint::Length(2),
-    ])
-    .split(frame.area());
-
-    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::vertical([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 vertical = Layout::vertical([Constraint::Length(1); 2]).split(inner);
-    let areas = vertical.iter().flat_map(|area| {
-        Layout::horizontal([Constraint::Ratio(1, 8); 8])
-            .split(*area)
-            .to_vec()
-    });
-    for (fg, area) in NAMED_COLORS.into_iter().zip(areas) {
-        let color_name = fg.to_string();
-        let paragraph = Paragraph::new(color_name).fg(fg).bg(bg);
-        frame.render_widget(paragraph, area);
-    }
-}
-
-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 vertical = Layout::vertical([Constraint::Length(1); 2]).split(inner);
-    let areas = vertical.iter().flat_map(|area| {
-        Layout::horizontal([Constraint::Ratio(1, 8); 8])
-            .split(*area)
-            .to_vec()
-    });
-    for (bg, area) in NAMED_COLORS.into_iter().zip(areas) {
-        let color_name = bg.to_string();
-        let paragraph = Paragraph::new(color_name).fg(fg).bg(bg);
-        frame.render_widget(paragraph, area);
-    }
-}
-
-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::vertical([
-        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::horizontal([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::horizontal([Constraint::Length(27); 3])
-                .split(*area)
-                .to_vec()
-        })
-        // each with 6 rows
-        .flat_map(|area| {
-            Layout::vertical([Constraint::Length(1); 6])
-                .split(area)
-                .to_vec()
-        })
-        // each with 6 columns
-        .flat_map(|area| {
-            Layout::horizontal([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::new()
-        .borders(Borders::TOP)
-        .title_alignment(Alignment::Center)
-        .border_style(Style::new().dark_gray())
-        .title_style(Style::new().reset())
-        .title(title)
-}
-
-fn render_indexed_grayscale(frame: &mut Frame, area: Rect) {
-    let layout = Layout::vertical([
-        Constraint::Length(1), // 232 - 243
-        Constraint::Length(1), // 244 - 255
-    ])
-    .split(area)
-    .iter()
-    .flat_map(|area| {
-        Layout::horizontal([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]);
-    }
-}
--- a/examples/apps/demo/Cargo.toml
+++ b/examples/apps/demo/Cargo.toml
@@ -1,17 +0,0 @@
-[package]
-name = "demo"
-publish = false
-license.workspace = true
-edition.workspace = true
-rust-version.workspace = true
-
-[features]
-default = ["crossterm"]
-crossterm = ["ratatui/crossterm"]
-termion = ["ratatui/termion"]
-termwiz = ["ratatui/termwiz"]
-
-[dependencies]
-clap = { version = "4.5.23", features = ["derive"] }
-rand = "0.8.5"
-ratatui.workspace = true
--- a/examples/apps/demo/README.md
+++ b/examples/apps/demo/README.md
@@ -1,25 +0,0 @@
-# Demo example
-
-This is the original demo that was developed for Tui-rs (the library that Ratatui was forked from).
-
-![demo.gif](https://github.com/ratatui/ratatui/blob/images/examples/demo.gif?raw=true)
-
-This example is available for each backend. To run it:
-
-## crossterm
-
-```shell
-cargo run -p demo
-```
-
-## termion
-
-```shell
-cargo run -p demo --no-default-features --features termion
-```
-
-## termwiz
-
-```shell
-cargo run -p demo --no-default-features --features termwiz
-```
--- a/examples/apps/demo/src/crossterm.rs
+++ b/examples/apps/demo/src/crossterm.rs
@@ -1,79 +0,0 @@
-use std::{
-    error::Error,
-    io,
-    time::{Duration, Instant},
-};
-
-use ratatui::{
-    backend::{Backend, CrosstermBackend},
-    crossterm::{
-        event::{self, DisableMouseCapture, EnableMouseCapture, Event, KeyCode, KeyEventKind},
-        execute,
-        terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
-    },
-    Terminal,
-};
-
-use crate::{app::App, ui};
-
-pub fn run(tick_rate: Duration, enhanced_graphics: bool) -> 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 app = App::new("Crossterm Demo", enhanced_graphics);
-    let app_result = 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) = app_result {
-        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(|frame| ui::draw(frame, &mut app))?;
-
-        let timeout = tick_rate.saturating_sub(last_tick.elapsed());
-        if event::poll(timeout)? {
-            if let Event::Key(key) = event::read()? {
-                if key.kind == KeyEventKind::Press {
-                    match key.code {
-                        KeyCode::Left | KeyCode::Char('h') => app.on_left(),
-                        KeyCode::Up | KeyCode::Char('k') => app.on_up(),
-                        KeyCode::Right | KeyCode::Char('l') => app.on_right(),
-                        KeyCode::Down | KeyCode::Char('j') => app.on_down(),
-                        KeyCode::Char(c) => app.on_key(c),
-                        _ => {}
-                    }
-                }
-            }
-        }
-        if last_tick.elapsed() >= tick_rate {
-            app.on_tick();
-            last_tick = Instant::now();
-        }
-        if app.should_quit {
-            return Ok(());
-        }
-    }
-}
--- a/examples/apps/demo/src/main.rs
+++ b/examples/apps/demo/src/main.rs
@@ -1,56 +0,0 @@
-//! # [Ratatui] Original Demo example
-//!
-//! The latest version of this example is available in the [examples] folder in the repository.
-//!
-//! Please note that the examples are designed to be run against the `main` branch of the Github
-//! repository. This means that you may not be able to compile with the latest release version on
-//! crates.io, or the one that you have installed locally.
-//!
-//! See the [examples readme] for more information on finding examples that match the version of the
-//! library you are using.
-//!
-//! [Ratatui]: https://github.com/ratatui/ratatui
-//! [examples]: https://github.com/ratatui/ratatui/blob/main/examples
-//! [examples readme]: https://github.com/ratatui/ratatui/blob/main/examples/README.md
-
-use std::{error::Error, time::Duration};
-
-use clap::Parser;
-
-mod app;
-#[cfg(feature = "crossterm")]
-mod crossterm;
-#[cfg(all(not(windows), feature = "termion"))]
-mod termion;
-#[cfg(feature = "termwiz")]
-mod termwiz;
-
-mod ui;
-
-/// Demo
-#[derive(Debug, Parser)]
-struct Cli {
-    /// time in ms between two ticks.
-    #[arg(short, long, default_value_t = 250)]
-    tick_rate: u64,
-
-    /// whether unicode symbols are used to improve the overall look of the app
-    #[arg(short, long, default_value_t = true)]
-    unicode: bool,
-}
-
-fn main() -> Result<(), Box<dyn Error>> {
-    let cli = Cli::parse();
-    let tick_rate = Duration::from_millis(cli.tick_rate);
-    #[cfg(feature = "crossterm")]
-    crate::crossterm::run(tick_rate, cli.unicode)?;
-    #[cfg(all(not(windows), feature = "termion", not(feature = "crossterm")))]
-    crate::termion::run(tick_rate, cli.unicode)?;
-    #[cfg(all(
-        feature = "termwiz",
-        not(feature = "crossterm"),
-        not(feature = "termion")
-    ))]
-    crate::termwiz::run(tick_rate, cli.unicode)?;
-    Ok(())
-}
--- a/examples/apps/demo/src/termion.rs
+++ b/examples/apps/demo/src/termion.rs
@@ -1,86 +0,0 @@
-#![allow(dead_code)]
-use std::{error::Error, io, sync::mpsc, thread, time::Duration};
-
-use ratatui::{
-    backend::{Backend, TermionBackend},
-    termion::{
-        event::Key,
-        input::{MouseTerminal, TermRead},
-        raw::IntoRawMode,
-        screen::IntoAlternateScreen,
-    },
-    Terminal,
-};
-
-use crate::{app::App, ui};
-
-pub fn run(tick_rate: Duration, enhanced_graphics: bool) -> Result<(), Box<dyn Error>> {
-    // setup terminal
-    let stdout = io::stdout()
-        .into_raw_mode()
-        .unwrap()
-        .into_alternate_screen()
-        .unwrap();
-    let stdout = MouseTerminal::from(stdout);
-    let backend = TermionBackend::new(stdout);
-    let mut terminal = Terminal::new(backend)?;
-
-    // create app and run it
-    let app = App::new("Termion demo", enhanced_graphics);
-    run_app(&mut terminal, app, tick_rate)?;
-
-    Ok(())
-}
-
-fn run_app<B: Backend>(
-    terminal: &mut Terminal<B>,
-    mut app: App,
-    tick_rate: Duration,
-) -> Result<(), Box<dyn Error>> {
-    let events = events(tick_rate);
-    loop {
-        terminal.draw(|frame| ui::draw(frame, &mut app))?;
-
-        match events.recv()? {
-            Event::Input(key) => match key {
-                Key::Up | Key::Char('k') => app.on_up(),
-                Key::Down | Key::Char('j') => app.on_down(),
-                Key::Left | Key::Char('h') => app.on_left(),
-                Key::Right | Key::Char('l') => app.on_right(),
-                Key::Char(c) => app.on_key(c),
-                _ => {}
-            },
-            Event::Tick => app.on_tick(),
-        }
-        if app.should_quit {
-            return Ok(());
-        }
-    }
-}
-
-enum Event {
-    Input(Key),
-    Tick,
-}
-
-fn events(tick_rate: Duration) -> mpsc::Receiver<Event> {
-    let (tx, rx) = mpsc::channel();
-    let keys_tx = tx.clone();
-    thread::spawn(move || {
-        let stdin = io::stdin();
-        for key in stdin.keys().flatten() {
-            if let Err(err) = keys_tx.send(Event::Input(key)) {
-                eprintln!("{err}");
-                return;
-            }
-        }
-    });
-    thread::spawn(move || loop {
-        if let Err(err) = tx.send(Event::Tick) {
-            eprintln!("{err}");
-            break;
-        }
-        thread::sleep(tick_rate);
-    });
-    rx
-}
--- a/examples/apps/demo/src/termwiz.rs
+++ b/examples/apps/demo/src/termwiz.rs
@@ -1,80 +0,0 @@
-#![allow(dead_code)]
-use std::{
-    error::Error,
-    time::{Duration, Instant},
-};
-
-use ratatui::{
-    backend::TermwizBackend,
-    termwiz::{
-        input::{InputEvent, KeyCode},
-        terminal::Terminal as TermwizTerminal,
-    },
-    Terminal,
-};
-
-use crate::{app::App, ui};
-
-pub fn run(tick_rate: Duration, enhanced_graphics: bool) -> Result<(), Box<dyn Error>> {
-    let backend = TermwizBackend::new()?;
-    let mut terminal = Terminal::new(backend)?;
-    terminal.hide_cursor()?;
-
-    // create app and run it
-    let app = App::new("Termwiz Demo", enhanced_graphics);
-    let app_result = run_app(&mut terminal, app, tick_rate);
-
-    terminal.show_cursor()?;
-    terminal.flush()?;
-
-    if let Err(err) = app_result {
-        println!("{err:?}");
-    }
-
-    Ok(())
-}
-
-fn run_app(
-    terminal: &mut Terminal<TermwizBackend>,
-    mut app: App,
-    tick_rate: Duration,
-) -> Result<(), Box<dyn Error>> {
-    let mut last_tick = Instant::now();
-    loop {
-        terminal.draw(|frame| ui::draw(frame, &mut app))?;
-
-        let timeout = tick_rate.saturating_sub(last_tick.elapsed());
-        if let Some(input) = terminal
-            .backend_mut()
-            .buffered_terminal_mut()
-            .terminal()
-            .poll_input(Some(timeout))?
-        {
-            match input {
-                InputEvent::Key(key_code) => match key_code.key {
-                    KeyCode::UpArrow | KeyCode::Char('k') => app.on_up(),
-                    KeyCode::DownArrow | KeyCode::Char('j') => app.on_down(),
-                    KeyCode::LeftArrow | KeyCode::Char('h') => app.on_left(),
-                    KeyCode::RightArrow | KeyCode::Char('l') => app.on_right(),
-                    KeyCode::Char(c) => app.on_key(c),
-                    _ => {}
-                },
-                InputEvent::Resized { cols, rows } => {
-                    terminal
-                        .backend_mut()
-                        .buffered_terminal_mut()
-                        .resize(cols, rows);
-                }
-                _ => {}
-            }
-        }
-
-        if last_tick.elapsed() >= tick_rate {
-            app.on_tick();
-            last_tick = Instant::now();
-        }
-        if app.should_quit {
-            return Ok(());
-        }
-    }
-}
--- a/examples/apps/demo2/Cargo.toml
+++ b/examples/apps/demo2/Cargo.toml
@@ -1,19 +0,0 @@
-[package]
-name = "demo2"
-publish = false
-license.workspace = true
-edition.workspace = true
-rust-version.workspace = true
-
-[dependencies]
-color-eyre = "0.6.3"
-crossterm.workspace = true
-indoc.workspace = true
-itertools.workspace = true
-palette = "0.7.6"
-rand = "0.8.5"
-rand_chacha = "0.3.1"
-ratatui = { workspace = true, features = ["all-widgets"] }
-strum.workspace = true
-time = "0.3.37"
-unicode-width = "0.2.0"
--- a/examples/apps/demo2/README.md
+++ b/examples/apps/demo2/README.md
@@ -1,9 +0,0 @@
-## Demo2
-
-This is the demo example from the main README and crate page. Source: [demo2](./demo2/).
-
-```shell
-cargo run -p demo2
-```
-
-![Demo2](https://github.com/ratatui/ratatui/blob/images/examples/demo2.gif?raw=true)
--- a/examples/apps/demo2/src/app.rs
+++ b/examples/apps/demo2/src/app.rs
@@ -1,225 +0,0 @@
-use std::time::Duration;
-
-use color_eyre::{eyre::Context, Result};
-use crossterm::event;
-use itertools::Itertools;
-use ratatui::{
-    buffer::Buffer,
-    crossterm::event::{Event, KeyCode, KeyEvent, KeyEventKind},
-    layout::{Constraint, Layout, Rect},
-    style::Color,
-    text::{Line, Span},
-    widgets::{Block, Tabs, Widget},
-    DefaultTerminal, Frame,
-};
-use strum::{Display, EnumIter, FromRepr, IntoEnumIterator};
-
-use crate::{
-    destroy,
-    tabs::{AboutTab, EmailTab, RecipeTab, TracerouteTab, WeatherTab},
-    THEME,
-};
-
-#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
-pub struct App {
-    mode: Mode,
-    tab: Tab,
-    about_tab: AboutTab,
-    recipe_tab: RecipeTab,
-    email_tab: EmailTab,
-    traceroute_tab: TracerouteTab,
-    weather_tab: WeatherTab,
-}
-
-#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
-enum Mode {
-    #[default]
-    Running,
-    Destroy,
-    Quit,
-}
-
-#[derive(Debug, Clone, Copy, Default, Display, EnumIter, FromRepr, PartialEq, Eq)]
-enum Tab {
-    #[default]
-    About,
-    Recipe,
-    Email,
-    Traceroute,
-    Weather,
-}
-
-impl App {
-    /// Run the app until the user quits.
-    pub fn run(mut self, mut terminal: DefaultTerminal) -> Result<()> {
-        while self.is_running() {
-            terminal
-                .draw(|frame| self.draw(frame))
-                .wrap_err("terminal.draw")?;
-            self.handle_events()?;
-        }
-        Ok(())
-    }
-
-    fn is_running(&self) -> bool {
-        self.mode != Mode::Quit
-    }
-
-    /// Draw a single frame of the app.
-    fn draw(&self, frame: &mut Frame) {
-        frame.render_widget(self, frame.area());
-        if self.mode == Mode::Destroy {
-            destroy::destroy(frame);
-        }
-    }
-
-    /// Handle events from the terminal.
-    ///
-    /// This function is called once per frame, The events are polled from the stdin with timeout of
-    /// 1/50th of a second. This was chosen to try to match the default frame rate of a GIF in VHS.
-    fn handle_events(&mut self) -> Result<()> {
-        let timeout = Duration::from_secs_f64(1.0 / 50.0);
-        if !event::poll(timeout)? {
-            return Ok(());
-        }
-        match event::read()? {
-            Event::Key(key) if key.kind == KeyEventKind::Press => self.handle_key_press(key),
-            _ => {}
-        }
-        Ok(())
-    }
-
-    fn handle_key_press(&mut self, key: KeyEvent) {
-        match key.code {
-            KeyCode::Char('q') | KeyCode::Esc => self.mode = Mode::Quit,
-            KeyCode::Char('h') | KeyCode::Left => self.prev_tab(),
-            KeyCode::Char('l') | KeyCode::Right => self.next_tab(),
-            KeyCode::Char('k') | KeyCode::Up => self.prev(),
-            KeyCode::Char('j') | KeyCode::Down => self.next(),
-            KeyCode::Char('d') | KeyCode::Delete => self.destroy(),
-            _ => {}
-        };
-    }
-
-    fn prev(&mut self) {
-        match self.tab {
-            Tab::About => self.about_tab.prev_row(),
-            Tab::Recipe => self.recipe_tab.prev(),
-            Tab::Email => self.email_tab.prev(),
-            Tab::Traceroute => self.traceroute_tab.prev_row(),
-            Tab::Weather => self.weather_tab.prev(),
-        }
-    }
-
-    fn next(&mut self) {
-        match self.tab {
-            Tab::About => self.about_tab.next_row(),
-            Tab::Recipe => self.recipe_tab.next(),
-            Tab::Email => self.email_tab.next(),
-            Tab::Traceroute => self.traceroute_tab.next_row(),
-            Tab::Weather => self.weather_tab.next(),
-        }
-    }
-
-    fn prev_tab(&mut self) {
-        self.tab = self.tab.prev();
-    }
-
-    fn next_tab(&mut self) {
-        self.tab = self.tab.next();
-    }
-
-    fn destroy(&mut self) {
-        self.mode = Mode::Destroy;
-    }
-}
-
-/// Implement Widget for &App rather than for App as we would otherwise have to clone or copy the
-/// entire app state on every frame. For this example, the app state is small enough that it doesn't
-/// matter, but for larger apps this can be a significant performance improvement.
-impl Widget for &App {
-    fn render(self, area: Rect, buf: &mut Buffer) {
-        let vertical = Layout::vertical([
-            Constraint::Length(1),
-            Constraint::Min(0),
-            Constraint::Length(1),
-        ]);
-        let [title_bar, tab, bottom_bar] = vertical.areas(area);
-
-        Block::new().style(THEME.root).render(area, buf);
-        self.render_title_bar(title_bar, buf);
-        self.render_selected_tab(tab, buf);
-        App::render_bottom_bar(bottom_bar, buf);
-    }
-}
-
-impl App {
-    fn render_title_bar(&self, area: Rect, buf: &mut Buffer) {
-        let layout = Layout::horizontal([Constraint::Min(0), Constraint::Length(43)]);
-        let [title, tabs] = layout.areas(area);
-
-        Span::styled("Ratatui", THEME.app_title).render(title, buf);
-        let titles = Tab::iter().map(Tab::title);
-        Tabs::new(titles)
-            .style(THEME.tabs)
-            .highlight_style(THEME.tabs_selected)
-            .select(self.tab as usize)
-            .divider("")
-            .padding("", "")
-            .render(tabs, buf);
-    }
-
-    fn render_selected_tab(&self, area: Rect, buf: &mut Buffer) {
-        match self.tab {
-            Tab::About => self.about_tab.render(area, buf),
-            Tab::Recipe => self.recipe_tab.render(area, buf),
-            Tab::Email => self.email_tab.render(area, buf),
-            Tab::Traceroute => self.traceroute_tab.render(area, buf),
-            Tab::Weather => self.weather_tab.render(area, buf),
-        };
-    }
-
-    fn render_bottom_bar(area: Rect, buf: &mut Buffer) {
-        let keys = [
-            ("H/←", "Left"),
-            ("L/→", "Right"),
-            ("K/↑", "Up"),
-            ("J/↓", "Down"),
-            ("D/Del", "Destroy"),
-            ("Q/Esc", "Quit"),
-        ];
-        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();
-        Line::from(spans)
-            .centered()
-            .style((Color::Indexed(236), Color::Indexed(232)))
-            .render(area, buf);
-    }
-}
-
-impl Tab {
-    fn next(self) -> Self {
-        let current_index = self as usize;
-        let next_index = current_index.saturating_add(1);
-        Self::from_repr(next_index).unwrap_or(self)
-    }
-
-    fn prev(self) -> Self {
-        let current_index = self as usize;
-        let prev_index = current_index.saturating_sub(1);
-        Self::from_repr(prev_index).unwrap_or(self)
-    }
-
-    fn title(self) -> String {
-        match self {
-            Self::About => String::new(),
-            tab => format!(" {tab} "),
-        }
-    }
-}
--- a/examples/apps/demo2/src/colors.rs
+++ b/examples/apps/demo2/src/colors.rs
@@ -1,35 +0,0 @@
-use palette::{IntoColor, Okhsv, Srgb};
-use ratatui::{buffer::Buffer, layout::Rect, style::Color, widgets::Widget};
-
-/// 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 {
-    #[allow(clippy::cast_precision_loss, clippy::similar_names)]
-    fn render(self, area: Rect, buf: &mut Buffer) {
-        for (yi, y) in (area.top()..area.bottom()).enumerate() {
-            let value = f32::from(area.height) - yi as f32;
-            let value_fg = value / f32::from(area.height);
-            let value_bg = (value - 0.5) / f32::from(area.height);
-            for (xi, x) in (area.left()..area.right()).enumerate() {
-                let hue = xi as f32 * 360.0 / f32::from(area.width);
-                let fg = color_from_oklab(hue, Okhsv::max_saturation(), value_fg);
-                let bg = color_from_oklab(hue, Okhsv::max_saturation(), value_bg);
-                buf[(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)
-}
--- a/examples/apps/demo2/src/destroy.rs
+++ b/examples/apps/demo2/src/destroy.rs
@@ -1,142 +0,0 @@
-use rand::Rng;
-use rand_chacha::rand_core::SeedableRng;
-use ratatui::{
-    buffer::Buffer,
-    layout::{Flex, Layout, Rect},
-    style::{Color, Style},
-    text::Text,
-    widgets::Widget,
-    Frame,
-};
-
-/// delay the start of the animation so it doesn't start immediately
-const DELAY: usize = 120;
-/// higher means more pixels per frame are modified in the animation
-const DRIP_SPEED: usize = 500;
-/// delay the start of the text animation so it doesn't start immediately after the initial delay
-const TEXT_DELAY: usize = 180;
-
-/// Destroy mode activated by pressing `d`
-pub fn destroy(frame: &mut Frame<'_>) {
-    let frame_count = frame.count().saturating_sub(DELAY);
-    if frame_count == 0 {
-        return;
-    }
-
-    let area = frame.area();
-    let buf = frame.buffer_mut();
-
-    drip(frame_count, area, buf);
-    text(frame_count, area, buf);
-}
-
-/// Move a bunch of random pixels down one row.
-///
-/// Each pick some random pixels and move them each down one row. This is a very inefficient way to
-/// do this, but it works well enough for this demo.
-#[allow(
-    clippy::cast_possible_truncation,
-    clippy::cast_precision_loss,
-    clippy::cast_sign_loss
-)]
-fn drip(frame_count: usize, area: Rect, buf: &mut Buffer) {
-    // a seeded rng as we have to move the same random pixels each frame
-    let mut rng = rand_chacha::ChaCha8Rng::seed_from_u64(10);
-    let ramp_frames = 450;
-    let fractional_speed = frame_count as f64 / f64::from(ramp_frames);
-    let variable_speed = DRIP_SPEED as f64 * fractional_speed * fractional_speed * fractional_speed;
-    let pixel_count = (frame_count as f64 * variable_speed).floor() as usize;
-    for _ in 0..pixel_count {
-        let src_x = rng.gen_range(0..area.width);
-        let src_y = rng.gen_range(1..area.height - 2);
-        let src = buf[(src_x, src_y)].clone();
-        // 1% of the time, move a blank or pixel (10:1) to the top line of the screen
-        if rng.gen_ratio(1, 100) {
-            let dest_x = rng
-                .gen_range(src_x.saturating_sub(5)..src_x.saturating_add(5))
-                .clamp(area.left(), area.right() - 1);
-            let dest_y = area.top() + 1;
-
-            let dest = &mut buf[(dest_x, dest_y)];
-            // copy the cell to the new location about 1/10 of the time blank out the cell the rest
-            // of the time. This has the effect of gradually removing the pixels from the screen.
-            if rng.gen_ratio(1, 10) {
-                *dest = src;
-            } else {
-                dest.reset();
-            }
-        } else {
-            // move the pixel down one row
-            let dest_x = src_x;
-            let dest_y = src_y.saturating_add(1).min(area.bottom() - 2);
-            // copy the cell to the new location
-            buf[(dest_x, dest_y)] = src;
-        }
-    }
-}
-
-/// draw some text fading in and out from black to red and back
-#[allow(clippy::cast_possible_truncation, clippy::cast_precision_loss)]
-fn text(frame_count: usize, area: Rect, buf: &mut Buffer) {
-    let sub_frame = frame_count.saturating_sub(TEXT_DELAY);
-    if sub_frame == 0 {
-        return;
-    }
-
-    let logo = indoc::indoc! {"
-        ██████      ████    ██████    ████    ██████  ██    ██  ██
-        ██    ██  ██    ██    ██    ██    ██    ██    ██    ██  ██
-        ██████    ████████    ██    ████████    ██    ██    ██  ██
-        ██  ██    ██    ██    ██    ██    ██    ██    ██    ██  ██
-        ██    ██  ██    ██    ██    ██    ██    ██      ████    ██
-    "};
-    let logo_text = Text::styled(logo, Color::Rgb(255, 255, 255));
-    let area = centered_rect(area, logo_text.width() as u16, logo_text.height() as u16);
-
-    let mask_buf = &mut Buffer::empty(area);
-    logo_text.render(area, mask_buf);
-
-    let percentage = (sub_frame as f64 / 480.0).clamp(0.0, 1.0);
-
-    for row in area.rows() {
-        for col in row.columns() {
-            let cell = &mut buf[(col.x, col.y)];
-            let mask_cell = &mut mask_buf[(col.x, col.y)];
-            cell.set_symbol(mask_cell.symbol());
-
-            // blend the mask cell color with the cell color
-            let cell_color = cell.style().bg.unwrap_or(Color::Rgb(0, 0, 0));
-            let mask_color = mask_cell.style().fg.unwrap_or(Color::Rgb(255, 0, 0));
-
-            let color = blend(mask_color, cell_color, percentage);
-            cell.set_style(Style::new().fg(color));
-        }
-    }
-}
-
-fn blend(mask_color: Color, cell_color: Color, percentage: f64) -> Color {
-    let Color::Rgb(mask_red, mask_green, mask_blue) = mask_color else {
-        return mask_color;
-    };
-    let Color::Rgb(cell_red, cell_green, cell_blue) = cell_color else {
-        return mask_color;
-    };
-
-    let remain = 1.0 - percentage;
-
-    let red = f64::from(mask_red).mul_add(percentage, f64::from(cell_red) * remain);
-    let green = f64::from(mask_green).mul_add(percentage, f64::from(cell_green) * remain);
-    let blue = f64::from(mask_blue).mul_add(percentage, f64::from(cell_blue) * remain);
-
-    #[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
-    Color::Rgb(red as u8, green as u8, blue as u8)
-}
-
-/// a centered rect of the given size
-fn centered_rect(area: Rect, width: u16, height: u16) -> Rect {
-    let horizontal = Layout::horizontal([width]).flex(Flex::Center);
-    let vertical = Layout::vertical([height]).flex(Flex::Center);
-    let [area] = vertical.areas(area);
-    let [area] = horizontal.areas(area);
-    area
-}
--- a/examples/apps/demo2/src/main.rs
+++ b/examples/apps/demo2/src/main.rs
@@ -1,54 +0,0 @@
-//! # [Ratatui] Demo2 example
-//!
-//! The latest version of this example is available in the [examples] folder in the repository.
-//!
-//! Please note that the examples are designed to be run against the `main` branch of the Github
-//! repository. This means that you may not be able to compile with the latest release version on
-//! crates.io, or the one that you have installed locally.
-//!
-//! See the [examples readme] for more information on finding examples that match the version of the
-//! library you are using.
-//!
-//! [Ratatui]: https://github.com/ratatui/ratatui
-//! [examples]: https://github.com/ratatui/ratatui/blob/main/examples
-//! [examples readme]: https://github.com/ratatui/ratatui/blob/main/examples/README.md
-
-#![allow(
-    clippy::missing_errors_doc,
-    clippy::module_name_repetitions,
-    clippy::must_use_candidate
-)]
-
-mod app;
-mod colors;
-mod destroy;
-mod tabs;
-mod theme;
-
-use std::io::stdout;
-
-use app::App;
-use color_eyre::Result;
-use crossterm::{
-    execute,
-    terminal::{EnterAlternateScreen, LeaveAlternateScreen},
-};
-use ratatui::{layout::Rect, TerminalOptions, Viewport};
-
-pub use self::{
-    colors::{color_from_oklab, RgbSwatch},
-    theme::THEME,
-};
-
-fn main() -> Result<()> {
-    color_eyre::install()?;
-    // 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 viewport = Viewport::Fixed(Rect::new(0, 0, 81, 18));
-    let terminal = ratatui::init_with_options(TerminalOptions { viewport });
-    execute!(stdout(), EnterAlternateScreen).expect("failed to enter alternate screen");
-    let app_result = App::default().run(terminal);
-    execute!(stdout(), LeaveAlternateScreen).expect("failed to leave alternate screen");
-    ratatui::restore();
-    app_result
-}
--- a/examples/apps/demo2/src/tabs.rs
+++ b/examples/apps/demo2/src/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;
--- a/examples/apps/demo2/src/tabs/about.rs
+++ b/examples/apps/demo2/src/tabs/about.rs
@@ -1,165 +0,0 @@
-use itertools::Itertools;
-use ratatui::{
-    buffer::Buffer,
-    layout::{Alignment, Constraint, Layout, Margin, Rect},
-    widgets::{Block, Borders, Clear, Padding, Paragraph, Widget, Wrap},
-};
-
-use crate::{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█ █     ",
-];
-
-#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
-pub struct AboutTab {
-    row_index: usize,
-}
-
-impl AboutTab {
-    pub fn prev_row(&mut self) {
-        self.row_index = self.row_index.saturating_sub(1);
-    }
-
-    pub fn next_row(&mut self) {
-        self.row_index = self.row_index.saturating_add(1);
-    }
-}
-
-impl Widget for AboutTab {
-    fn render(self, area: Rect, buf: &mut Buffer) {
-        RgbSwatch.render(area, buf);
-        let horizontal = Layout::horizontal([Constraint::Length(34), Constraint::Min(0)]);
-        let [description, logo] = horizontal.areas(area);
-        render_crate_description(description, buf);
-        render_logo(self.row_index, logo, 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.
-#[allow(clippy::cast_possible_truncation)]
-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 = &mut buf[(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.bg = 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;
-                }
-                (_, _) => {}
-            };
-        }
-    }
-}
--- a/examples/apps/demo2/src/tabs/email.rs
+++ b/examples/apps/demo2/src/tabs/email.rs
@@ -1,158 +0,0 @@
-use itertools::Itertools;
-use ratatui::{
-    buffer::Buffer,
-    layout::{Constraint, Layout, Margin, Rect},
-    style::{Styled, Stylize},
-    text::Line,
-    widgets::{
-        Block, BorderType, Borders, Clear, List, ListItem, ListState, Padding, Paragraph,
-        Scrollbar, ScrollbarState, StatefulWidget, Tabs, Widget,
-    },
-};
-use unicode_width::UnicodeWidthStr;
-
-use crate::{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, Clone, Copy, Default, PartialEq, Eq)]
-pub struct EmailTab {
-    row_index: usize,
-}
-
-impl EmailTab {
-    /// Select the previous email (with wrap around).
-    pub fn prev(&mut self) {
-        self.row_index = self.row_index.saturating_add(EMAILS.len() - 1) % EMAILS.len();
-    }
-
-    /// Select the next email (with wrap around).
-    pub fn next(&mut self) {
-        self.row_index = self.row_index.saturating_add(1) % 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 vertical = Layout::vertical([Constraint::Length(5), Constraint::Min(0)]);
-        let [inbox, email] = vertical.areas(area);
-        render_inbox(self.row_index, inbox, buf);
-        render_email(self.row_index, email, buf);
-    }
-}
-fn render_inbox(selected_index: usize, area: Rect, buf: &mut Buffer) {
-    let vertical = Layout::vertical([Constraint::Length(1), Constraint::Min(0)]);
-    let [tabs, inbox] = vertical.areas(area);
-    let theme = THEME.email;
-    Tabs::new(vec![" Inbox ", " Sent ", " Drafts "])
-        .style(theme.tabs)
-        .highlight_style(theme.tabs_selected)
-        .select(0)
-        .divider("")
-        .render(tabs, 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()]))
-    });
-    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),
-        inbox,
-        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(inbox, 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 vertical = Layout::vertical([Constraint::Length(3), Constraint::Min(0)]);
-        let [headers_area, body_area] = vertical.areas(inner);
-        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(headers_area, buf);
-        let body = email.body.lines().map(Line::from).collect_vec();
-        Paragraph::new(body)
-            .style(theme.body)
-            .render(body_area, buf);
-    } else {
-        Paragraph::new("No email selected").render(inner, buf);
-    }
-}
--- a/examples/apps/demo2/src/tabs/recipe.rs
+++ b/examples/apps/demo2/src/tabs/recipe.rs
@@ -1,185 +0,0 @@
-use itertools::Itertools;
-use ratatui::{
-    buffer::Buffer,
-    layout::{Alignment, Constraint, Layout, Margin, Rect},
-    style::{Style, Stylize},
-    text::Line,
-    widgets::{
-        Block, Clear, Padding, Paragraph, Row, Scrollbar, ScrollbarOrientation, ScrollbarState,
-        StatefulWidget, Table, TableState, Widget, Wrap,
-    },
-};
-
-use crate::{RgbSwatch, THEME};
-
-#[derive(Debug, Default, Clone, Copy)]
-struct Ingredient {
-    quantity: &'static str,
-    name: &'static str,
-}
-
-impl Ingredient {
-    #[allow(clippy::cast_possible_truncation)]
-    fn height(&self) -> u16 {
-        self.name.lines().count() as u16
-    }
-}
-
-impl From<Ingredient> for Row<'_> {
-    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, Default, Clone, Copy, PartialEq, Eq)]
-pub struct RecipeTab {
-    row_index: usize,
-}
-
-impl RecipeTab {
-    /// Select the previous item in the ingredients list (with wrap around)
-    pub fn prev(&mut self) {
-        self.row_index = self.row_index.saturating_add(INGREDIENTS.len() - 1) % INGREDIENTS.len();
-    }
-
-    /// Select the next item in the ingredients list (with wrap around)
-    pub fn next(&mut self) {
-        self.row_index = self.row_index.saturating_add(1) % 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.row_index, scrollbar_area, buf);
-
-        let area = area.inner(Margin {
-            horizontal: 2,
-            vertical: 1,
-        });
-        let [recipe, ingredients] =
-            Layout::horizontal([Constraint::Length(44), Constraint::Min(0)]).areas(area);
-
-        render_recipe(recipe, buf);
-        render_ingredients(self.row_index, ingredients, 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().copied();
-    let theme = THEME.recipe;
-    StatefulWidget::render(
-        Table::new(rows, [Constraint::Length(7), Constraint::Length(30)])
-            .block(Block::new().style(theme.ingredients))
-            .header(Row::new(vec!["Qty", "Ingredient"]).style(theme.ingredients_header))
-            .row_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);
-}
--- a/examples/apps/demo2/src/tabs/traceroute.rs
+++ b/examples/apps/demo2/src/tabs/traceroute.rs
@@ -1,206 +0,0 @@
-use itertools::Itertools;
-use ratatui::{
-    buffer::Buffer,
-    layout::{Alignment, Constraint, Layout, Margin, Rect},
-    style::{Styled, Stylize},
-    symbols::Marker,
-    widgets::{
-        canvas::{self, Canvas, Map, MapResolution, Points},
-        Block, BorderType, Clear, Padding, Row, Scrollbar, ScrollbarOrientation, ScrollbarState,
-        Sparkline, StatefulWidget, Table, TableState, Widget,
-    },
-};
-
-use crate::{RgbSwatch, THEME};
-
-#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
-pub struct TracerouteTab {
-    row_index: usize,
-}
-
-impl TracerouteTab {
-    /// Select the previous row (with wrap around).
-    pub fn prev_row(&mut self) {
-        self.row_index = self.row_index.saturating_add(HOPS.len() - 1) % HOPS.len();
-    }
-
-    /// Select the next row (with wrap around).
-    pub fn next_row(&mut self) {
-        self.row_index = self.row_index.saturating_add(1) % 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 horizontal = Layout::horizontal([Constraint::Ratio(1, 2), Constraint::Ratio(1, 2)]);
-        let vertical = Layout::vertical([Constraint::Min(0), Constraint::Length(3)]);
-        let [left, map] = horizontal.areas(area);
-        let [hops, pings] = vertical.areas(left);
-
-        render_hops(self.row_index, hops, buf);
-        render_ping(self.row_index, pings, buf);
-        render_map(self.row_index, map, 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]));
-    let block = Block::new()
-        .padding(Padding::new(1, 1, 1, 1))
-        .title_alignment(Alignment::Center)
-        .title("Traceroute bad.horse".bold().white());
-    StatefulWidget::render(
-        Table::new(rows, [Constraint::Max(100), Constraint::Length(15)])
-            .header(Row::new(vec!["Host", "Address"]).set_style(THEME.traceroute.header))
-            .row_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: 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),
-];
--- a/examples/apps/demo2/src/tabs/weather.rs
+++ b/examples/apps/demo2/src/tabs/weather.rs
@@ -1,164 +0,0 @@
-use itertools::Itertools;
-use palette::Okhsv;
-use ratatui::{
-    buffer::Buffer,
-    layout::{Constraint, Direction, Layout, Margin, Rect},
-    style::{Color, Style, Stylize},
-    symbols,
-    widgets::{
-        calendar::{CalendarEventStore, Monthly},
-        Bar, BarChart, BarGroup, Block, Clear, LineGauge, Padding, Widget,
-    },
-};
-use time::OffsetDateTime;
-
-use crate::{color_from_oklab, RgbSwatch, THEME};
-
-#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
-pub struct WeatherTab {
-    pub download_progress: usize,
-}
-
-impl WeatherTab {
-    /// Simulate a download indicator by decrementing the row index.
-    pub fn prev(&mut self) {
-        self.download_progress = self.download_progress.saturating_sub(1);
-    }
-
-    /// Simulate a download indicator by incrementing the row index.
-    pub fn next(&mut self) {
-        self.download_progress = self.download_progress.saturating_add(1);
-    }
-}
-
-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 [main, _, gauges] = Layout::vertical([
-            Constraint::Min(0),
-            Constraint::Length(1),
-            Constraint::Length(1),
-        ])
-        .areas(area);
-        let [calendar, charts] =
-            Layout::horizontal([Constraint::Length(23), Constraint::Min(0)]).areas(main);
-        let [simple, horizontal] =
-            Layout::vertical([Constraint::Length(29), Constraint::Min(0)]).areas(charts);
-
-        render_calendar(calendar, buf);
-        render_simple_barchart(simple, buf);
-        render_horizontal_barchart(horizontal, buf);
-        render_gauge(self.download_progress, gauges, buf);
-    }
-}
-
-fn render_calendar(area: Rect, buf: &mut Buffer) {
-    let date = OffsetDateTime::now_utc().date();
-    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/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)
-        })
-        .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").value(51),
-        Bar::default().text_value("Spring 40-65").value(65),
-        Bar::default().text_value("Summer 54-77").value(77),
-        Bar::default()
-            .text_value("Fall 41-71")
-            .value(71)
-            .value_style(Style::new().bold()), // current season
-    ];
-    let group = BarGroup::default().label("GPU").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);
-}
-
-#[allow(clippy::cast_precision_loss)]
-pub fn render_gauge(progress: usize, area: Rect, buf: &mut Buffer) {
-    let percent = (progress * 3).min(100) as f64;
-
-    render_line_gauge(percent, area, buf);
-}
-
-#[allow(clippy::cast_possible_truncation)]
-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 filled_color = color_from_oklab(hue, Okhsv::max_saturation(), value);
-    let unfilled_color = 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())
-        .filled_style(Style::new().fg(filled_color))
-        .unfilled_style(Style::new().fg(unfilled_color))
-        .line_set(symbols::line::THICK)
-        .render(area, buf);
-}
--- a/examples/apps/demo2/src/theme.rs
+++ b/examples/apps/demo2/src/theme.rs
@@ -1,136 +0,0 @@
-use ratatui::style::{Color, Modifier, Style};
-
-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::Rgb(215, 0, 0);
-const BLACK: Color = Color::Rgb(8, 8, 8); // not really black, often #080808
-const DARK_GRAY: Color = Color::Rgb(68, 68, 68);
-const MID_GRAY: Color = Color::Rgb(128, 128, 128);
-const LIGHT_GRAY: Color = Color::Rgb(188, 188, 188);
-const WHITE: Color = Color::Rgb(238, 238, 238); // not really white, often #eeeeee
--- a/examples/apps/input-form/Cargo.toml
+++ b/examples/apps/input-form/Cargo.toml
@@ -1,16 +0,0 @@
-[package]
-name = "input-form"
-publish = false
-license.workspace = true
-edition.workspace = true
-rust-version.workspace = true
-
-[dependencies]
-color-eyre.workspace = true
-crossterm.workspace = true
-ratatui.workspace = true
-serde.workspace = true
-serde_json.workspace = true
-
-[lints]
-workspace = true
--- a/examples/apps/input-form/README.md
+++ b/examples/apps/input-form/README.md
@@ -1,27 +0,0 @@
-# Input Form example
-
-This example demonstrates how to handle input across several form fields (2 strings and an number).
-It uses an enum to track the focused field, and sends keyboard events to one which is current.
-
-Run this example with:
-
-```shell
-cargo run -p input-form
-```
-
-This example does not handle things like cursor movement within the line (just keys and backspace).
-Most apps would benefit from using the following crates for text input rather than directly using
-strings:
-
- [`tui-input`](https://crates.io/crates/tui-input)
- [`tui-prompts`](https://crates.io/crates/tui-prompts)
- [`tui-textarea`](https://crates.io/crates/tui-textarea)
- [`rat-salsa`](https://crates.io/crates/rat-salsa)
-
-Some more ideas for handling focus can be found in:
-
- [`focusable`](https://crates.io/crates/focusable) (see also [Ratatui forum
-  post](https://forum.ratatui.rs/t/focusable-crate-manage-focus-state-for-your-widgets/73))
- [`rat-focus`](https://crates.io/crates/rat-focus)
- A useful [`Bevy` discssion](https://github.com/bevyengine/bevy/discussions/15374) about focus
-  more generally.
--- a/examples/apps/input-form/src/main.rs
+++ b/examples/apps/input-form/src/main.rs
@@ -1,270 +0,0 @@
-//! A Ratatui example that demonstrates how to handle input form focus
-//!
-//! This example demonstrates how to handle cursor and input focus between multiple fields in a
-//! form. You can navigate between fields using the Tab key.
-//!
-//! This does not handle cursor movement etc. This is just a simple example. In a real application,
-//! consider using [`tui-input`], or [`tui-prompts`], or [`tui-textarea`].
-//!
-//! This example runs with the Ratatui library code in the branch that you are currently reading.
-//! See the [`latest`] branch for the code which works with the most recent Ratatui release.
-//!
-//! [`latest`]: https://github.com/ratatui/ratatui/tree/latest
-//! [`tui-input`]: https://crates.io/crates/tui-input
-//! [`tui-prompts`]: https://crates.io/crates/tui-prompts
-//! [`tui-textarea`]: https://crates.io/crates/tui-textarea
-
-use color_eyre::Result;
-use crossterm::event::{self, Event, KeyCode, KeyEvent, KeyEventKind};
-use ratatui::{
-    buffer::Buffer,
-    layout::{Constraint, Layout, Offset, Rect},
-    style::Stylize,
-    text::Line,
-    widgets::Widget,
-    DefaultTerminal, Frame,
-};
-use serde::Serialize;
-
-fn main() -> Result<()> {
-    color_eyre::install()?;
-    let terminal = ratatui::init();
-    let result = App::default().run(terminal);
-    ratatui::restore();
-
-    // serialize the form to JSON if the user submitted it, otherwise print "Canceled"
-    match result {
-        Ok(Some(form)) => println!("{}", serde_json::to_string_pretty(&form)?),
-        Ok(None) => println!("Canceled"),
-        Err(err) => eprintln!("{err}"),
-    }
-    Ok(())
-}
-
-#[derive(Default)]
-struct App {
-    state: AppState,
-    form: InputForm,
-}
-
-#[derive(Default, PartialEq, Eq)]
-enum AppState {
-    #[default]
-    Running,
-    Cancelled,
-    Submitted,
-}
-
-impl App {
-    fn run(mut self, mut terminal: DefaultTerminal) -> Result<Option<InputForm>> {
-        while self.state == AppState::Running {
-            terminal.draw(|frame| self.render(frame))?;
-            self.handle_events()?;
-        }
-        match self.state {
-            AppState::Cancelled => Ok(None),
-            AppState::Submitted => Ok(Some(self.form)),
-            AppState::Running => unreachable!(),
-        }
-    }
-
-    fn render(&self, frame: &mut Frame) {
-        self.form.render(frame);
-    }
-
-    fn handle_events(&mut self) -> Result<()> {
-        match event::read()? {
-            Event::Key(event) if event.kind == KeyEventKind::Press => match event.code {
-                KeyCode::Esc => self.state = AppState::Cancelled,
-                KeyCode::Enter => self.state = AppState::Submitted,
-                _ => self.form.on_key_press(event),
-            },
-            _ => {}
-        }
-        Ok(())
-    }
-}
-
-#[derive(Serialize)]
-struct InputForm {
-    #[serde(skip)]
-    focus: Focus,
-    first_name: StringField,
-    last_name: StringField,
-    age: AgeField,
-}
-
-impl Default for InputForm {
-    fn default() -> Self {
-        Self {
-            focus: Focus::FirstName,
-            first_name: StringField::new("First Name"),
-            last_name: StringField::new("Last Name"),
-            age: AgeField::new("Age"),
-        }
-    }
-}
-
-impl InputForm {
-    // Handle focus navigation or pass the event to the focused field.
-    fn on_key_press(&mut self, event: KeyEvent) {
-        match event.code {
-            KeyCode::Tab => self.focus = self.focus.next(),
-            _ => match self.focus {
-                Focus::FirstName => self.first_name.on_key_press(event),
-                Focus::LastName => self.last_name.on_key_press(event),
-                Focus::Age => self.age.on_key_press(event),
-            },
-        }
-    }
-
-    /// Render the form with the current focus.
-    ///
-    /// The cursor is placed at the end of the focused field.
-    fn render(&self, frame: &mut Frame) {
-        let [first_name_area, last_name_area, age_area] =
-            Layout::vertical(Constraint::from_lengths([1, 1, 1])).areas(frame.area());
-
-        frame.render_widget(&self.first_name, first_name_area);
-        frame.render_widget(&self.last_name, last_name_area);
-        frame.render_widget(&self.age, age_area);
-
-        let cursor_position = match self.focus {
-            Focus::FirstName => first_name_area.offset(self.first_name.cursor_offset()),
-            Focus::LastName => last_name_area.offset(self.last_name.cursor_offset()),
-            Focus::Age => age_area.offset(self.age.cursor_offset()),
-        };
-        frame.set_cursor_position(cursor_position);
-    }
-}
-
-#[derive(Default, PartialEq, Eq)]
-enum Focus {
-    #[default]
-    FirstName,
-    LastName,
-    Age,
-}
-
-impl Focus {
-    // Round-robin focus order.
-    const fn next(&self) -> Self {
-        match self {
-            Self::FirstName => Self::LastName,
-            Self::LastName => Self::Age,
-            Self::Age => Self::FirstName,
-        }
-    }
-}
-
-/// A new-type representing a string field with a label.
-#[derive(Debug, Serialize)]
-struct StringField {
-    #[serde(skip)]
-    label: &'static str,
-    value: String,
-}
-
-impl StringField {
-    const fn new(label: &'static str) -> Self {
-        Self {
-            label,
-            value: String::new(),
-        }
-    }
-
-    /// Handle input events for the string input.
-    fn on_key_press(&mut self, event: KeyEvent) {
-        match event.code {
-            KeyCode::Char(c) => self.value.push(c),
-            KeyCode::Backspace => {
-                self.value.pop();
-            }
-            _ => {}
-        }
-    }
-
-    fn cursor_offset(&self) -> Offset {
-        let x = (self.label.len() + self.value.len() + 2) as i32;
-        Offset::new(x, 0)
-    }
-}
-
-impl Widget for &StringField {
-    fn render(self, area: Rect, buf: &mut Buffer) {
-        let constraints = [
-            Constraint::Length(self.label.len() as u16 + 2),
-            Constraint::Fill(1),
-        ];
-        let [label_area, value_area] = Layout::horizontal(constraints).areas(area);
-        let label = Line::from_iter([self.label, ": "]).bold();
-        label.render(label_area, buf);
-        self.value.clone().render(value_area, buf);
-    }
-}
-
-/// A new-type representing a person's age in years (0-130).
-#[derive(Default, Clone, Copy, Serialize)]
-struct AgeField {
-    #[serde(skip)]
-    label: &'static str,
-    value: u8,
-}
-
-impl AgeField {
-    const MAX: u8 = 130;
-
-    const fn new(label: &'static str) -> Self {
-        Self { label, value: 0 }
-    }
-
-    /// Handle input events for the age input.
-    ///
-    /// Digits are accepted as input, with any input which would exceed the maximum age being
-    /// ignored. The up/down arrow keys and 'j'/'k' keys can be used to increment/decrement the
-    /// age.
-    fn on_key_press(&mut self, event: KeyEvent) {
-        match event.code {
-            KeyCode::Char(digit @ '0'..='9') => {
-                let value = self
-                    .value
-                    .saturating_mul(10)
-                    .saturating_add(digit as u8 - b'0');
-                if value <= Self::MAX {
-                    self.value = value;
-                }
-            }
-            KeyCode::Backspace => self.value /= 10,
-            KeyCode::Up | KeyCode::Char('k') => self.increment(),
-            KeyCode::Down | KeyCode::Char('j') => self.decrement(),
-            _ => {}
-        };
-    }
-
-    fn increment(&mut self) {
-        self.value = self.value.saturating_add(1).min(Self::MAX);
-    }
-
-    fn decrement(&mut self) {
-        self.value = self.value.saturating_sub(1);
-    }
-
-    fn cursor_offset(&self) -> Offset {
-        let x = (self.label.len() + self.value.to_string().len() + 2) as i32;
-        Offset::new(x, 0)
-    }
-}
-
-impl Widget for &AgeField {
-    fn render(self, area: Rect, buf: &mut Buffer) {
-        let constraints = [
-            Constraint::Length(self.label.len() as u16 + 2),
-            Constraint::Fill(1),
-        ];
-        let [label_area, value_area] = Layout::horizontal(constraints).areas(area);
-        let label = Line::from_iter([self.label, ": "]).bold();
-        let value = self.value.to_string();
-        label.render(label_area, buf);
-        value.render(value_area, buf);
-    }
-}
--- a/examples/apps/mouse-drawing/Cargo.toml
+++ b/examples/apps/mouse-drawing/Cargo.toml
@@ -1,17 +0,0 @@
-[package]
-name = "mouse-drawing"
-publish = false
-license.workspace = true
-edition.workspace = true
-rust-version.workspace = true
-
-[dependencies]
-color-eyre.workspace = true
-crossterm.workspace = true
-## a collection of line drawing algorithms (e.g. Bresenham's line algorithm)
-line_drawing = "1.0.0"
-rand = "0.8.5"
-ratatui.workspace = true
-
-[lints]
-workspace = true
--- a/examples/apps/mouse-drawing/README.md
+++ b/examples/apps/mouse-drawing/README.md
@@ -1,9 +0,0 @@
-# Mouse drawing demo
-
-This example shows how to receive mouse and handle mouse events.
-
-To run this demo:
-
-```shell
-cargo run -p mouse-drawing
-```
--- a/examples/apps/mouse-drawing/src/main.rs
+++ b/examples/apps/mouse-drawing/src/main.rs
@@ -1,123 +0,0 @@
-/// A Ratatui example that demonstrates how to handle mouse events.
-///
-/// This example demonstrates how to handle mouse events in Ratatui. You can draw lines by
-/// clicking and dragging the mouse.
-///
-/// This example runs with the Ratatui library code in the branch that you are currently
-/// reading. See the [`latest`] branch for the code which works with the most recent Ratatui
-/// release.
-///
-/// [`latest`]: https://github.com/ratatui/ratatui/tree/latest
-use color_eyre::Result;
-use crossterm::{
-    event::{
-        self, DisableMouseCapture, EnableMouseCapture, Event, KeyCode, KeyEvent, MouseEvent,
-        MouseEventKind,
-    },
-    execute,
-};
-use ratatui::{
-    layout::{Position, Rect, Size},
-    style::{Color, Stylize},
-    symbols,
-    text::Line,
-    DefaultTerminal, Frame,
-};
-
-fn main() -> Result<()> {
-    color_eyre::install()?;
-    let terminal = ratatui::init();
-    let result = MouseDrawingApp::default().run(terminal);
-    ratatui::restore();
-    result
-}
-
-#[derive(Default)]
-struct MouseDrawingApp {
-    // Whether the app should exit
-    pub should_exit: bool,
-    // The last known mouse position
-    pub mouse_position: Option<Position>,
-    // The points that have been clicked / drawn by dragging the mouse
-    pub points: Vec<(Position, Color)>,
-    // The color to draw with
-    pub current_color: Color,
-}
-
-impl MouseDrawingApp {
-    fn run(mut self, mut terminal: DefaultTerminal) -> Result<()> {
-        execute!(std::io::stdout(), EnableMouseCapture)?;
-        while !self.should_exit {
-            terminal.draw(|frame| self.render(frame))?;
-            self.handle_events()?;
-        }
-        execute!(std::io::stdout(), DisableMouseCapture)?;
-        Ok(())
-    }
-
-    fn handle_events(&mut self) -> Result<()> {
-        match event::read()? {
-            Event::Key(event) => self.on_key_event(event),
-            Event::Mouse(event) => self.on_mouse_event(event),
-            _ => {}
-        }
-        Ok(())
-    }
-
-    /// Quit the app if the user presses 'q' or 'Esc'
-    fn on_key_event(&mut self, event: KeyEvent) {
-        match event.code {
-            KeyCode::Char(' ') => {
-                self.current_color = Color::Rgb(rand::random(), rand::random(), rand::random());
-            }
-            KeyCode::Char('q') | KeyCode::Esc => self.should_exit = true,
-            _ => {}
-        }
-    }
-
-    /// Adds any points which were clicked or dragged to the `points` vector.
-    fn on_mouse_event(&mut self, event: MouseEvent) {
-        let position = Position::new(event.column, event.row);
-        match event.kind {
-            MouseEventKind::Down(_) => self.points.push((position, self.current_color)),
-            MouseEventKind::Drag(_) => self.draw_line(position),
-            _ => {}
-        }
-        self.mouse_position = Some(position);
-    }
-
-    /// Draw a line between the last point and the given position
-    fn draw_line(&mut self, position: Position) {
-        if let Some(start) = self.points.last() {
-            let (x0, y0) = (i32::from(start.0.x), i32::from(start.0.y));
-            let (x1, y1) = (i32::from(position.x), i32::from(position.y));
-            for (x, y) in line_drawing::Bresenham::new((x0, y0), (x1, y1)) {
-                let point = (Position::new(x as u16, y as u16), self.current_color);
-                self.points.push(point);
-            }
-        }
-    }
-
-    fn render(&self, frame: &mut Frame) {
-        // call order is important here as later elements are drawn on top of earlier elements
-        self.render_points(frame);
-        self.render_mouse_cursor(frame);
-        let value = "Mouse Example ('Esc' to quit. Click / drag to draw. 'Space' to change color)";
-        let title = Line::from(value).centered();
-        frame.render_widget(title, frame.area());
-    }
-
-    fn render_points(&self, frame: &mut Frame<'_>) {
-        for (position, color) in &self.points {
-            let area = Rect::from((*position, Size::new(1, 1))).clamp(frame.area());
-            frame.render_widget(symbols::block::FULL.fg(*color), area);
-        }
-    }
-
-    fn render_mouse_cursor(&self, frame: &mut Frame<'_>) {
-        if let Some(position) = self.mouse_position {
-            let area = Rect::from((position, Size::new(1, 1))).clamp(frame.area());
-            frame.render_widget("╳".bg(self.current_color), area);
-        }
-    }
-}
--- a/examples/apps/weather/Cargo.toml
+++ b/examples/apps/weather/Cargo.toml
@@ -1,15 +0,0 @@
-[package]
-name = "weather"
-publish = false
-license.workspace = true
-edition.workspace = true
-rust-version.workspace = true
-
-[dependencies]
-color-eyre.workspace = true
-crossterm.workspace = true
-rand = "0.8.5"
-ratatui.workspace = true
-
-[lints]
-workspace = true
--- a/examples/apps/weather/README.md
+++ b/examples/apps/weather/README.md
@@ -1,9 +0,0 @@
-# Weather demo
-
-This example shows how to render weather data using barchart widget.
-
-To run this demo:
-
-```shell
-cargo run -p weather
-```
--- a/examples/apps/weather/src/main.rs
+++ b/examples/apps/weather/src/main.rs
@@ -1,98 +0,0 @@
-//! A Ratatui example that demonstrates how to render weather data using [`BarChart`] widget.
-//!
-//! Generates random temperature data for each hour of the day and renders it as a vertical bar.
-//!
-//! This example runs with the Ratatui library code in the branch that you are currently reading.
-//! See the [`latest`] branch for the code which works with the most recent Ratatui release.
-//!
-//! [`latest`]: https://github.com/ratatui/ratatui/tree/latest
-//! [`BarChart`]: https://docs.rs/ratatui/latest/ratatui/widgets/struct.BarChart.html
-
-use color_eyre::Result;
-use rand::{thread_rng, Rng};
-use ratatui::{
-    crossterm::event::{self, Event, KeyCode, KeyEventKind},
-    layout::{Constraint, Layout},
-    style::{Color, Style, Stylize},
-    text::Line,
-    widgets::{Bar, BarChart, BarGroup},
-    DefaultTerminal, Frame,
-};
-
-fn main() -> Result<()> {
-    color_eyre::install()?;
-    let terminal = ratatui::init();
-    let app_result = App::new().run(terminal);
-    ratatui::restore();
-    app_result
-}
-
-struct App {
-    should_exit: bool,
-    temperatures: Vec<u8>,
-}
-
-impl App {
-    fn new() -> Self {
-        let mut rng = thread_rng();
-        let temperatures = (0..24).map(|_| rng.gen_range(50..90)).collect();
-        Self {
-            should_exit: false,
-            temperatures,
-        }
-    }
-
-    fn run(mut self, mut terminal: DefaultTerminal) -> Result<()> {
-        while !self.should_exit {
-            terminal.draw(|frame| self.draw(frame))?;
-            self.handle_events()?;
-        }
-        Ok(())
-    }
-
-    fn handle_events(&mut self) -> Result<()> {
-        if let Event::Key(key) = event::read()? {
-            if key.kind == KeyEventKind::Press && key.code == KeyCode::Char('q') {
-                self.should_exit = true;
-            }
-        }
-        Ok(())
-    }
-
-    fn draw(&self, frame: &mut Frame) {
-        let [title, main] = Layout::vertical([Constraint::Length(1), Constraint::Fill(1)])
-            .spacing(1)
-            .areas(frame.area());
-
-        frame.render_widget("Weather demo".bold().into_centered_line(), title);
-        frame.render_widget(vertical_barchart(&self.temperatures), main);
-    }
-}
-
-/// Create a vertical bar chart from the temperatures data.
-fn vertical_barchart(temperatures: &[u8]) -> BarChart {
-    let bars: Vec<Bar> = temperatures
-        .iter()
-        .enumerate()
-        .map(|(hour, value)| vertical_bar(hour, value))
-        .collect();
-    BarChart::default()
-        .data(BarGroup::default().bars(&bars))
-        .bar_width(5)
-}
-
-fn vertical_bar(hour: usize, temperature: &u8) -> Bar {
-    Bar::default()
-        .value(u64::from(*temperature))
-        .label(Line::from(format!("{hour:>02}:00")))
-        .text_value(format!("{temperature:>3}°"))
-        .style(temperature_style(*temperature))
-        .value_style(temperature_style(*temperature).reversed())
-}
-
-/// create a yellow to red value based on the value (50-90)
-fn temperature_style(value: u8) -> Style {
-    let green = (255.0 * (1.0 - f64::from(value - 50) / 40.0)) as u8;
-    let color = Color::Rgb(255, green, 0);
-    Style::new().fg(color)
-}
--- a/examples/barchart.rs
+++ b/examples/barchart.rs
@@ -0,0 +1,132 @@
+#[allow(dead_code)]
+mod util;
+
+use crate::util::event::{Event, Events};
+use std::{error::Error, io};
+use termion::{event::Key, input::MouseTerminal, raw::IntoRawMode, screen::AlternateScreen};
+use tui::{
+    backend::TermionBackend,
+    layout::{Constraint, Direction, Layout},
+    style::{Color, Modifier, Style},
+    widgets::{BarChart, Block, Borders},
+    Terminal,
+};
+
+struct App<'a> {
+    data: Vec<(&'a str, u64)>,
+}
+
+impl<'a> App<'a> {
+    fn new() -> App<'a> {
+        App {
+            data: vec![
+                ("B1", 9),
+                ("B2", 12),
+                ("B3", 5),
+                ("B4", 8),
+                ("B5", 2),
+                ("B6", 4),
+                ("B7", 5),
+                ("B8", 9),
+                ("B9", 14),
+                ("B10", 15),
+                ("B11", 1),
+                ("B12", 0),
+                ("B13", 4),
+                ("B14", 6),
+                ("B15", 4),
+                ("B16", 6),
+                ("B17", 4),
+                ("B18", 7),
+                ("B19", 13),
+                ("B20", 8),
+                ("B21", 11),
+                ("B22", 9),
+                ("B23", 3),
+                ("B24", 5),
+            ],
+        }
+    }
+
+    fn update(&mut self) {
+        let value = self.data.pop().unwrap();
+        self.data.insert(0, value);
+    }
+}
+
+fn main() -> Result<(), Box<dyn Error>> {
+    // Terminal initialization
+    let stdout = io::stdout().into_raw_mode()?;
+    let stdout = MouseTerminal::from(stdout);
+    let stdout = AlternateScreen::from(stdout);
+    let backend = TermionBackend::new(stdout);
+    let mut terminal = Terminal::new(backend)?;
+
+    // Setup event handlers
+    let events = Events::new();
+
+    // App
+    let mut app = App::new();
+
+    loop {
+        terminal.draw(|f| {
+            let chunks = Layout::default()
+                .direction(Direction::Vertical)
+                .margin(2)
+                .constraints([Constraint::Percentage(50), Constraint::Percentage(50)].as_ref())
+                .split(f.size());
+            let barchart = BarChart::default()
+                .block(Block::default().title("Data1").borders(Borders::ALL))
+                .data(&app.data)
+                .bar_width(9)
+                .bar_style(Style::default().fg(Color::Yellow))
+                .value_style(Style::default().fg(Color::Black).bg(Color::Yellow));
+            f.render_widget(barchart, chunks[0]);
+
+            let chunks = Layout::default()
+                .direction(Direction::Horizontal)
+                .constraints([Constraint::Percentage(50), Constraint::Percentage(50)].as_ref())
+                .split(chunks[1]);
+
+            let barchart = BarChart::default()
+                .block(Block::default().title("Data2").borders(Borders::ALL))
+                .data(&app.data)
+                .bar_width(5)
+                .bar_gap(3)
+                .bar_style(Style::default().fg(Color::Green))
+                .value_style(
+                    Style::default()
+                        .bg(Color::Green)
+                        .add_modifier(Modifier::BOLD),
+                );
+            f.render_widget(barchart, chunks[0]);
+
+            let barchart = BarChart::default()
+                .block(Block::default().title("Data3").borders(Borders::ALL))
+                .data(&app.data)
+                .bar_style(Style::default().fg(Color::Red))
+                .bar_width(7)
+                .bar_gap(0)
+                .value_style(Style::default().bg(Color::Red))
+                .label_style(
+                    Style::default()
+                        .fg(Color::Cyan)
+                        .add_modifier(Modifier::ITALIC),
+                );
+            f.render_widget(barchart, chunks[1]);
+        })?;
+
+        match events.next()? {
+            Event::Input(input) => {
+                if input == Key::Char('q') {
+                    break;
+                }
+            }
+            Event::Tick => {
+                app.update();
+            }
+        }
+    }
+
+    Ok(())
+}
--- a/examples/block.rs
+++ b/examples/block.rs
@@ -0,0 +1,86 @@
+#[allow(dead_code)]
+mod util;
+
+use crate::util::event::{Event, Events};
+use std::{error::Error, io};
+use termion::{event::Key, input::MouseTerminal, raw::IntoRawMode, screen::AlternateScreen};
+use tui::{
+    backend::TermionBackend,
+    layout::{Constraint, Direction, Layout},
+    style::{Color, Modifier, Style},
+    text::Span,
+    widgets::{Block, BorderType, Borders},
+    Terminal,
+};
+
+fn main() -> Result<(), Box<dyn Error>> {
+    // Terminal initialization
+    let stdout = io::stdout().into_raw_mode()?;
+    let stdout = MouseTerminal::from(stdout);
+    let stdout = AlternateScreen::from(stdout);
+    let backend = TermionBackend::new(stdout);
+    let mut terminal = Terminal::new(backend)?;
+
+    // Setup event handlers
+    let events = Events::new();
+
+    loop {
+        terminal.draw(|f| {
+            // Wrapping block for a group
+            // Just draw the block and the group on the same area and build the group
+            // with at least a margin of 1
+            let size = f.size();
+            let block = Block::default()
+                .borders(Borders::ALL)
+                .title("Main block with round corners")
+                .border_type(BorderType::Rounded);
+            f.render_widget(block, size);
+            let chunks = Layout::default()
+                .direction(Direction::Vertical)
+                .margin(4)
+                .constraints([Constraint::Percentage(50), Constraint::Percentage(50)].as_ref())
+                .split(f.size());
+
+            let top_chunks = Layout::default()
+                .direction(Direction::Horizontal)
+                .constraints([Constraint::Percentage(50), Constraint::Percentage(50)].as_ref())
+                .split(chunks[0]);
+            let block = Block::default()
+                .title(vec![
+                    Span::styled("With", Style::default().fg(Color::Yellow)),
+                    Span::from(" background"),
+                ])
+                .style(Style::default().bg(Color::Green));
+            f.render_widget(block, top_chunks[0]);
+
+            let block = Block::default().title(Span::styled(
+                "Styled title",
+                Style::default()
+                    .fg(Color::White)
+                    .bg(Color::Red)
+                    .add_modifier(Modifier::BOLD),
+            ));
+            f.render_widget(block, top_chunks[1]);
+
+            let bottom_chunks = Layout::default()
+                .direction(Direction::Horizontal)
+                .constraints([Constraint::Percentage(50), Constraint::Percentage(50)].as_ref())
+                .split(chunks[1]);
+            let block = Block::default().title("With borders").borders(Borders::ALL);
+            f.render_widget(block, bottom_chunks[0]);
+            let block = Block::default()
+                .title("With styled borders and doubled borders")
+                .border_style(Style::default().fg(Color::Cyan))
+                .borders(Borders::LEFT | Borders::RIGHT)
+                .border_type(BorderType::Double);
+            f.render_widget(block, bottom_chunks[1]);
+        })?;
+
+        if let Event::Input(key) = events.next()? {
+            if key == Key::Char('q') {
+                break;
+            }
+        }
+    }
+    Ok(())
+}
--- a/examples/canvas.rs
+++ b/examples/canvas.rs
@@ -0,0 +1,148 @@
+#[allow(dead_code)]
+mod util;
+
+use crate::util::event::{Config, Event, Events};
+use std::{error::Error, io, time::Duration};
+use termion::{event::Key, input::MouseTerminal, raw::IntoRawMode, screen::AlternateScreen};
+use tui::{
+    backend::TermionBackend,
+    layout::{Constraint, Direction, Layout, Rect},
+    style::Color,
+    widgets::{
+        canvas::{Canvas, Map, MapResolution, Rectangle},
+        Block, Borders,
+    },
+    Terminal,
+};
+
+struct App {
+    x: f64,
+    y: f64,
+    ball: Rectangle,
+    playground: Rect,
+    vx: f64,
+    vy: f64,
+    dir_x: bool,
+    dir_y: bool,
+}
+
+impl App {
+    fn new() -> App {
+        App {
+            x: 0.0,
+            y: 0.0,
+            ball: Rectangle {
+                x: 10.0,
+                y: 30.0,
+                width: 10.0,
+                height: 10.0,
+                color: Color::Yellow,
+            },
+            playground: Rect::new(10, 10, 100, 100),
+            vx: 1.0,
+            vy: 1.0,
+            dir_x: true,
+            dir_y: true,
+        }
+    }
+
+    fn update(&mut self) {
+        if self.ball.x < self.playground.left() as f64
+            || self.ball.x + self.ball.width > self.playground.right() as f64
+        {
+            self.dir_x = !self.dir_x;
+        }
+        if self.ball.y < self.playground.top() as f64
+            || self.ball.y + self.ball.height > self.playground.bottom() as f64
+        {
+            self.dir_y = !self.dir_y;
+        }
+
+        if self.dir_x {
+            self.ball.x += self.vx;
+        } else {
+            self.ball.x -= self.vx;
+        }
+
+        if self.dir_y {
+            self.ball.y += self.vy;
+        } else {
+            self.ball.y -= self.vy
+        }
+    }
+}
+
+fn main() -> Result<(), Box<dyn Error>> {
+    // Terminal initialization
+    let stdout = io::stdout().into_raw_mode()?;
+    let stdout = MouseTerminal::from(stdout);
+    let stdout = AlternateScreen::from(stdout);
+    let backend = TermionBackend::new(stdout);
+    let mut terminal = Terminal::new(backend)?;
+
+    // Setup event handlers
+    let config = Config {
+        tick_rate: Duration::from_millis(250),
+        ..Default::default()
+    };
+    let events = Events::with_config(config);
+
+    // App
+    let mut app = App::new();
+
+    loop {
+        terminal.draw(|f| {
+            let chunks = Layout::default()
+                .direction(Direction::Horizontal)
+                .constraints([Constraint::Percentage(50), Constraint::Percentage(50)].as_ref())
+                .split(f.size());
+            let canvas = Canvas::default()
+                .block(Block::default().borders(Borders::ALL).title("World"))
+                .paint(|ctx| {
+                    ctx.draw(&Map {
+                        color: Color::White,
+                        resolution: MapResolution::High,
+                    });
+                    ctx.print(app.x, -app.y, "You are here", Color::Yellow);
+                })
+                .x_bounds([-180.0, 180.0])
+                .y_bounds([-90.0, 90.0]);
+            f.render_widget(canvas, chunks[0]);
+            let canvas = Canvas::default()
+                .block(Block::default().borders(Borders::ALL).title("Pong"))
+                .paint(|ctx| {
+                    ctx.draw(&app.ball);
+                })
+                .x_bounds([10.0, 110.0])
+                .y_bounds([10.0, 110.0]);
+            f.render_widget(canvas, chunks[1]);
+        })?;
+
+        match events.next()? {
+            Event::Input(input) => match input {
+                Key::Char('q') => {
+                    break;
+                }
+                Key::Down => {
+                    app.y += 1.0;
+                }
+                Key::Up => {
+                    app.y -= 1.0;
+                }
+                Key::Right => {
+                    app.x += 1.0;
+                }
+                Key::Left => {
+                    app.x -= 1.0;
+                }
+
+                _ => {}
+            },
+            Event::Tick => {
+                app.update();
+            }
+        }
+    }
+
+    Ok(())
+}
--- a/examples/chart.rs
+++ b/examples/chart.rs
@@ -0,0 +1,246 @@
+#[allow(dead_code)]
+mod util;
+
+use crate::util::{
+    event::{Event, Events},
+    SinSignal,
+};
+use std::{error::Error, io};
+use termion::{event::Key, input::MouseTerminal, raw::IntoRawMode, screen::AlternateScreen};
+use tui::{
+    backend::TermionBackend,
+    layout::{Constraint, Direction, Layout},
+    style::{Color, Modifier, Style},
+    symbols,
+    text::Span,
+    widgets::{Axis, Block, Borders, Chart, Dataset, GraphType},
+    Terminal,
+};
+
+const DATA: [(f64, f64); 5] = [(0.0, 0.0), (1.0, 1.0), (2.0, 2.0), (3.0, 3.0), (4.0, 4.0)];
+const DATA2: [(f64, f64); 7] = [
+    (0.0, 0.0),
+    (10.0, 1.0),
+    (20.0, 0.5),
+    (30.0, 1.5),
+    (40.0, 1.0),
+    (50.0, 2.5),
+    (60.0, 3.0),
+];
+
+struct App {
+    signal1: SinSignal,
+    data1: Vec<(f64, f64)>,
+    signal2: SinSignal,
+    data2: Vec<(f64, f64)>,
+    window: [f64; 2],
+}
+
+impl App {
+    fn new() -> App {
+        let mut signal1 = SinSignal::new(0.2, 3.0, 18.0);
+        let mut signal2 = SinSignal::new(0.1, 2.0, 10.0);
+        let data1 = signal1.by_ref().take(200).collect::<Vec<(f64, f64)>>();
+        let data2 = signal2.by_ref().take(200).collect::<Vec<(f64, f64)>>();
+        App {
+            signal1,
+            data1,
+            signal2,
+            data2,
+            window: [0.0, 20.0],
+        }
+    }
+
+    fn update(&mut self) {
+        for _ in 0..5 {
+            self.data1.remove(0);
+        }
+        self.data1.extend(self.signal1.by_ref().take(5));
+        for _ in 0..10 {
+            self.data2.remove(0);
+        }
+        self.data2.extend(self.signal2.by_ref().take(10));
+        self.window[0] += 1.0;
+        self.window[1] += 1.0;
+    }
+}
+
+fn main() -> Result<(), Box<dyn Error>> {
+    // Terminal initialization
+    let stdout = io::stdout().into_raw_mode()?;
+    let stdout = MouseTerminal::from(stdout);
+    let stdout = AlternateScreen::from(stdout);
+    let backend = TermionBackend::new(stdout);
+    let mut terminal = Terminal::new(backend)?;
+
+    let events = Events::new();
+
+    // App
+    let mut app = App::new();
+
+    loop {
+        terminal.draw(|f| {
+            let size = f.size();
+            let chunks = Layout::default()
+                .direction(Direction::Vertical)
+                .constraints(
+                    [
+                        Constraint::Ratio(1, 3),
+                        Constraint::Ratio(1, 3),
+                        Constraint::Ratio(1, 3),
+                    ]
+                    .as_ref(),
+                )
+                .split(size);
+            let x_labels = vec![
+                Span::styled(
+                    format!("{}", app.window[0]),
+                    Style::default().add_modifier(Modifier::BOLD),
+                ),
+                Span::raw(format!("{}", (app.window[0] + app.window[1]) / 2.0)),
+                Span::styled(
+                    format!("{}", app.window[1]),
+                    Style::default().add_modifier(Modifier::BOLD),
+                ),
+            ];
+            let datasets = vec![
+                Dataset::default()
+                    .name("data2")
+                    .marker(symbols::Marker::Dot)
+                    .style(Style::default().fg(Color::Cyan))
+                    .data(&app.data1),
+                Dataset::default()
+                    .name("data3")
+                    .marker(symbols::Marker::Braille)
+                    .style(Style::default().fg(Color::Yellow))
+                    .data(&app.data2),
+            ];
+
+            let chart = Chart::new(datasets)
+                .block(
+                    Block::default()
+                        .title(Span::styled(
+                            "Chart 1",
+                            Style::default()
+                                .fg(Color::Cyan)
+                                .add_modifier(Modifier::BOLD),
+                        ))
+                        .borders(Borders::ALL),
+                )
+                .x_axis(
+                    Axis::default()
+                        .title("X Axis")
+                        .style(Style::default().fg(Color::Gray))
+                        .labels(x_labels)
+                        .bounds(app.window),
+                )
+                .y_axis(
+                    Axis::default()
+                        .title("Y Axis")
+                        .style(Style::default().fg(Color::Gray))
+                        .labels(vec![
+                            Span::styled("-20", Style::default().add_modifier(Modifier::BOLD)),
+                            Span::raw("0"),
+                            Span::styled("20", Style::default().add_modifier(Modifier::BOLD)),
+                        ])
+                        .bounds([-20.0, 20.0]),
+                );
+            f.render_widget(chart, chunks[0]);
+
+            let datasets = vec![Dataset::default()
+                .name("data")
+                .marker(symbols::Marker::Braille)
+                .style(Style::default().fg(Color::Yellow))
+                .graph_type(GraphType::Line)
+                .data(&DATA)];
+            let chart = Chart::new(datasets)
+                .block(
+                    Block::default()
+                        .title(Span::styled(
+                            "Chart 2",
+                            Style::default()
+                                .fg(Color::Cyan)
+                                .add_modifier(Modifier::BOLD),
+                        ))
+                        .borders(Borders::ALL),
+                )
+                .x_axis(
+                    Axis::default()
+                        .title("X Axis")
+                        .style(Style::default().fg(Color::Gray))
+                        .bounds([0.0, 5.0])
+                        .labels(vec![
+                            Span::styled("0", Style::default().add_modifier(Modifier::BOLD)),
+                            Span::raw("2.5"),
+                            Span::styled("5.0", Style::default().add_modifier(Modifier::BOLD)),
+                        ]),
+                )
+                .y_axis(
+                    Axis::default()
+                        .title("Y Axis")
+                        .style(Style::default().fg(Color::Gray))
+                        .bounds([0.0, 5.0])
+                        .labels(vec![
+                            Span::styled("0", Style::default().add_modifier(Modifier::BOLD)),
+                            Span::raw("2.5"),
+                            Span::styled("5.0", Style::default().add_modifier(Modifier::BOLD)),
+                        ]),
+                );
+            f.render_widget(chart, chunks[1]);
+
+            let datasets = vec![Dataset::default()
+                .name("data")
+                .marker(symbols::Marker::Braille)
+                .style(Style::default().fg(Color::Yellow))
+                .graph_type(GraphType::Line)
+                .data(&DATA2)];
+            let chart = Chart::new(datasets)
+                .block(
+                    Block::default()
+                        .title(Span::styled(
+                            "Chart 3",
+                            Style::default()
+                                .fg(Color::Cyan)
+                                .add_modifier(Modifier::BOLD),
+                        ))
+                        .borders(Borders::ALL),
+                )
+                .x_axis(
+                    Axis::default()
+                        .title("X Axis")
+                        .style(Style::default().fg(Color::Gray))
+                        .bounds([0.0, 50.0])
+                        .labels(vec![
+                            Span::styled("0", Style::default().add_modifier(Modifier::BOLD)),
+                            Span::raw("25"),
+                            Span::styled("50", Style::default().add_modifier(Modifier::BOLD)),
+                        ]),
+                )
+                .y_axis(
+                    Axis::default()
+                        .title("Y Axis")
+                        .style(Style::default().fg(Color::Gray))
+                        .bounds([0.0, 5.0])
+                        .labels(vec![
+                            Span::styled("0", Style::default().add_modifier(Modifier::BOLD)),
+                            Span::raw("2.5"),
+                            Span::styled("5", Style::default().add_modifier(Modifier::BOLD)),
+                        ]),
+                );
+            f.render_widget(chart, chunks[2]);
+        })?;
+
+        match events.next()? {
+            Event::Input(input) => {
+                if input == Key::Char('q') {
+                    break;
+                }
+            }
+            Event::Tick => {
+                app.update();
+            }
+        }
+    }
+
+    Ok(())
+}
--- a/examples/crossterm_demo.rs
+++ b/examples/crossterm_demo.rs
@@ -0,0 +1,108 @@
+#[allow(dead_code)]
+mod demo;
+#[allow(dead_code)]
+mod util;
+
+use crate::demo::{ui, App};
+use argh::FromArgs;
+use crossterm::{
+    event::{self, DisableMouseCapture, EnableMouseCapture, Event as CEvent, KeyCode},
+    execute,
+    terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
+};
+use std::{
+    error::Error,
+    io::{stdout, Write},
+    sync::mpsc,
+    thread,
+    time::{Duration, Instant},
+};
+use tui::{backend::CrosstermBackend, Terminal};
+
+enum Event<I> {
+    Input(I),
+    Tick,
+}
+
+/// Crossterm demo
+#[derive(Debug, FromArgs)]
+struct Cli {
+    /// time in ms between two ticks.
+    #[argh(option, default = "250")]
+    tick_rate: u64,
+    /// whether unicode symbols are used to improve the overall look of the app
+    #[argh(option, default = "true")]
+    enhanced_graphics: bool,
+}
+
+fn main() -> Result<(), Box<dyn Error>> {
+    let cli: Cli = argh::from_env();
+
+    enable_raw_mode()?;
+
+    let mut stdout = stdout();
+    execute!(stdout, EnterAlternateScreen, EnableMouseCapture)?;
+
+    let backend = CrosstermBackend::new(stdout);
+
+    let mut terminal = Terminal::new(backend)?;
+
+    // Setup input handling
+    let (tx, rx) = mpsc::channel();
+
+    let tick_rate = Duration::from_millis(cli.tick_rate);
+    thread::spawn(move || {
+        let mut last_tick = Instant::now();
+        loop {
+            // poll for tick rate duration, if no events, sent tick event.
+            let timeout = tick_rate
+                .checked_sub(last_tick.elapsed())
+                .unwrap_or_else(|| Duration::from_secs(0));
+            if event::poll(timeout).unwrap() {
+                if let CEvent::Key(key) = event::read().unwrap() {
+                    tx.send(Event::Input(key)).unwrap();
+                }
+            }
+            if last_tick.elapsed() >= tick_rate {
+                tx.send(Event::Tick).unwrap();
+                last_tick = Instant::now();
+            }
+        }
+    });
+
+    let mut app = App::new("Crossterm Demo", cli.enhanced_graphics);
+
+    terminal.clear()?;
+
+    loop {
+        terminal.draw(|f| ui::draw(f, &mut app))?;
+        match rx.recv()? {
+            Event::Input(event) => match event.code {
+                KeyCode::Char('q') => {
+                    disable_raw_mode()?;
+                    execute!(
+                        terminal.backend_mut(),
+                        LeaveAlternateScreen,
+                        DisableMouseCapture
+                    )?;
+                    terminal.show_cursor()?;
+                    break;
+                }
+                KeyCode::Char(c) => app.on_key(c),
+                KeyCode::Left => app.on_left(),
+                KeyCode::Up => app.on_up(),
+                KeyCode::Right => app.on_right(),
+                KeyCode::Down => app.on_down(),
+                _ => {}
+            },
+            Event::Tick => {
+                app.on_tick();
+            }
+        }
+        if app.should_quit {
+            break;
+        }
+    }
+
+    Ok(())
+}
--- a/examples/curses_demo.rs
+++ b/examples/curses_demo.rs
@@ -0,0 +1,74 @@
+mod demo;
+#[allow(dead_code)]
+mod util;
+
+use crate::demo::{ui, App};
+use argh::FromArgs;
+use std::{
+    error::Error,
+    io,
+    time::{Duration, Instant},
+};
+use tui::{backend::CursesBackend, Terminal};
+
+/// Curses demo
+#[derive(Debug, FromArgs)]
+struct Cli {
+    /// time in ms between two ticks.
+    #[argh(option, default = "250")]
+    tick_rate: u64,
+    /// whether unicode symbols are used to improve the overall look of the app
+    #[argh(option, default = "true")]
+    enhanced_graphics: bool,
+}
+
+fn main() -> Result<(), Box<dyn Error>> {
+    let cli: Cli = argh::from_env();
+
+    let mut backend =
+        CursesBackend::new().ok_or_else(|| io::Error::new(io::ErrorKind::Other, ""))?;
+    let curses = backend.get_curses_mut();
+    curses.set_echo(false);
+    curses.set_input_timeout(easycurses::TimeoutMode::WaitUpTo(50));
+    curses.set_input_mode(easycurses::InputMode::RawCharacter);
+    curses.set_keypad_enabled(true);
+    let mut terminal = Terminal::new(backend)?;
+    terminal.hide_cursor()?;
+
+    let mut app = App::new("Curses demo", cli.enhanced_graphics);
+
+    let mut last_tick = Instant::now();
+    let tick_rate = Duration::from_millis(cli.tick_rate);
+    loop {
+        terminal.draw(|f| ui::draw(f, &mut app))?;
+        if let Some(input) = terminal.backend_mut().get_curses_mut().get_input() {
+            match input {
+                easycurses::Input::Character(c) => {
+                    app.on_key(c);
+                }
+                easycurses::Input::KeyUp => {
+                    app.on_up();
+                }
+                easycurses::Input::KeyDown => {
+                    app.on_down();
+                }
+                easycurses::Input::KeyLeft => {
+                    app.on_left();
+                }
+                easycurses::Input::KeyRight => {
+                    app.on_right();
+                }
+                _ => {}
+            };
+        };
+        terminal.backend_mut().get_curses_mut().flush_input();
+        if last_tick.elapsed() > tick_rate {
+            app.on_tick();
+            last_tick = Instant::now();
+        }
+        if app.should_quit {
+            break;
+        }
+    }
+    Ok(())
+}
--- a/examples/custom_widget.rs
+++ b/examples/custom_widget.rs
@@ -0,0 +1,59 @@
+#[allow(dead_code)]
+mod util;
+
+use crate::util::event::{Event, Events};
+use std::{error::Error, io};
+use termion::{event::Key, input::MouseTerminal, raw::IntoRawMode, screen::AlternateScreen};
+use tui::{
+    backend::TermionBackend, buffer::Buffer, layout::Rect, style::Style, widgets::Widget, Terminal,
+};
+
+struct Label<'a> {
+    text: &'a str,
+}
+
+impl<'a> Default for Label<'a> {
+    fn default() -> Label<'a> {
+        Label { text: "" }
+    }
+}
+
+impl<'a> Widget for Label<'a> {
+    fn render(self, area: Rect, buf: &mut Buffer) {
+        buf.set_string(area.left(), area.top(), self.text, Style::default());
+    }
+}
+
+impl<'a> Label<'a> {
+    fn text(mut self, text: &'a str) -> Label<'a> {
+        self.text = text;
+        self
+    }
+}
+
+fn main() -> Result<(), Box<dyn Error>> {
+    // Terminal initialization
+    let stdout = io::stdout().into_raw_mode()?;
+    let stdout = MouseTerminal::from(stdout);
+    let stdout = AlternateScreen::from(stdout);
+    let backend = TermionBackend::new(stdout);
+    let mut terminal = Terminal::new(backend)?;
+
+    let events = Events::new();
+
+    loop {
+        terminal.draw(|f| {
+            let size = f.size();
+            let label = Label::default().text("Test");
+            f.render_widget(label, size);
+        })?;
+
+        if let Event::Input(key) = events.next()? {
+            if key == Key::Char('q') {
+                break;
+            }
+        }
+    }
+
+    Ok(())
+}
--- a/examples/apps/demo/src/app.rs
+++ b/examples/apps/demo/src/app.rs
@@ -1,8 +1,4 @@
-use rand::{
-    distributions::{Distribution, Uniform},
-    rngs::ThreadRng,
-};
-use ratatui::widgets::ListState;
+use crate::util::{RandomSignal, SinSignal, StatefulList, TabsState};

 const TASKS: [&str; 24] = [
    "Item1", "Item2", "Item3", "Item4", "Item5", "Item6", "Item7", "Item8", "Item9", "Item10",
@@ -66,120 +62,6 @@ const EVENTS: [(&str, u64); 24] = [
    ("B24", 5),
 ];

-#[derive(Clone)]
-pub struct RandomSignal {
-    distribution: Uniform<u64>,
-    rng: ThreadRng,
-}
-
-impl RandomSignal {
-    pub fn new(lower: u64, upper: u64) -> Self {
-        Self {
-            distribution: Uniform::new(lower, upper),
-            rng: rand::thread_rng(),
-        }
-    }
-}
-
-impl Iterator for RandomSignal {
-    type Item = u64;
-    fn next(&mut self) -> Option<u64> {
-        Some(self.distribution.sample(&mut self.rng))
-    }
-}
-
-#[derive(Clone)]
-pub struct SinSignal {
-    x: f64,
-    interval: f64,
-    period: f64,
-    scale: f64,
-}
-
-impl SinSignal {
-    pub const fn new(interval: f64, period: f64, scale: f64) -> Self {
-        Self {
-            x: 0.0,
-            interval,
-            period,
-            scale,
-        }
-    }
-}
-
-impl Iterator for SinSignal {
-    type Item = (f64, f64);
-    fn next(&mut self) -> Option<Self::Item> {
-        let point = (self.x, (self.x * 1.0 / self.period).sin() * self.scale);
-        self.x += self.interval;
-        Some(point)
-    }
-}
-
-pub struct TabsState<'a> {
-    pub titles: Vec<&'a str>,
-    pub index: usize,
-}
-
-impl<'a> TabsState<'a> {
-    pub const fn new(titles: Vec<&'a str>) -> Self {
-        Self { titles, index: 0 }
-    }
-    pub fn next(&mut self) {
-        self.index = (self.index + 1) % self.titles.len();
-    }
-
-    pub fn previous(&mut self) {
-        if self.index > 0 {
-            self.index -= 1;
-        } else {
-            self.index = self.titles.len() - 1;
-        }
-    }
-}
-
-pub struct StatefulList<T> {
-    pub state: ListState,
-    pub items: Vec<T>,
-}
-
-impl<T> StatefulList<T> {
-    pub fn with_items(items: Vec<T>) -> Self {
-        Self {
-            state: ListState::default(),
-            items,
-        }
-    }
-
-    pub fn next(&mut self) {
-        let i = match self.state.selected() {
-            Some(i) => {
-                if i >= self.items.len() - 1 {
-                    0
-                } else {
-                    i + 1
-                }
-            }
-            None => 0,
-        };
-        self.state.select(Some(i));
-    }
-
-    pub fn previous(&mut self) {
-        let i = match self.state.selected() {
-            Some(i) => {
-                if i == 0 {
-                    self.items.len() - 1
-                } else {
-                    i - 1
-                }
-            }
-            None => 0,
-        };
-        self.state.select(Some(i));
-    }
-}
-
 pub struct Signal<S: Iterator> {
    source: S,
    pub points: Vec<S::Item>,
@@ -191,7 +73,9 @@ where
    S: Iterator,
 {
    fn on_tick(&mut self) {
-        self.points.drain(0..self.tick_rate);
+        for _ in 0..self.tick_rate {
+            self.points.remove(0);
+        }
        self.points
            .extend(self.source.by_ref().take(self.tick_rate));
    }
@@ -235,7 +119,7 @@ pub struct App<'a> {
 }

 impl<'a> App<'a> {
-    pub fn new(title: &'a str, enhanced_graphics: bool) -> Self {
+    pub fn new(title: &'a str, enhanced_graphics: bool) -> App<'a> {
        let mut rand_signal = RandomSignal::new(0, 100);
        let sparkline_points = rand_signal.by_ref().take(300).collect();
        let mut sin_signal = SinSignal::new(0.2, 3.0, 18.0);
@@ -245,7 +129,7 @@ impl<'a> App<'a> {
        App {
            title,
            should_quit: false,
-            tabs: TabsState::new(vec!["Tab0", "Tab1", "Tab2"]),
+            tabs: TabsState::new(vec!["Tab0", "Tab1"]),
            show_chart: true,
            progress: 0.0,
            sparkline: Signal {
--- a/examples/demo/mod.rs
+++ b/examples/demo/mod.rs
@@ -0,0 +1,3 @@
+mod app;
+pub mod ui;
+pub use app::App;
--- a/examples/apps/demo/src/ui.rs
+++ b/examples/apps/demo/src/ui.rs
@@ -1,77 +1,92 @@
-use ratatui::{
-    layout::{Constraint, Layout, Rect},
+use crate::demo::App;
+use tui::{
+    backend::Backend,
+    layout::{Constraint, Direction, Layout, Rect},
    style::{Color, Modifier, Style},
    symbols,
-    text::{self, Span},
+    text::{Span, Spans},
+    widgets::canvas::{Canvas, Line, Map, MapResolution, Rectangle},
    widgets::{
-        canvas::{self, Canvas, Circle, Map, MapResolution, Rectangle},
-        Axis, BarChart, Block, Cell, Chart, Dataset, Gauge, LineGauge, List, ListItem, Paragraph,
-        Row, Sparkline, Table, Tabs, Wrap,
+        Axis, BarChart, Block, Borders, Chart, Dataset, Gauge, LineGauge, List, ListItem,
+        Paragraph, Row, Sparkline, Table, Tabs, Wrap,
    },
    Frame,
 };

-use crate::app::App;
-
-pub fn draw(frame: &mut Frame, app: &mut App) {
-    let chunks = Layout::vertical([Constraint::Length(3), Constraint::Min(0)]).split(frame.area());
-    let tabs = app
+pub fn draw<B: Backend>(f: &mut Frame<B>, app: &mut App) {
+    let chunks = Layout::default()
+        .constraints([Constraint::Length(3), Constraint::Min(0)].as_ref())
+        .split(f.size());
+    let titles = app
        .tabs
        .titles
        .iter()
-        .map(|t| text::Line::from(Span::styled(*t, Style::default().fg(Color::Green))))
-        .collect::<Tabs>()
-        .block(Block::bordered().title(app.title))
+        .map(|t| Spans::from(Span::styled(*t, Style::default().fg(Color::Green))))
+        .collect();
+    let tabs = Tabs::new(titles)
+        .block(Block::default().borders(Borders::ALL).title(app.title))
        .highlight_style(Style::default().fg(Color::Yellow))
        .select(app.tabs.index);
-    frame.render_widget(tabs, chunks[0]);
+    f.render_widget(tabs, chunks[0]);
    match app.tabs.index {
-        0 => draw_first_tab(frame, app, chunks[1]),
-        1 => draw_second_tab(frame, app, chunks[1]),
-        2 => draw_third_tab(frame, app, chunks[1]),
+        0 => draw_first_tab(f, app, chunks[1]),
+        1 => draw_second_tab(f, app, chunks[1]),
        _ => {}
    };
 }

-fn draw_first_tab(frame: &mut Frame, app: &mut App, area: Rect) {
-    let chunks = Layout::vertical([
-        Constraint::Length(9),
-        Constraint::Min(8),
-        Constraint::Length(7),
-    ])
-    .split(area);
-    draw_gauges(frame, app, chunks[0]);
-    draw_charts(frame, app, chunks[1]);
-    draw_text(frame, chunks[2]);
+fn draw_first_tab<B>(f: &mut Frame<B>, app: &mut App, area: Rect)
+where
+    B: Backend,
+{
+    let chunks = Layout::default()
+        .constraints(
+            [
+                Constraint::Length(9),
+                Constraint::Min(8),
+                Constraint::Length(7),
+            ]
+            .as_ref(),
+        )
+        .split(area);
+    draw_gauges(f, app, chunks[0]);
+    draw_charts(f, app, chunks[1]);
+    draw_text(f, chunks[2]);
 }

-fn draw_gauges(frame: &mut Frame, app: &mut App, area: Rect) {
-    let chunks = Layout::vertical([
-        Constraint::Length(2),
-        Constraint::Length(3),
-        Constraint::Length(2),
-    ])
-    .margin(1)
-    .split(area);
-    let block = Block::bordered().title("Graphs");
-    frame.render_widget(block, area);
+fn draw_gauges<B>(f: &mut Frame<B>, app: &mut App, area: Rect)
+where
+    B: Backend,
+{
+    let chunks = Layout::default()
+        .constraints(
+            [
+                Constraint::Length(2),
+                Constraint::Length(3),
+                Constraint::Length(1),
+            ]
+            .as_ref(),
+        )
+        .margin(1)
+        .split(area);
+    let block = Block::default().borders(Borders::ALL).title("Graphs");
+    f.render_widget(block, area);

    let label = format!("{:.2}%", app.progress * 100.0);
    let gauge = Gauge::default()
-        .block(Block::new().title("Gauge:"))
+        .block(Block::default().title("Gauge:"))
        .gauge_style(
            Style::default()
                .fg(Color::Magenta)
                .bg(Color::Black)
                .add_modifier(Modifier::ITALIC | Modifier::BOLD),
        )
-        .use_unicode(app.enhanced_graphics)
        .label(label)
        .ratio(app.progress);
-    frame.render_widget(gauge, chunks[0]);
+    f.render_widget(gauge, chunks[0]);

    let sparkline = Sparkline::default()
-        .block(Block::new().title("Sparkline:"))
+        .block(Block::default().title("Sparkline:"))
        .style(Style::default().fg(Color::Green))
        .data(&app.sparkline.points)
        .bar_set(if app.enhanced_graphics {
@@ -79,48 +94,55 @@ fn draw_gauges(frame: &mut Frame, app: &mut App, area: Rect) {
        } else {
            symbols::bar::THREE_LEVELS
        });
-    frame.render_widget(sparkline, chunks[1]);
+    f.render_widget(sparkline, chunks[1]);

    let line_gauge = LineGauge::default()
-        .block(Block::new().title("LineGauge:"))
-        .filled_style(Style::default().fg(Color::Magenta))
+        .block(Block::default().title("LineGauge:"))
+        .gauge_style(Style::default().fg(Color::Magenta))
        .line_set(if app.enhanced_graphics {
            symbols::line::THICK
        } else {
            symbols::line::NORMAL
        })
        .ratio(app.progress);
-    frame.render_widget(line_gauge, chunks[2]);
+    f.render_widget(line_gauge, chunks[2]);
 }

-#[allow(clippy::too_many_lines)]
-fn draw_charts(frame: &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 {
        vec![Constraint::Percentage(100)]
    };
-    let chunks = Layout::horizontal(constraints).split(area);
+    let chunks = Layout::default()
+        .constraints(constraints)
+        .direction(Direction::Horizontal)
+        .split(area);
    {
-        let chunks = Layout::vertical([Constraint::Percentage(50), Constraint::Percentage(50)])
+        let chunks = Layout::default()
+            .constraints([Constraint::Percentage(50), Constraint::Percentage(50)].as_ref())
            .split(chunks[0]);
        {
-            let chunks =
-                Layout::horizontal([Constraint::Percentage(50), Constraint::Percentage(50)])
-                    .split(chunks[0]);
+            let chunks = Layout::default()
+                .constraints([Constraint::Percentage(50), Constraint::Percentage(50)].as_ref())
+                .direction(Direction::Horizontal)
+                .split(chunks[0]);

            // Draw tasks
            let tasks: Vec<ListItem> = app
                .tasks
                .items
                .iter()
-                .map(|i| ListItem::new(vec![text::Line::from(Span::raw(*i))]))
+                .map(|i| ListItem::new(vec![Spans::from(Span::raw(*i))]))
                .collect();
            let tasks = List::new(tasks)
-                .block(Block::bordered().title("List"))
+                .block(Block::default().borders(Borders::ALL).title("List"))
                .highlight_style(Style::default().add_modifier(Modifier::BOLD))
                .highlight_symbol("> ");
-            frame.render_stateful_widget(tasks, chunks[0], &mut app.tasks.state);
+            f.render_stateful_widget(tasks, chunks[0], &mut app.tasks.state);

            // Draw logs
            let info_style = Style::default().fg(Color::Blue);
@@ -138,19 +160,19 @@ fn draw_charts(frame: &mut Frame, app: &mut App, area: Rect) {
                        "WARNING" => warning_style,
                        _ => info_style,
                    };
-                    let content = vec![text::Line::from(vec![
-                        Span::styled(format!("{level:<9}"), s),
+                    let content = vec![Spans::from(vec![
+                        Span::styled(format!("{:<9}", level), s),
                        Span::raw(evt),
                    ])];
                    ListItem::new(content)
                })
                .collect();
-            let logs = List::new(logs).block(Block::bordered().title("List"));
-            frame.render_stateful_widget(logs, chunks[1], &mut app.logs.state);
+            let logs = List::new(logs).block(Block::default().borders(Borders::ALL).title("List"));
+            f.render_stateful_widget(logs, chunks[1], &mut app.logs.state);
        }

        let barchart = BarChart::default()
-            .block(Block::bordered().title("Bar chart"))
+            .block(Block::default().borders(Borders::ALL).title("Bar chart"))
            .data(&app.barchart)
            .bar_width(3)
            .bar_gap(2)
@@ -167,7 +189,7 @@ fn draw_charts(frame: &mut Frame, app: &mut App, area: Rect) {
            )
            .label_style(Style::default().fg(Color::Yellow))
            .bar_style(Style::default().fg(Color::Green));
-        frame.render_widget(barchart, chunks[1]);
+        f.render_widget(barchart, chunks[1]);
    }
    if app.show_chart {
        let x_labels = vec![
@@ -202,12 +224,14 @@ fn draw_charts(frame: &mut Frame, app: &mut App, area: Rect) {
        ];
        let chart = Chart::new(datasets)
            .block(
-                Block::bordered().title(Span::styled(
-                    "Chart",
-                    Style::default()
-                        .fg(Color::Cyan)
-                        .add_modifier(Modifier::BOLD),
-                )),
+                Block::default()
+                    .title(Span::styled(
+                        "Chart",
+                        Style::default()
+                            .fg(Color::Cyan)
+                            .add_modifier(Modifier::BOLD),
+                    ))
+                    .borders(Borders::ALL),
            )
            .x_axis(
                Axis::default()
@@ -221,21 +245,24 @@ fn draw_charts(frame: &mut Frame, app: &mut App, area: Rect) {
                    .title("Y Axis")
                    .style(Style::default().fg(Color::Gray))
                    .bounds([-20.0, 20.0])
-                    .labels([
+                    .labels(vec![
                        Span::styled("-20", Style::default().add_modifier(Modifier::BOLD)),
                        Span::raw("0"),
                        Span::styled("20", Style::default().add_modifier(Modifier::BOLD)),
                    ]),
            );
-        frame.render_widget(chart, chunks[1]);
+        f.render_widget(chart, chunks[1]);
    }
 }

-fn draw_text(frame: &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(""),
-        text::Line::from(vec![
+        Spans::from("This is a paragraph with several lines. You can change style your text the way you want"),
+        Spans::from(""),
+        Spans::from(vec![
            Span::from("For example: "),
            Span::styled("under", Style::default().fg(Color::Red)),
            Span::raw(" "),
@@ -244,7 +271,7 @@ fn draw_text(frame: &mut Frame, area: Rect) {
            Span::styled("rainbow", Style::default().fg(Color::Blue)),
            Span::raw("."),
        ]),
-        text::Line::from(vec![
+        Spans::from(vec![
            Span::raw("Oh and if you didn't "),
            Span::styled("notice", Style::default().add_modifier(Modifier::ITALIC)),
            Span::raw(" you can "),
@@ -255,53 +282,53 @@ fn draw_text(frame: &mut Frame, area: Rect) {
            Span::styled("text", Style::default().add_modifier(Modifier::UNDERLINED)),
            Span::raw(".")
        ]),
-        text::Line::from(
+        Spans::from(
            "One more thing is that it should display unicode characters: 10€"
        ),
    ];
-    let block = Block::bordered().title(Span::styled(
+    let block = Block::default().borders(Borders::ALL).title(Span::styled(
        "Footer",
        Style::default()
            .fg(Color::Magenta)
            .add_modifier(Modifier::BOLD),
    ));
    let paragraph = Paragraph::new(text).block(block).wrap(Wrap { trim: true });
-    frame.render_widget(paragraph, area);
+    f.render_widget(paragraph, area);
 }

-fn draw_second_tab(frame: &mut Frame, app: &mut App, area: Rect) {
-    let chunks =
-        Layout::horizontal([Constraint::Percentage(30), Constraint::Percentage(70)]).split(area);
+fn draw_second_tab<B>(f: &mut Frame<B>, app: &mut App, area: Rect)
+where
+    B: Backend,
+{
+    let chunks = Layout::default()
+        .constraints([Constraint::Percentage(30), Constraint::Percentage(70)].as_ref())
+        .direction(Direction::Horizontal)
+        .split(area);
    let up_style = Style::default().fg(Color::Green);
    let failure_style = Style::default()
        .fg(Color::Red)
        .add_modifier(Modifier::RAPID_BLINK | Modifier::CROSSED_OUT);
+    let header = ["Server", "Location", "Status"];
    let rows = app.servers.iter().map(|s| {
        let style = if s.status == "Up" {
            up_style
        } else {
            failure_style
        };
-        Row::new(vec![s.name, s.location, s.status]).style(style)
+        Row::StyledData(vec![s.name, s.location, s.status].into_iter(), style)
    });
-    let table = Table::new(
-        rows,
-        [
+    let table = Table::new(header.iter(), rows)
+        .block(Block::default().title("Servers").borders(Borders::ALL))
+        .header_style(Style::default().fg(Color::Yellow))
+        .widths(&[
            Constraint::Length(15),
            Constraint::Length(15),
            Constraint::Length(10),
-        ],
-    )
-    .header(
-        Row::new(vec!["Server", "Location", "Status"])
-            .style(Style::default().fg(Color::Yellow))
-            .bottom_margin(1),
-    )
-    .block(Block::bordered().title("Servers"));
-    frame.render_widget(table, chunks[0]);
+        ]);
+    f.render_widget(table, chunks[0]);

    let map = Canvas::default()
-        .block(Block::bordered().title("World"))
+        .block(Block::default().title("World").borders(Borders::ALL))
        .paint(|ctx| {
            ctx.draw(&Map {
                color: Color::White,
@@ -315,15 +342,9 @@ fn draw_second_tab(frame: &mut Frame, app: &mut App, area: Rect) {
                height: 10.0,
                color: Color::Yellow,
            });
-            ctx.draw(&Circle {
-                x: app.servers[2].coords.1,
-                y: app.servers[2].coords.0,
-                radius: 10.0,
-                color: Color::Green,
-            });
            for (i, s1) in app.servers.iter().enumerate() {
                for s2 in &app.servers[i + 1..] {
-                    ctx.draw(&canvas::Line {
+                    ctx.draw(&Line {
                        x1: s1.coords.1,
                        y1: s1.coords.0,
                        y2: s2.coords.0,
@@ -338,11 +359,7 @@ fn draw_second_tab(frame: &mut Frame, app: &mut App, area: Rect) {
                } else {
                    Color::Red
                };
-                ctx.print(
-                    server.coords.1,
-                    server.coords.0,
-                    Span::styled("X", Style::default().fg(color)),
-                );
+                ctx.print(server.coords.1, server.coords.0, "X", color);
            }
        })
        .marker(if app.enhanced_graphics {
@@ -352,49 +369,5 @@ fn draw_second_tab(frame: &mut Frame, app: &mut App, area: Rect) {
        })
        .x_bounds([-180.0, 180.0])
        .y_bounds([-90.0, 90.0]);
-    frame.render_widget(map, chunks[1]);
-}
-
-fn draw_third_tab(frame: &mut Frame, _app: &mut App, area: Rect) {
-    let chunks = Layout::horizontal([Constraint::Ratio(1, 2), Constraint::Ratio(1, 2)]).split(area);
-    let colors = [
-        Color::Reset,
-        Color::Black,
-        Color::Red,
-        Color::Green,
-        Color::Yellow,
-        Color::Blue,
-        Color::Magenta,
-        Color::Cyan,
-        Color::Gray,
-        Color::DarkGray,
-        Color::LightRed,
-        Color::LightGreen,
-        Color::LightYellow,
-        Color::LightBlue,
-        Color::LightMagenta,
-        Color::LightCyan,
-        Color::White,
-    ];
-    let items: Vec<Row> = colors
-        .iter()
-        .map(|c| {
-            let cells = vec![
-                Cell::from(Span::raw(format!("{c:?}: "))),
-                Cell::from(Span::styled("Foreground", Style::default().fg(*c))),
-                Cell::from(Span::styled("Background", Style::default().bg(*c))),
-            ];
-            Row::new(cells)
-        })
-        .collect();
-    let table = Table::new(
-        items,
-        [
-            Constraint::Ratio(1, 3),
-            Constraint::Ratio(1, 3),
-            Constraint::Ratio(1, 3),
-        ],
-    )
-    .block(Block::bordered().title("Colors"));
-    frame.render_widget(table, chunks[0]);
+    f.render_widget(map, chunks[1]);
 }
--- a/examples/gauge.rs
+++ b/examples/gauge.rs
@@ -0,0 +1,126 @@
+#[allow(dead_code)]
+mod util;
+
+use crate::util::event::{Event, Events};
+use std::{error::Error, io};
+use termion::{event::Key, input::MouseTerminal, raw::IntoRawMode, screen::AlternateScreen};
+use tui::{
+    backend::TermionBackend,
+    layout::{Constraint, Direction, Layout},
+    style::{Color, Modifier, Style},
+    widgets::{Block, Borders, Gauge},
+    Terminal,
+};
+
+struct App {
+    progress1: u16,
+    progress2: u16,
+    progress3: f64,
+    progress4: u16,
+}
+
+impl App {
+    fn new() -> App {
+        App {
+            progress1: 0,
+            progress2: 0,
+            progress3: 0.0,
+            progress4: 0,
+        }
+    }
+
+    fn update(&mut self) {
+        self.progress1 += 5;
+        if self.progress1 > 100 {
+            self.progress1 = 0;
+        }
+        self.progress2 += 10;
+        if self.progress2 > 100 {
+            self.progress2 = 0;
+        }
+        self.progress3 += 0.001;
+        if self.progress3 > 1.0 {
+            self.progress3 = 0.0;
+        }
+        self.progress4 += 3;
+        if self.progress4 > 100 {
+            self.progress4 = 0;
+        }
+    }
+}
+
+fn main() -> Result<(), Box<dyn Error>> {
+    // Terminal initialization
+    let stdout = io::stdout().into_raw_mode()?;
+    let stdout = MouseTerminal::from(stdout);
+    let stdout = AlternateScreen::from(stdout);
+    let backend = TermionBackend::new(stdout);
+    let mut terminal = Terminal::new(backend)?;
+
+    let events = Events::new();
+
+    let mut app = App::new();
+
+    loop {
+        terminal.draw(|f| {
+            let chunks = Layout::default()
+                .direction(Direction::Vertical)
+                .margin(2)
+                .constraints(
+                    [
+                        Constraint::Percentage(25),
+                        Constraint::Percentage(25),
+                        Constraint::Percentage(25),
+                        Constraint::Percentage(25),
+                    ]
+                    .as_ref(),
+                )
+                .split(f.size());
+
+            let gauge = Gauge::default()
+                .block(Block::default().title("Gauge1").borders(Borders::ALL))
+                .gauge_style(Style::default().fg(Color::Yellow))
+                .percent(app.progress1);
+            f.render_widget(gauge, chunks[0]);
+
+            let label = format!("{}/100", app.progress2);
+            let gauge = Gauge::default()
+                .block(Block::default().title("Gauge2").borders(Borders::ALL))
+                .gauge_style(Style::default().fg(Color::Magenta).bg(Color::Green))
+                .percent(app.progress2)
+                .label(label);
+            f.render_widget(gauge, chunks[1]);
+
+            let gauge = Gauge::default()
+                .block(Block::default().title("Gauge3").borders(Borders::ALL))
+                .gauge_style(Style::default().fg(Color::Yellow))
+                .ratio(app.progress3);
+            f.render_widget(gauge, chunks[2]);
+
+            let label = format!("{}/100", app.progress2);
+            let gauge = Gauge::default()
+                .block(Block::default().title("Gauge4"))
+                .gauge_style(
+                    Style::default()
+                        .fg(Color::Cyan)
+                        .add_modifier(Modifier::ITALIC),
+                )
+                .percent(app.progress4)
+                .label(label);
+            f.render_widget(gauge, chunks[3]);
+        })?;
+
+        match events.next()? {
+            Event::Input(input) => {
+                if input == Key::Char('q') {
+                    break;
+                }
+            }
+            Event::Tick => {
+                app.update();
+            }
+        }
+    }
+
+    Ok(())
+}
--- a/examples/layout.rs
+++ b/examples/layout.rs
@@ -0,0 +1,52 @@
+#[allow(dead_code)]
+mod util;
+
+use crate::util::event::{Event, Events};
+use std::{error::Error, io};
+use termion::{event::Key, input::MouseTerminal, raw::IntoRawMode, screen::AlternateScreen};
+use tui::{
+    backend::TermionBackend,
+    layout::{Constraint, Direction, Layout},
+    widgets::{Block, Borders},
+    Terminal,
+};
+
+fn main() -> Result<(), Box<dyn Error>> {
+    // Terminal initialization
+    let stdout = io::stdout().into_raw_mode()?;
+    let stdout = MouseTerminal::from(stdout);
+    let stdout = AlternateScreen::from(stdout);
+    let backend = TermionBackend::new(stdout);
+    let mut terminal = Terminal::new(backend)?;
+
+    let events = Events::new();
+
+    loop {
+        terminal.draw(|f| {
+            let chunks = Layout::default()
+                .direction(Direction::Vertical)
+                .constraints(
+                    [
+                        Constraint::Percentage(10),
+                        Constraint::Percentage(80),
+                        Constraint::Percentage(10),
+                    ]
+                    .as_ref(),
+                )
+                .split(f.size());
+
+            let block = Block::default().title("Block").borders(Borders::ALL);
+            f.render_widget(block, chunks[0]);
+            let block = Block::default().title("Block 2").borders(Borders::ALL);
+            f.render_widget(block, chunks[2]);
+        })?;
+
+        if let Event::Input(input) = events.next()? {
+            if let Key::Char('q') = input {
+                break;
+            }
+        }
+    }
+
+    Ok(())
+}
--- a/examples/list.rs
+++ b/examples/list.rs
@@ -0,0 +1,193 @@
+#[allow(dead_code)]
+mod util;
+
+use crate::util::{
+    event::{Event, Events},
+    StatefulList,
+};
+use std::{error::Error, io};
+use termion::{event::Key, input::MouseTerminal, raw::IntoRawMode, screen::AlternateScreen};
+use tui::{
+    backend::TermionBackend,
+    layout::{Constraint, Corner, Direction, Layout},
+    style::{Color, Modifier, Style},
+    text::{Span, Spans},
+    widgets::{Block, Borders, List, ListItem},
+    Terminal,
+};
+
+struct App<'a> {
+    items: StatefulList<(&'a str, usize)>,
+    events: Vec<(&'a str, &'a str)>,
+}
+
+impl<'a> App<'a> {
+    fn new() -> App<'a> {
+        App {
+            items: StatefulList::with_items(vec![
+                ("Item0", 1),
+                ("Item1", 2),
+                ("Item2", 1),
+                ("Item3", 3),
+                ("Item4", 1),
+                ("Item5", 4),
+                ("Item6", 1),
+                ("Item7", 3),
+                ("Item8", 1),
+                ("Item9", 6),
+                ("Item10", 1),
+                ("Item11", 3),
+                ("Item12", 1),
+                ("Item13", 2),
+                ("Item14", 1),
+                ("Item15", 1),
+                ("Item16", 4),
+                ("Item17", 1),
+                ("Item18", 5),
+                ("Item19", 4),
+                ("Item20", 1),
+                ("Item21", 2),
+                ("Item22", 1),
+                ("Item23", 3),
+                ("Item24", 1),
+            ]),
+            events: vec![
+                ("Event1", "INFO"),
+                ("Event2", "INFO"),
+                ("Event3", "CRITICAL"),
+                ("Event4", "ERROR"),
+                ("Event5", "INFO"),
+                ("Event6", "INFO"),
+                ("Event7", "WARNING"),
+                ("Event8", "INFO"),
+                ("Event9", "INFO"),
+                ("Event10", "INFO"),
+                ("Event11", "CRITICAL"),
+                ("Event12", "INFO"),
+                ("Event13", "INFO"),
+                ("Event14", "INFO"),
+                ("Event15", "INFO"),
+                ("Event16", "INFO"),
+                ("Event17", "ERROR"),
+                ("Event18", "ERROR"),
+                ("Event19", "INFO"),
+                ("Event20", "INFO"),
+                ("Event21", "WARNING"),
+                ("Event22", "INFO"),
+                ("Event23", "INFO"),
+                ("Event24", "WARNING"),
+                ("Event25", "INFO"),
+                ("Event26", "INFO"),
+            ],
+        }
+    }
+
+    fn advance(&mut self) {
+        let event = self.events.pop().unwrap();
+        self.events.insert(0, event);
+    }
+}
+
+fn main() -> Result<(), Box<dyn Error>> {
+    // Terminal initialization
+    let stdout = io::stdout().into_raw_mode()?;
+    let stdout = MouseTerminal::from(stdout);
+    let stdout = AlternateScreen::from(stdout);
+    let backend = TermionBackend::new(stdout);
+    let mut terminal = Terminal::new(backend)?;
+
+    let events = Events::new();
+
+    // App
+    let mut app = App::new();
+
+    loop {
+        terminal.draw(|f| {
+            let chunks = Layout::default()
+                .direction(Direction::Horizontal)
+                .constraints([Constraint::Percentage(50), Constraint::Percentage(50)].as_ref())
+                .split(f.size());
+
+            let items: Vec<ListItem> = app
+                .items
+                .items
+                .iter()
+                .map(|i| {
+                    let mut lines = vec![Spans::from(i.0)];
+                    for _ in 0..i.1 {
+                        lines.push(Spans::from(Span::styled(
+                            "Lorem ipsum dolor sit amet, consectetur adipiscing elit.",
+                            Style::default().add_modifier(Modifier::ITALIC),
+                        )));
+                    }
+                    ListItem::new(lines).style(Style::default().fg(Color::Black).bg(Color::White))
+                })
+                .collect();
+            let items = List::new(items)
+                .block(Block::default().borders(Borders::ALL).title("List"))
+                .highlight_style(
+                    Style::default()
+                        .bg(Color::LightGreen)
+                        .add_modifier(Modifier::BOLD),
+                )
+                .highlight_symbol(">> ");
+            f.render_stateful_widget(items, chunks[0], &mut app.items.state);
+
+            let events: Vec<ListItem> = app
+                .events
+                .iter()
+                .map(|&(evt, level)| {
+                    let s = match level {
+                        "CRITICAL" => Style::default().fg(Color::Red),
+                        "ERROR" => Style::default().fg(Color::Magenta),
+                        "WARNING" => Style::default().fg(Color::Yellow),
+                        "INFO" => Style::default().fg(Color::Blue),
+                        _ => Style::default(),
+                    };
+                    let header = Spans::from(vec![
+                        Span::styled(format!("{:<9}", level), s),
+                        Span::raw(" "),
+                        Span::styled(
+                            "2020-01-01 10:00:00",
+                            Style::default().add_modifier(Modifier::ITALIC),
+                        ),
+                    ]);
+                    let log = Spans::from(vec![Span::raw(evt)]);
+                    ListItem::new(vec![
+                        Spans::from("-".repeat(chunks[1].width as usize)),
+                        header,
+                        Spans::from(""),
+                        log,
+                    ])
+                })
+                .collect();
+            let events_list = List::new(events)
+                .block(Block::default().borders(Borders::ALL).title("List"))
+                .start_corner(Corner::BottomLeft);
+            f.render_widget(events_list, chunks[1]);
+        })?;
+
+        match events.next()? {
+            Event::Input(input) => match input {
+                Key::Char('q') => {
+                    break;
+                }
+                Key::Left => {
+                    app.items.unselect();
+                }
+                Key::Down => {
+                    app.items.next();
+                }
+                Key::Up => {
+                    app.items.previous();
+                }
+                _ => {}
+            },
+            Event::Tick => {
+                app.advance();
+            }
+        }
+    }
+
+    Ok(())
+}
--- a/Show More
+++ b/Show More
				`@@ -1 +0,0 @@`
				`<!-- Please read CONTRIBUTING.md before submitting any pull request. -->`