Merge 05b4bffe3b into bcdcf70348

This highlight support for the Bazel build system.

.bcr/README.md

@@ -0,0 +1,9 @@
+# Bazel Central Registry
+
+When the ruleset is released, we want it to be published to the
+Bazel Central Registry automatically:
+<https://registry.bazel.build>
+
+This folder contains configuration files to automate the publish step.
+See <https://github.com/bazel-contrib/publish-to-bcr/blob/main/templates/README.md>
+for authoritative documentation about these files.

.bcr/metadata.template.json

@@ -0,0 +1,16 @@
+{
+  "homepage": "https://github.com/ArthurSonzogni/FTXUI",
+  "maintainers": [
+    {
+      "name": "Arthur Sonzogni",
+      "email": "sonzogniarthur@gmail.com",
+      "github": "ArthurSonzogni",
+      "github_user_id": 4759106
+    }
+  ],
+  "repository": [
+    "github:ArthurSonzogni/FTXUI"
+  ],
+  "versions": [],
+  "yanked_versions": {}
+}

.bcr/presubmit.yml

@@ -0,0 +1,24 @@
+# Copyright 2025 Arthur Sonzogni. All rights reserved.
+# Use of this source code is governed by the MIT license that can be found in
+# the LICENSE file.
+matrix:
+  platform:
+  - centos7
+  - debian10
+  - ubuntu2004
+  - macos
+  - windows
+  bazel: [6.x, 7.x, 8.x]
+tasks:
+  verify_targets:
+    name: Build and test.
+    platform: ${{ platform }}
+    bazel: ${{ bazel }}
+    build_targets:
+    - '@ftxui//:ftxui'
+    - '@ftxui//:screen'
+    - '@ftxui//:dom'
+    - '@ftxui//:component'
+    test_targets:
+    - '@ftxui//:tests'
+

.bcr/source.template.json

@@ -0,0 +1,5 @@
+{
+  "integrity": "",
+  "strip_prefix": "",
+  "url": "https://github.com/ArthurSonzogni/FTXUI/releases/download/{TAG}/source.tar.gz"
+}

.github/workflows/build.yaml

@@ -10,8 +10,41 @@ on:
       - main
 
 jobs:
-  test:
-    name: "Tests"
+
+  test_bazel:
+    name: "Bazel, ${{ matrix.compiler }}, ${{ matrix.os }}"
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-latest
+            compiler: gcc
+
+          - os: ubuntu-latest
+            compiler: llvm
+
+          - os: macos-latest
+            compiler: llvm
+
+          - os: macos-latest
+            compiler: gcc
+
+          - os: windows-latest
+            compiler: cl
+
+    runs-on: ${{ matrix.os }}
+    steps:
+      - name: "Checkout repository"
+        uses: actions/checkout@v3
+
+      - name: "Build with Bazel"
+        run: bazel build ...
+
+      - name: "Tests with Bazel"
+        run: bazel run tests
+
+  test_cmake:
+    name: "CMake, ${{ matrix.compiler }}, ${{ matrix.os }}"
     strategy:
       fail-fast: false
       matrix:
@@ -19,18 +52,16 @@ jobs:
           - name: Linux GCC
             os: ubuntu-latest
             compiler: gcc
-            gcov_executable: gcov
 
           - name: Linux Clang
             os: ubuntu-latest
             compiler: llvm
             gcov_executable: "llvm-cov gcov"
 
-          # https://github.com/aminya/setup-cpp/issues/246
-          #- name: MacOS clang
-            #os: macos-latest
-            #compiler: llvm
-            #gcov_executable: "llvm-cov gcov"
+          - name: MacOS clang
+            os: macos-latest
+            compiler: llvm
+            gcov_executable: "llvm-cov gcov"
 
           - name: Windows MSVC
             os: windows-latest
@@ -85,7 +116,7 @@ jobs:
           ctest -C Debug --rerun-failed --output-on-failure;
 
       - name: Unix - coverage
-        if: runner.os != 'Windows'
+        if: matrix.gcov_executable != ''
         working-directory: ./build
         run: >
           gcovr
@@ -122,9 +153,55 @@ jobs:
           name: ${{ runner.os }}-coverage
           files: ./build/coverage.xml
 
+  test_modules:
+    name: "Test modules"
+    strategy:
+      matrix:
+        include:
+          - os: ubuntu-latest
+            compiler: llvm
+          # TODO add gcc / msvc
+    runs-on: ${{ matrix.os }}
+    steps:
+      - name: "Checkout repository"
+        uses: actions/checkout@v3
+
+      - name: "Setup Cpp"
+        uses: aminya/setup-cpp@v1
+        with:
+          compiler: ${{ matrix.compiler }}
+          vcvarsall: ${{ contains(matrix.os, 'windows' )}}
+          cmake: true
+          ninja: true
+          clangtidy: false
+          cppcheck: false
+          opencppcoverage: false
+
+      - name: "Generate ./examples_modules"
+        run: >
+          ./tools/generate_examples_modules.sh
+
+      - name: "Build modules"
+        run: >
+          mkdir build;
+          cd build;
+          cmake ..
+          -DCMAKE_GENERATOR=Ninja
+          -DFTXUI_BUILD_MODULES=ON
+          -DFTXUI_BUILD_EXAMPLES=ON
+          -DCMAKE_BUILD_TYPE=Debug
+          -DFTXUI_BUILD_DOCS=OFF
+          -DFTXUI_BUILD_TESTS=OFF
+          -DFTXUI_BUILD_TESTS_FUZZER=OFF
+          -DFTXUI_ENABLE_INSTALL=ON
+          -DFTXUI_DEV_WARNINGS=ON ;
+          cmake --build .
+
   # Create a release on new v* tags
   release:
-    needs: test
+    needs:
+      - test_cmake
+      - test_bazel
     if: ${{ github.event_name == 'create' && startsWith(github.ref, 'refs/tags/v') }}
     name: "Create release"
     runs-on: ubuntu-latest
@@ -140,7 +217,7 @@ jobs:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
   # Build artifact for the release
-  package:
+  package_compiled:
     name: "Build packages"
     needs: release
     strategy:
@@ -184,6 +261,29 @@ jobs:
           upload_url: ${{ needs.release.outputs.upload_url }}
           asset_path: ${{ matrix.asset_path }}
           overwrite: true
+
+  # Build "source" artifact for the release. This is the same as the github
+  # "source" archive, but with a stable URL. This is useful for the Bazel
+  # Central Repository.
+  package_source:
+    name: "Build source package"
+    needs: release
+    runs-on: ubuntu-latest
+    steps:
+      - name: "Checkout repository"
+        uses: actions/checkout@v3
+
+      - name: "Create source package"
+        run: >
+          git archive --format=tar.gz -o source.tar.gz HEAD
+
+      - name: "Upload source package"
+        uses: shogo82148/actions-upload-release-asset@v1
+        with:
+          upload_url: ${{ needs.release.outputs.upload_url }}
+          asset_path: source.tar.gz
+          overwrite: true
+
   
   documentation:
     if: github.ref == 'refs/heads/main'

.github/workflows/codeql.yml

@@ -1,76 +0,0 @@
-# For most projects, this workflow file will not need changing; you simply need
-# to commit it to your repository.
-#
-# You may wish to alter this file to override the set of languages analyzed,
-# or to provide custom queries or build logic.
-#
-# ******** NOTE ********
-# We have attempted to detect the languages in your repository. Please check
-# the `language` matrix defined below to confirm you have the correct set of
-# supported CodeQL languages.
-#
-name: "CodeQL"
-
-on:
-  push:
-    branches: [ "main" ]
-  pull_request:
-    # The branches below must be a subset of the branches above
-    branches: [ "main" ]
-  schedule:
-    - cron: '45 22 * * 5'
-
-jobs:
-  analyze:
-    name: Analyze
-    runs-on: ${{ (matrix.language == 'swift' && 'macos-latest') || 'ubuntu-latest' }}
-    permissions:
-      actions: read
-      contents: read
-      security-events: write
-
-    strategy:
-      fail-fast: false
-      matrix:
-        language: [ 'cpp' ]
-        # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python', 'ruby' ]
-        # Use only 'java' to analyze code written in Java, Kotlin or both
-        # Use only 'javascript' to analyze code written in JavaScript, TypeScript or both
-        # Learn more about CodeQL language support at https://aka.ms/codeql-docs/language-support
-
-    steps:
-    - name: Checkout repository
-      uses: actions/checkout@v3
-
-    # Initializes the CodeQL tools for scanning.
-    - name: Initialize CodeQL
-      uses: github/codeql-action/init@v2
-      with:
-        languages: ${{ matrix.language }}
-        # If you wish to specify custom queries, you can do so here or in a config file.
-        # By default, queries listed here will override any specified in a config file.
-        # Prefix the list here with "+" to use these queries and those in the config file.
-
-        # For more details on CodeQL's query packs, refer to: https://docs.github.com/en/code-security/code-scanning/automatically-scanning-your-code-for-vulnerabilities-and-errors/configuring-code-scanning#using-queries-in-ql-packs
-        # queries: security-extended,security-and-quality
-
-
-    # Autobuild attempts to build any compiled languages  (C/C++, C#, Go, or Java).
-    # If this step fails, then you should remove it and run the build manually (see below)
-    - name: Autobuild
-      uses: github/codeql-action/autobuild@v2
-
-    # ℹ️ Command-line programs to run using the OS shell.
-    # 📚 See https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsrun
-
-    #   If the Autobuild fails above, remove it and uncomment the following three lines.
-    #   modify them (or add more) to build your code if your project, please refer to the EXAMPLE below for guidance.
-
-    # - run: |
-    #     echo "Run, Build Application using script"
-    #     ./location_of_script_within_repo/buildscript.sh
-
-    - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v2
-      with:
-        category: "/language:${{matrix.language}}"

.github/workflows/publish.yaml

@@ -0,0 +1,20 @@
+on:
+  # On manual trigger:
+  workflow_dispatch:
+    inputs:
+      tag_name:
+        required: true
+        type: string
+
+jobs:    
+  publish:
+    uses: bazel-contrib/publish-to-bcr/.github/workflows/publish.yaml@v0.0.4
+    with:
+      tag_name: ${{ inputs.tag_name }}
+      registry_fork: ArthurSonzogni/bazel-central-registry
+    permissions:
+      attestations: write
+      contents: write
+      id-token: write
+    secrets:
+      publish_token: ${{ secrets.PUBLISH_TOKEN }}

.gitignore

@@ -20,6 +20,10 @@ out/
 !flake.nix
 !ftxui.pc.in
 !iwyu.imp
+!WORKSPACE.bazel
+!BUILD.bazel
+!MODULE.bazel
+!.bazelrc
 
 # .github directory:
 !.github/**/*.yaml
@@ -29,6 +33,10 @@ out/
 !cmake/**/*.in
 !cmake/**/*.cmake
 
+# bazel directory:
+!bazel/**/*.bzl
+!.bcr/*
+
 # doc directory:
 !doc/**/Doxyfile.in
 !doc/**/*.txt
@@ -54,8 +62,10 @@ out/
 !include/ftxui/**/*.cpp
 
 # src directory:
+!src/ftxui/*.cppm
 !src/ftxui/**/*.hpp
 !src/ftxui/**/*.cpp
+!src/ftxui/**/*.cppm
 
 # tools directory:
 !tools/**/*.sh

BUILD.bazel

@@ -0,0 +1,251 @@
+# Copyright 2025 Arthur Sonzogni. All rights reserved.
+# Use of this source code is governed by the MIT license that can be found in
+# the LICENSE file.
+
+# TODO:
+# - Build benchmark.
+# - Build fuzzers.
+# - Build documentation.
+# - Enable the two tests timing out.
+# - Support WebAssembly
+
+load("@rules_cc//cc:defs.bzl", "cc_binary", "cc_library", "cc_test")
+load(":bazel/ftxui.bzl", "ftxui_cc_library")
+load(":bazel/ftxui.bzl", "generate_examples")
+load(":bazel/ftxui.bzl", "cpp20")
+load(":bazel/ftxui.bzl", "windows_copts")
+load(":bazel/ftxui.bzl", "pthread_linkopts")
+
+package(default_visibility = ["//visibility:public"])
+
+# A meta target that depends on all the ftxui sub modules.
+alias(
+    name = "ftxui",
+    # Note that :component depends on :dom, which depends on :screen. Bazel
+    # doesn't really support "public" and "private" dependencies. They are all
+    # public. This is equivalent to depending on all the submodules.
+    actual = ":component",
+    visibility = ["//visibility:public"],
+)
+
+# ftxui:screen is a module that provides a screen buffer and color management
+# for terminal applications. A screen is a 2D array of cells, each cell can
+# contain a glyph, a color, and other attributes. The library also provides
+# functions to manipulate the screen.
+ftxui_cc_library(
+    name = "screen",
+    srcs = [
+        "src/ftxui/screen/box.cpp",
+        "src/ftxui/screen/color.cpp",
+        "src/ftxui/screen/color_info.cpp",
+        "src/ftxui/screen/image.cpp",
+        "src/ftxui/screen/screen.cpp",
+        "src/ftxui/screen/string.cpp",
+        "src/ftxui/screen/string_internal.hpp",
+        "src/ftxui/screen/terminal.cpp",
+        "src/ftxui/screen/util.hpp",
+    ],
+    hdrs = [
+        "include/ftxui/screen/box.hpp",
+        "include/ftxui/screen/color.hpp",
+        "include/ftxui/screen/color_info.hpp",
+        "include/ftxui/screen/deprecated.hpp",
+        "include/ftxui/screen/image.hpp",
+        "include/ftxui/screen/pixel.hpp",
+        "include/ftxui/screen/screen.hpp",
+        "include/ftxui/screen/string.hpp",
+        "include/ftxui/screen/terminal.hpp",
+        "include/ftxui/util/autoreset.hpp",
+        "include/ftxui/util/ref.hpp",
+    ],
+)
+
+# ftxui:dom is a library that provides a way to create and manipulate a
+# "document" that can be rendered to a screen. The document is a tree of nodes.
+# Nodes can be text, layouts, or various decorators. Users needs to compose
+# nodes to create a document. A document is responsive to the size of the
+# screen.
+ftxui_cc_library(
+    name = "dom",
+    srcs = [
+        "src/ftxui/dom/automerge.cpp",
+        "src/ftxui/dom/blink.cpp",
+        "src/ftxui/dom/bold.cpp",
+        "src/ftxui/dom/border.cpp",
+        "src/ftxui/dom/box_helper.cpp",
+        "src/ftxui/dom/box_helper.hpp",
+        "src/ftxui/dom/canvas.cpp",
+        "src/ftxui/dom/clear_under.cpp",
+        "src/ftxui/dom/color.cpp",
+        "src/ftxui/dom/composite_decorator.cpp",
+        "src/ftxui/dom/dbox.cpp",
+        "src/ftxui/dom/dim.cpp",
+        "src/ftxui/dom/flex.cpp",
+        "src/ftxui/dom/flexbox.cpp",
+        "src/ftxui/dom/flexbox_config.cpp",
+        "src/ftxui/dom/flexbox_helper.cpp",
+        "src/ftxui/dom/flexbox_helper.hpp",
+        "src/ftxui/dom/focus.cpp",
+        "src/ftxui/dom/frame.cpp",
+        "src/ftxui/dom/gauge.cpp",
+        "src/ftxui/dom/graph.cpp",
+        "src/ftxui/dom/gridbox.cpp",
+        "src/ftxui/dom/hbox.cpp",
+        "src/ftxui/dom/hyperlink.cpp",
+        "src/ftxui/dom/inverted.cpp",
+        "src/ftxui/dom/italic.cpp",
+        "src/ftxui/dom/linear_gradient.cpp",
+        "src/ftxui/dom/node.cpp",
+        "src/ftxui/dom/node_decorator.cpp",
+        "src/ftxui/dom/node_decorator.hpp",
+        "src/ftxui/dom/paragraph.cpp",
+        "src/ftxui/dom/reflect.cpp",
+        "src/ftxui/dom/scroll_indicator.cpp",
+        "src/ftxui/dom/selection.cpp",
+        "src/ftxui/dom/selection_style.cpp",
+        "src/ftxui/dom/separator.cpp",
+        "src/ftxui/dom/size.cpp",
+        "src/ftxui/dom/spinner.cpp",
+        "src/ftxui/dom/strikethrough.cpp",
+        "src/ftxui/dom/table.cpp",
+        "src/ftxui/dom/text.cpp",
+        "src/ftxui/dom/underlined.cpp",
+        "src/ftxui/dom/underlined_double.cpp",
+        "src/ftxui/dom/util.cpp",
+        "src/ftxui/dom/vbox.cpp",
+    ],
+    hdrs = [
+        "include/ftxui/dom/canvas.hpp",
+        "include/ftxui/dom/deprecated.hpp",
+        "include/ftxui/dom/direction.hpp",
+        "include/ftxui/dom/elements.hpp",
+        "include/ftxui/dom/flexbox_config.hpp",
+        "include/ftxui/dom/linear_gradient.hpp",
+        "include/ftxui/dom/node.hpp",
+        "include/ftxui/dom/requirement.hpp",
+        "include/ftxui/dom/selection.hpp",
+        "include/ftxui/dom/table.hpp",
+        "include/ftxui/dom/take_any_args.hpp",
+    ],
+    deps = [":screen"],
+)
+
+# ftxui:component is a library to create "dynamic" component renderering and
+# updating a ftxui::dom document on the screen. It is a higher level API than
+# ftxui:dom.
+#
+# The module is required if your program needs to respond to user input. It
+# defines a set of ftxui::Component. These components can be utilized to
+# navigate using the arrow keys and/or cursor. There are several builtin widgets
+# like checkbox/inputbox/etc to interact with. You can combine them, or even
+# define your own custom components.
+ftxui_cc_library(
+    name = "component",
+    srcs = [
+        "src/ftxui/component/animation.cpp",
+        "src/ftxui/component/button.cpp",
+        "src/ftxui/component/catch_event.cpp",
+        "src/ftxui/component/checkbox.cpp",
+        "src/ftxui/component/collapsible.cpp",
+        "src/ftxui/component/component.cpp",
+        "src/ftxui/component/component_options.cpp",
+        "src/ftxui/component/container.cpp",
+        "src/ftxui/component/dropdown.cpp",
+        "src/ftxui/component/event.cpp",
+        "src/ftxui/component/hoverable.cpp",
+        "src/ftxui/component/input.cpp",
+        "src/ftxui/component/loop.cpp",
+        "src/ftxui/component/maybe.cpp",
+        "src/ftxui/component/menu.cpp",
+        "src/ftxui/component/modal.cpp",
+        "src/ftxui/component/radiobox.cpp",
+        "src/ftxui/component/renderer.cpp",
+        "src/ftxui/component/resizable_split.cpp",
+        "src/ftxui/component/screen_interactive.cpp",
+        "src/ftxui/component/slider.cpp",
+        "src/ftxui/component/terminal_input_parser.cpp",
+        "src/ftxui/component/terminal_input_parser.hpp",
+        "src/ftxui/component/util.cpp",
+        "src/ftxui/component/window.cpp",
+    ],
+    hdrs = [
+        "include/ftxui/component/animation.hpp",
+        "include/ftxui/component/captured_mouse.hpp",
+        "include/ftxui/component/component.hpp",
+        "include/ftxui/component/component_base.hpp",
+        "include/ftxui/component/component_options.hpp",
+        "include/ftxui/component/event.hpp",
+        "include/ftxui/component/loop.hpp",
+        "include/ftxui/component/mouse.hpp",
+        "include/ftxui/component/receiver.hpp",
+        "include/ftxui/component/screen_interactive.hpp",
+        "include/ftxui/component/task.hpp",
+    ],
+    linkopts = pthread_linkopts(),
+    deps = [":dom"],
+)
+
+# FTXUI's tests
+cc_test(
+    name = "tests",
+    testonly = True,
+    srcs = [
+        "src/ftxui/component/animation_test.cpp",
+        "src/ftxui/component/button_test.cpp",
+        "src/ftxui/component/collapsible_test.cpp",
+        "src/ftxui/component/component_test.cpp",
+        "src/ftxui/component/container_test.cpp",
+        "src/ftxui/component/dropdown_test.cpp",
+        "src/ftxui/component/hoverable_test.cpp",
+        "src/ftxui/component/input_test.cpp",
+        "src/ftxui/component/menu_test.cpp",
+        "src/ftxui/component/modal_test.cpp",
+        "src/ftxui/component/radiobox_test.cpp",
+        "src/ftxui/component/receiver_test.cpp",
+        "src/ftxui/component/resizable_split_test.cpp",
+        "src/ftxui/component/slider_test.cpp",
+        "src/ftxui/component/terminal_input_parser_test.cpp",
+        "src/ftxui/component/terminal_input_parser_test_fuzzer.cpp",
+        "src/ftxui/component/toggle_test.cpp",
+        "src/ftxui/dom/blink_test.cpp",
+        "src/ftxui/dom/bold_test.cpp",
+        "src/ftxui/dom/border_test.cpp",
+        "src/ftxui/dom/canvas_test.cpp",
+        "src/ftxui/dom/color_test.cpp",
+        "src/ftxui/dom/dbox_test.cpp",
+        "src/ftxui/dom/dim_test.cpp",
+        "src/ftxui/dom/flexbox_helper_test.cpp",
+        "src/ftxui/dom/flexbox_test.cpp",
+        "src/ftxui/dom/gauge_test.cpp",
+        "src/ftxui/dom/gridbox_test.cpp",
+        "src/ftxui/dom/hbox_test.cpp",
+        "src/ftxui/dom/hyperlink_test.cpp",
+        "src/ftxui/dom/italic_test.cpp",
+        "src/ftxui/dom/linear_gradient_test.cpp",
+        "src/ftxui/dom/scroll_indicator_test.cpp",
+        "src/ftxui/dom/separator_test.cpp",
+        "src/ftxui/dom/spinner_test.cpp",
+        "src/ftxui/dom/table_test.cpp",
+        "src/ftxui/dom/text_test.cpp",
+        "src/ftxui/dom/underlined_test.cpp",
+        "src/ftxui/dom/vbox_test.cpp",
+        "src/ftxui/screen/color_test.cpp",
+        "src/ftxui/screen/string_test.cpp",
+        "src/ftxui/util/ref_test.cpp",
+
+        # TODO: Enable the two tests timing out with Bazel:
+        # - "src/ftxui/component/screen_interactive_test.cpp",
+        # - "src/ftxui/dom/selection_test.cpp",
+    ],
+    includes = [
+        "include",
+        "src",
+    ],
+    copts = cpp20() + windows_copts(),
+    deps = [
+        "//:ftxui",
+        "@googletest//:gtest_main",
+    ],
+)
+
+generate_examples()

CHANGELOG.md

@@ -1,8 +1,84 @@
 Changelog
 =========
 
-current (development) 
----------------------
+Development
+-----------
+
+### Build
+- Feature: Support C++20 modules. 
+  This requires:
+  - Using the Ninja or MSVC generator
+  - A recent Clang/GCC/MSVC compiler.
+  - Cmake 3.28 or higher.
+  Usage:
+  ```cpp
+  import ftxui;
+  import ftxui.component;
+  import ftxui.dom;
+  import ftxui.screen;
+  ```
+  Thanks @mikomikotaishi for PR #1015.
+
+
+Future release
+------------
+
+6.1.1 (2025-04-30)
+-----------------
+
+### Build
+- Feature: Support `bazel` build system. See #1032.
+  Proposed by Kostya Serebryany @kcc
+  If all goes well (pending), it should appear in the Bazel central repository.
+  It can be imported into your project using the following lines:
+
+  **MODULE.bazel**
+  ```bazel
+  bazel_dep(name = "ftxui", version = "6.1.1")
+  ```
+
+  **BUILD.bazel**
+  ```bazel
+  deps = [
+    // Depend on the whole library:
+    "@ftxui//:ftxui",
+
+    // Choose a specific submodule:
+    "@ftxui//:component",
+    "@ftxui//:dom",
+    "@ftxui//:screen",
+  ]
+  ```
+
+### Component
+- Bugfix: Fix a crash with ResizeableSplit. See #1023.
+  - Clamp screen size to terminal size.
+  - Disallow `ResizeableSplit` with negative size.
+
+### Dom
+- Bugfix: Disallow specifying a negative size constraint. See #1023.
+
+
+6.0.2 (2025-03-30)
+-----
+
+### Component
+- BugFix: Fix major crash on Windows affecting all components. See #1020
+- BugFix: Fix focusRelative.
+
+6.0.1 (2025-03-28)
+-----
+
+Same as v6.0.0.
+
+Due to a problem tag v6.0.0 was replaced. This isn't a good practice and affect
+developers that started using it in the short timeframe. Submitting a new
+release with the same content is the best way to fix this.
+
+See #1017 and #1019.
+
+6.0.0 (2025-03-23)
+-----
 
 ### Component
 - Feature: Add support for raw input. Allowing more keys to be detected.
@@ -16,6 +92,9 @@ current (development)
 - Feature: Add support for `Input`'s insert mode. Add `InputOption::insert`
   option. Added by @mingsheng13.
 - Feature: Add `DropdownOption` to configure the dropdown. See #826.
+- Feature: Add support for Selection. Thanks @clement-roblot. See #926.
+  - See `ScreenInteractive::GetSelection()`.
+  - See `ScreenInteractive::SelectionChange(...)` listener.
 - Bugfix/Breaking change: `Mouse transition`:
   - Detect when the mouse move, as opposed to being pressed.
     The Mouse::Moved motion was added.
@@ -41,14 +120,37 @@ current (development)
   See #932
 - Feature: Add `SliderOption::on_change`. This allows to set a callback when the
   slider value changes. See #938.
+- Bugfix: Handle `Dropdown` with no entries.
+- Bugfix: Fix crash in `LinearGradient` due to float precision and an off-by-one
+          mistake. See #998.
 
 ### Dom
+- Feature: Add `italic` decorator. For instance:
+  ```cpp
+  auto italic_text = text("Italic text") | italic;
+  ```
+  ```cpp
+  auto italic_text = italic(text("Italic text"));
+  ```
+  Proposed by @kenReneris in #1009.
 - Feature: Add `hscroll_indicator`. It display an horizontal indicator
   reflecting the current scroll position. Proposed by @ibrahimnasson in
   [issue 752](https://github.com/ArthurSonzogni/FTXUI/issues/752)
 - Feature: Add `extend_beyond_screen` option to `Dimension::Fit(..)`, allowing
   the element to be larger than the screen. Proposed by @LordWhiro. See #572 and
   #949.
+- Feature: Add support for Selection. Thanks @clement-roblot. See #926.
+  - See `selectionColor` decorator.
+  - See `selectionBackgroundColor` decorator.
+  - See `selectionForegroundColor` decorator.
+  - See `selectionStyle(style)` decorator.
+  - See `selectionStyleReset` decorator.
+- Breaking change: Change how "focus"/"select" are handled. This fixes the
+  behavior.
+- Breaking change: `Component::OnRender()` becomes the method to override to
+  render a component. This replaces `Component::Render()` that is still in use
+  to call the rendering method on the children. This change allows to fix a
+  couple of issues around focus handling.
 
 ### Screen
 - Feature: Add `Box::IsEmpty()`.

CMakeLists.txt

@@ -1,20 +1,26 @@
-cmake_minimum_required(VERSION 3.12)
+option(FTXUI_BUILD_DOCS "Set to ON to build docs" OFF)
+option(FTXUI_BUILD_EXAMPLES "Set to ON to build examples" OFF)
+option(FTXUI_BUILD_MODULES "Build the C++20 modules" OFF)
+option(FTXUI_BUILD_TESTS "Set to ON to build tests" OFF)
+option(FTXUI_BUILD_TESTS_FUZZER "Set to ON to enable fuzzing" OFF)
+option(FTXUI_CLANG_TIDY "Execute clang-tidy" OFF)
+option(FTXUI_DEV_WARNINGS "Enable more compiler warnings and warnings as errors" OFF)
+option(FTXUI_ENABLE_COVERAGE "Execute code coverage" OFF)
+option(FTXUI_ENABLE_INSTALL "Generate the install target" ON)
+option(FTXUI_QUIET "Set to ON for FTXUI to be quiet" OFF)
+
+if (FTXUI_BUILD_MODULES)
+  cmake_minimum_required(VERSION 3.28.2)
+else()
+  cmake_minimum_required(VERSION 3.12)
+endif()
 
 project(ftxui
   LANGUAGES CXX
-  VERSION 5.0.0
+  VERSION 6.1.1
   DESCRIPTION "C++ Functional Terminal User Interface."
 )
 
-option(FTXUI_QUIET "Set to ON for FTXUI to be quiet" OFF)
-option(FTXUI_BUILD_EXAMPLES "Set to ON to build examples" OFF)
-option(FTXUI_BUILD_DOCS "Set to ON to build docs" OFF)
-option(FTXUI_BUILD_TESTS "Set to ON to build tests" OFF)
-option(FTXUI_BUILD_TESTS_FUZZER "Set to ON to enable fuzzing" OFF)
-option(FTXUI_ENABLE_INSTALL "Generate the install target" ON)
-option(FTXUI_CLANG_TIDY "Execute clang-tidy" OFF)
-option(FTXUI_ENABLE_COVERAGE "Execute code coverage" OFF)
-option(FTXUI_DEV_WARNINGS "Enable more compiler warnings and warnings as errors" OFF)
 
 set(FTXUI_MICROSOFT_TERMINAL_FALLBACK_HELP_TEXT "On windows, assume the \
 terminal used will be one of Microsoft and use a set of reasonnable fallback \
@@ -56,11 +62,12 @@ add_library(dom
   include/ftxui/dom/flexbox_config.hpp
   include/ftxui/dom/node.hpp
   include/ftxui/dom/requirement.hpp
+  include/ftxui/dom/selection.hpp
   include/ftxui/dom/take_any_args.hpp
   src/ftxui/dom/automerge.cpp
+  src/ftxui/dom/selection_style.cpp
   src/ftxui/dom/blink.cpp
   src/ftxui/dom/bold.cpp
-  src/ftxui/dom/hyperlink.cpp
   src/ftxui/dom/border.cpp
   src/ftxui/dom/box_helper.cpp
   src/ftxui/dom/box_helper.hpp
@@ -81,13 +88,16 @@ add_library(dom
   src/ftxui/dom/graph.cpp
   src/ftxui/dom/gridbox.cpp
   src/ftxui/dom/hbox.cpp
+  src/ftxui/dom/hyperlink.cpp
   src/ftxui/dom/inverted.cpp
+  src/ftxui/dom/italic.cpp
   src/ftxui/dom/linear_gradient.cpp
   src/ftxui/dom/node.cpp
   src/ftxui/dom/node_decorator.cpp
   src/ftxui/dom/paragraph.cpp
   src/ftxui/dom/reflect.cpp
   src/ftxui/dom/scroll_indicator.cpp
+  src/ftxui/dom/selection.cpp
   src/ftxui/dom/separator.cpp
   src/ftxui/dom/size.cpp
   src/ftxui/dom/spinner.cpp
@@ -172,6 +182,13 @@ include(cmake/iwyu.cmake)
 include(cmake/ftxui_export.cmake)
 include(cmake/ftxui_install.cmake)
 include(cmake/ftxui_package.cmake)
+include(cmake/ftxui_modules.cmake)
 
-add_subdirectory(examples)
 add_subdirectory(doc)
+add_subdirectory(examples)
+
+# You can generate ./examples_modules/ by running
+# ./tools/generate_examples_modules.sh
+if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/examples_modules/CMakeLists.txt")
+  add_subdirectory(examples_modules)
+endif()

MODULE.bazel

@@ -0,0 +1,13 @@
+# Copyright 2025 Arthur Sonzogni. All rights reserved.
+# Use of this source code is governed by the MIT license that can be found in
+# the LICENSE file.
+
+# FTXUI Module.
+module(name = "ftxui", version = "6.1.1")
+
+# Build deps.
+bazel_dep(name = "rules_cc", version = "0.1.1")
+bazel_dep(name = "platforms", version = "0.0.11")
+
+# Test deps.
+bazel_dep(name = "googletest", version = "1.16.0.bcr.1")

README.md

@@ -40,9 +40,10 @@ A simple cross-platform C++ library for terminal based user interfaces!
  * Support for animations. [Demo 1](https://arthursonzogni.github.io/FTXUI/examples/?file=component/menu_underline_animated_gallery), [Demo 2](https://arthursonzogni.github.io/FTXUI/examples/?file=component/button_style)
  * Support for drawing. [Demo](https://arthursonzogni.github.io/FTXUI/examples/?file=component/canvas_animated)
  * No dependencies
+ * Module support
  * **Cross platform**: Linux/MacOS (main target), WebAssembly, Windows (Thanks to contributors!).
  * Learn by [examples](#documentation), and [tutorials](#documentation)
- * Multiple packages: CMake [FetchContent]([https://bewagner.net/programming/2020/05/02/cmake-fetchcontent/](https://cmake.org/cmake/help/latest/module/FetchContent.html)) (preferred), vcpkg, pkgbuild, conan.
+ * Multiple packages: CMake [FetchContent]([https://bewagner.net/programming/2020/05/02/cmake-fetchcontent/](https://cmake.org/cmake/help/latest/module/FetchContent.html)) (preferred),Bazel, vcpkg, pkgbuild, conan.
  * Good practices: documentation, tests, fuzzers, performance tests, automated CI, automated packaging, etc...
 
 ## Documentation
@@ -109,6 +110,7 @@ Element can become flexible using the the `flex` decorator.
 
 An element can be decorated using the functions:
   - `bold`
+  - `italic`
   - `dim`
   - `inverted`
   - `underlined`
@@ -342,6 +344,12 @@ Feel free to add your projects here:
 - [Fallout terminal hacking](https://github.com/gshigin/yet-another-fallout-terminal-hacking-game)
 - [Lazylist](https://github.com/zhuyongqi9/lazylist)
 - [TUISIC](https://github.com/Dark-Kernel/tuisic)
+- [inLimbo](https://github.com/nots1dd/inLimbo)
+- [BestEdrOfTheMarket](https://github.com/Xacone/BestEdrOfTheMarket)
+- [terminal-rain](https://github.com/Oakamoore/terminal-rain)
+- [keywords](https://github.com/Oakamoore/keywords) ([Play web version :heart:](https://oakamoore.itch.io/keywords))
+- [FTB - tertminal file browser](https://github.com/Cyxuan0311/FTB)
+- [openJuice](https://github.com/mikomikotaishi/openJuice)
 
 ### [cpp-best-practices/game_jam](https://github.com/cpp-best-practices/game_jam)
 
@@ -366,7 +374,7 @@ include(FetchContent)
 
 FetchContent_Declare(ftxui
   GIT_REPOSITORY https://github.com/ArthurSonzogni/ftxui
-  GIT_TAG v5.0.0
+  GIT_TAG v6.1.1
 )
 
 FetchContent_GetProperties(ftxui)
@@ -377,19 +385,20 @@ endif()
 ```
 
 If you don't, FTXUI may be used from the following packages:
+- [bazel](...)
 - [vcpkg](https://vcpkgx.com/details.html?package=ftxui)
 - [Arch Linux PKGBUILD](https://aur.archlinux.org/packages/ftxui-git/).
 - [conan.io](https://conan.io/center/ftxui)
 - [openSUSE](https://build.opensuse.org/package/show/devel:libraries:c_c++/ftxui)
 - 
-[![Packaging status](https://repology.org/badge/vertical-allrepos/ftxui.svg)](https://repology.org/project/ftxui/versions)
+[![Packaging status](https://repology.org/badge/vertical-allrepos/libftxui.svg)](https://repology.org/project/libftxui/versions)
 
 If you choose to build and link FTXUI yourself, `ftxui-component` must be first in the linking order relative to the other FTXUI libraries, i.e.
 ```bash
 g++ . . . -lftxui-component -lftxui-dom -lftxui-screen . . .
 ```
 
-
+To build FTXUI with modules, ensure that you are using a generator like Ninja or Visual Studio that supports modules, and pass the flag `FTXUI_BUILD_MODULES`. 
 
 ## Contributors
 

WORKSPACE.bazel

@@ -0,0 +1,4 @@
+# Copyright 2025 Arthur Sonzogni. All rights reserved.
+# Use of this source code is governed by the MIT license that can be found in
+# the LICENSE file.
+workspace(name = "ftxui")

bazel/ftxui.bzl

@@ -0,0 +1,115 @@
+# ftxui_common.bzl
+
+load("@rules_cc//cc:defs.bzl", "cc_library")
+
+def cpp17():
+    return select({
+        "@rules_cc//cc/compiler:msvc-cl": ["/std:c++17"],
+        "@rules_cc//cc/compiler:clang-cl": ["/std:c++17"],
+        "@rules_cc//cc/compiler:clang": ["-std=c++17"],
+        "@rules_cc//cc/compiler:gcc": ["-std=c++17"],
+        "//conditions:default": ["-std=c++17"],
+    })
+
+def cpp20():
+    return select({
+        "@rules_cc//cc/compiler:msvc-cl": ["/std:c++20"],
+        "@rules_cc//cc/compiler:clang-cl": ["/std:c++20"],
+        "@rules_cc//cc/compiler:clang": ["-std=c++20"],
+        "@rules_cc//cc/compiler:gcc": ["-std=c++20"],
+        "//conditions:default": ["-std=c++20"],
+    })
+
+# Microsoft terminal is a bit buggy ¯\_(ツ)_/¯ and MSVC uses bad defaults.
+def windows_copts():
+    MSVC_COPTS = [
+      # Microsoft Visual Studio must decode sources files as UTF-8.
+      "/utf-8",
+
+      # Microsoft Visual Studio must interpret the codepoint using unicode.
+      "/DUNICODE",
+      "/D_UNICODE",
+
+      # Fallback for Microsoft Terminal.
+      # This
+      # - Replace missing font symbols by others.
+      # - Reduce screen position pooling frequency to deals against a Microsoft
+      #   race condition. This was fixed in 2020, but clients never not updated.
+      #   - https://github.com/microsoft/terminal/pull/7583
+      #   - https://github.com/ArthurSonzogni/FTXUI/issues/136
+      "/DFTXUI_MICROSOFT_TERMINAL_FALLBACK",
+    ]
+
+    WINDOWS_COPTS = [
+      # Fallback for Microsoft Terminal.
+      # This
+      # - Replace missing font symbols by others.
+      # - Reduce screen position pooling frequency to deals against a Microsoft
+      #   race condition. This was fixed in 2020, but clients never not updated.
+      #   - https://github.com/microsoft/terminal/pull/7583
+      #   - https://github.com/ArthurSonzogni/FTXUI/issues/136
+      "-DFTXUI_MICROSOFT_TERMINAL_FALLBACK",
+    ];
+    
+    return select({
+        # MSVC:
+        "@rules_cc//cc/compiler:msvc-cl": MSVC_COPTS,
+        "@rules_cc//cc/compiler:clang-cl": MSVC_COPTS,
+        "@platforms//os:windows": WINDOWS_COPTS,
+        "//conditions:default": [],
+    })
+
+def pthread_linkopts():
+    return select({
+        # With MSVC, threading is already built-in (you don't need -pthread.
+        "@rules_cc//cc/compiler:msvc-cl": [],
+        "@rules_cc//cc/compiler:clang-cl": [],
+        "@rules_cc//cc/compiler:clang": ["-pthread"],
+        "@rules_cc//cc/compiler:gcc": ["-pthread"],
+        "//conditions:default": ["-pthread"],
+    })
+
+def ftxui_cc_library(
+        name,
+        srcs,
+        hdrs,
+        linkopts = [],
+        deps = []):
+
+    cc_library(
+        name = name,
+        srcs = srcs,
+        hdrs = hdrs,
+        linkopts = linkopts,
+        deps = deps,
+        strip_include_prefix = "",
+        include_prefix = "",
+        includes = [
+            "include",
+            "src",
+        ],
+        copts = cpp17() + windows_copts(),
+        visibility = ["//visibility:public"],
+    )
+
+# Compile all the examples in the examples/ directory.
+# This is useful to check the Bazel is synchronized with CMake definitions.
+def generate_examples():
+    cpp_files = native.glob(["examples/**/*.cpp"])
+
+    for src in cpp_files:
+        # Skip failing examples due to the color_info_sorted_2d.ipp dependency.
+        if src == "examples/component/homescreen.cpp" or \
+           src == "examples/dom/color_info_palette256.cpp" or \
+           src == "examples/dom/color_gallery.cpp":
+            continue
+
+        # Turn "examples/component/button.cpp" → "example_component_button"
+        name = src.replace("/", "_").replace(".cpp", "")
+
+        native.cc_binary(
+            name = name,
+            srcs = [src],
+            deps = ["//:component"],
+            copts = cpp20() + windows_copts(),
+        )

cmake/ftxui_message.cmake

@@ -5,13 +5,14 @@ function(ftxui_message msg)
 endfunction()
 
 ftxui_message("┌─ FTXUI options ─────────────────────")
-ftxui_message("│ FTXUI_ENABLE_INSTALL     : ${FTXUI_ENABLE_INSTALL}")
-ftxui_message("│ FTXUI_BUILD_EXAMPLES     : ${FTXUI_BUILD_EXAMPLES}")
-ftxui_message("│ FTXUI_QUIET              : ${FTXUI_QUIET}")
 ftxui_message("│ FTXUI_BUILD_DOCS         : ${FTXUI_BUILD_DOCS}")
+ftxui_message("│ FTXUI_BUILD_EXAMPLES     : ${FTXUI_BUILD_EXAMPLES}")
+ftxui_message("│ FTXUI_BUILD_MODULES      : ${FTXUI_BUILD_MODULES}")
 ftxui_message("│ FTXUI_BUILD_TESTS        : ${FTXUI_BUILD_TESTS}")
 ftxui_message("│ FTXUI_BUILD_TESTS_FUZZER : ${FTXUI_BUILD_TESTS_FUZZER}")
-ftxui_message("│ FTXUI_ENABLE_COVERAGE    : ${FTXUI_ENABLE_COVERAGE}")
-ftxui_message("│ FTXUI_DEV_WARNINGS       : ${FTXUI_DEV_WARNINGS}")
 ftxui_message("│ FTXUI_CLANG_TIDY         : ${FTXUI_CLANG_TIDY}")
+ftxui_message("│ FTXUI_DEV_WARNINGS       : ${FTXUI_DEV_WARNINGS}")
+ftxui_message("│ FTXUI_ENABLE_COVERAGE    : ${FTXUI_ENABLE_COVERAGE}")
+ftxui_message("│ FTXUI_ENABLE_INSTALL     : ${FTXUI_ENABLE_INSTALL}")
+ftxui_message("│ FTXUI_QUIET              : ${FTXUI_QUIET}")
 ftxui_message("└─────────────────────────────────────")

cmake/ftxui_modules.cmake

@@ -0,0 +1,81 @@
+if (NOT FTXUI_BUILD_MODULES)
+  return()
+endif()
+
+add_library(ftxui-modules)
+
+target_sources(ftxui-modules
+  PUBLIC FILE_SET CXX_MODULES FILES
+  src/ftxui/component.cppm
+  src/ftxui/component/Animation.cppm
+  src/ftxui/component/CapturedMouse.cppm
+  src/ftxui/component/Component.cppm
+  src/ftxui/component/ComponentBase.cppm
+  src/ftxui/component/ComponentOptions.cppm
+  src/ftxui/component/Event.cppm
+  src/ftxui/component/Loop.cppm
+  src/ftxui/component/Mouse.cppm
+  src/ftxui/component/Receiver.cppm
+  src/ftxui/component/ScreenInteractive.cppm
+  src/ftxui/component/Task.cppm
+  src/ftxui/dom.cppm
+  src/ftxui/dom/Canvas.cppm
+  src/ftxui/dom/Deprecated.cppm
+  src/ftxui/dom/Direction.cppm
+  src/ftxui/dom/Elements.cppm
+  src/ftxui/dom/FlexboxConfig.cppm
+  src/ftxui/dom/LinearGradient.cppm
+  src/ftxui/dom/Node.cppm
+  src/ftxui/dom/Requirement.cppm
+  src/ftxui/dom/Selection.cppm
+  src/ftxui/dom/Table.cppm
+  src/ftxui/screen.cppm
+  src/ftxui/screen/Box.cppm
+  src/ftxui/screen/Color.cppm
+  src/ftxui/screen/ColorInfo.cppm
+  src/ftxui/screen/Deprecated.cppm
+  src/ftxui/screen/Image.cppm
+  src/ftxui/screen/Pixel.cppm
+  src/ftxui/screen/Screen.cppm
+  src/ftxui/screen/String.cppm
+  src/ftxui/screen/Terminal.cppm
+  src/ftxui/util.cppm
+  src/ftxui/util/AutoReset.cppm
+  src/ftxui/util/Ref.cppm
+  )
+
+target_link_libraries(ftxui-modules
+  PUBLIC
+    ftxui::screen
+    ftxui::dom
+    ftxui::component
+)
+
+target_compile_features(ftxui-modules PUBLIC cxx_std_20)
+if (CMAKE_COMPILER_IS_GNUCXX)
+  target_compile_options(${name} PUBLIC -fmodules-ts)
+endif ()
+
+add_library(ftxui::modules ALIAS ftxui-modules)
+
+if(FTXUI_ENABLE_INSTALL)
+
+include(GNUInstallDirs)
+
+install(TARGETS ftxui-modules
+    EXPORT ftxui-targets
+    FILE_SET CXX_MODULES
+      DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/ftxui
+    FILE_SET HEADERS
+      DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/ftxui
+    INCLUDES
+      DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/ftxui
+)
+install(EXPORT ftxui-targets
+    DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/ftxui
+    CXX_MODULES_DIRECTORY ${CMAKE_INSTALL_LIBDIR}/cmake/ftxui
+)
+install(FILES my_package-config.cmake
+    DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/ftxui
+)
+endif()

cmake/ftxui_set_options.cmake

@@ -83,10 +83,6 @@ function(ftxui_set_options library)
       target_compile_options(${library} PRIVATE "-Wpedantic")
       target_compile_options(${library} PRIVATE "-Wshadow")
       target_compile_options(${library} PRIVATE "-Wunused")
-      
-      if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
-        target_compile_options(${library} PRIVATE "-Wuseless-cast")
-      endif()
     endif()
   endif()
 

cmake/ftxui_test.cmake

@@ -13,6 +13,7 @@ add_executable(ftxui-tests
   src/ftxui/component/component_test.cpp
   src/ftxui/component/component_test.cpp
   src/ftxui/component/container_test.cpp
+  src/ftxui/component/dropdown_test.cpp
   src/ftxui/component/hoverable_test.cpp
   src/ftxui/component/input_test.cpp
   src/ftxui/component/menu_test.cpp
@@ -38,8 +39,10 @@ add_executable(ftxui-tests
   src/ftxui/dom/gridbox_test.cpp
   src/ftxui/dom/hbox_test.cpp
   src/ftxui/dom/hyperlink_test.cpp
+  src/ftxui/dom/italic_test.cpp
   src/ftxui/dom/linear_gradient_test.cpp
   src/ftxui/dom/scroll_indicator_test.cpp
+  src/ftxui/dom/selection_test.cpp
   src/ftxui/dom/separator_test.cpp
   src/ftxui/dom/spinner_test.cpp
   src/ftxui/dom/table_test.cpp

doc/mainpage.md

@@ -123,8 +123,8 @@ The project is comprised of 3 modules:
 
 This is the visual element of the program. It defines a `ftxui::Screen`, which
 is a grid of `ftxui::Pixel`. A Pixel represents a Unicode character and its
-associated style (bold, colors, etc.). The screen can be printed as a string
-using `ftxui::Screen::ToString()`. The following example highlights this
+associated style (bold, italic, colors, etc.). The screen can be printed as a
+string using `ftxui::Screen::ToString()`. The following example highlights this
 process:
 
 ```cpp
@@ -476,10 +476,11 @@ See [demo](https://arthursonzogni.github.io/FTXUI/examples/?file=component/linea
 
 ## Style {#dom-style}
 In addition to colored text and colored backgrounds. Many terminals support text
-effects such as: `bold`, `dim`, `underlined`, `inverted`, `blink`.
+effects such as: `bold`, `italic`, `dim`, `underlined`, `inverted`, `blink`.
 
 ```cpp
 Element bold(Element);
+Element italic(Element);
 Element dim(Element);
 Element inverted(Element);
 Element underlined(Element);

examples/component/CMakeLists.txt

@@ -18,6 +18,7 @@ example(focus_cursor)
 example(gallery)
 example(homescreen)
 example(input)
+example(input_in_frame)
 example(input_style)
 example(linear_gradient_gallery)
 example(maybe)
@@ -39,6 +40,7 @@ example(radiobox_in_frame)
 example(renderer)
 example(resizable_split)
 example(scrollbar)
+example(selection)
 example(slider)
 example(slider_direction)
 example(slider_rgb)

examples/component/button.cpp

@@ -18,7 +18,7 @@ using namespace ftxui;
 // We are using `center` to center the text inside the button, then `border` to
 // add a border around the button, and finally `flex` to make the button fill
 // the available space.
-ButtonOption Style() {
+ButtonOption ButtonStyle() {
   auto option = ButtonOption::Animated();
   option.transform = [](const EntryState& s) {
     auto element = text(s.label);
@@ -33,19 +33,20 @@ ButtonOption Style() {
 int main() {
   int value = 50;
 
-  // clang-format off
-  auto btn_dec_01 = Button("-1", [&] { value -= 1; }, Style());
-  auto btn_inc_01 = Button("+1", [&] { value += 1; }, Style());
-  auto btn_dec_10 = Button("-10", [&] { value -= 10; }, Style());
-  auto btn_inc_10 = Button("+10", [&] { value += 10; }, Style());
-  // clang-format on
-
   // The tree of components. This defines how to navigate using the keyboard.
-  // The selected `row` is shared to get a grid layout.
-  int row = 0;
   auto buttons = Container::Vertical({
-      Container::Horizontal({btn_dec_01, btn_inc_01}, &row) | flex,
-      Container::Horizontal({btn_dec_10, btn_inc_10}, &row) | flex,
+      Container::Horizontal({
+          Button(
+              "-1", [&] { value--; }, ButtonStyle()),
+          Button(
+              "+1", [&] { value++; }, ButtonStyle()),
+      }) | flex,
+      Container::Horizontal({
+          Button(
+              "-10", [&] { value -= 10; }, ButtonStyle()),
+          Button(
+              "+10", [&] { value += 10; }, ButtonStyle()),
+      }) | flex,
   });
 
   // Modify the way to render them on screen:
@@ -58,7 +59,7 @@ int main() {
            flex | border;
   });
 
-  auto screen = ScreenInteractive::FitComponent();
+  auto screen = ScreenInteractive::Fullscreen();
   screen.Loop(component);
   return 0;
 }

examples/component/checkbox.cpp

@@ -1,30 +1,38 @@
 // Copyright 2021 Arthur Sonzogni. All rights reserved.
 // Use of this source code is governed by the MIT license that can be found in
 // the LICENSE file.
-#include <memory>  // for allocator, __shared_ptr_access
-#include <string>  // for string, basic_string, operator+, to_string
-#include <vector>  // for vector
+#include <array>  // for array
+#include <iostream>
+#include <memory>  // for shared_ptr, __shared_ptr_access
+#include <string>  // for operator+, to_string
 
 #include "ftxui/component/captured_mouse.hpp"  // for ftxui
-#include "ftxui/component/component.hpp"       // for Input, Renderer, Vertical
-#include "ftxui/component/component_base.hpp"  // for ComponentBase
-#include "ftxui/component/screen_interactive.hpp"  // for Component, ScreenInteractive
+#include "ftxui/component/component.hpp"  // for Checkbox, Renderer, Vertical
+#include "ftxui/component/component_base.hpp"      // for ComponentBase
+#include "ftxui/component/screen_interactive.hpp"  // for ScreenInteractive
 #include "ftxui/dom/elements.hpp"  // for operator|, Element, size, border, frame, vscroll_indicator, HEIGHT, LESS_THAN
 
+using namespace ftxui;
+
 int main() {
-  using namespace ftxui;
+  bool download = false;
+  bool upload = false;
+  bool ping = false;
 
-  Component input_list = Container::Vertical({});
-  std::vector<std::string> items(100, "");
-  for (size_t i = 0; i < items.size(); ++i) {
-    input_list->Add(Input(&(items[i]), "placeholder " + std::to_string(i)));
-  }
-
-  auto renderer = Renderer(input_list, [&] {
-    return input_list->Render() | vscroll_indicator | frame | border |
-           size(HEIGHT, LESS_THAN, 10);
+  auto container = Container::Vertical({
+      Checkbox("Download", &download),
+      Checkbox("Upload", &upload),
+      Checkbox("Ping", &ping),
   });
 
-  auto screen = ScreenInteractive::TerminalOutput();
-  screen.Loop(renderer);
+  auto screen = ScreenInteractive::FitComponent();
+  screen.Loop(container);
+
+  std::cout << "---" << std::endl;
+  std::cout << "Download: " << download << std::endl;
+  std::cout << "Upload: " << upload << std::endl;
+  std::cout << "Ping: " << ping << std::endl;
+  std::cout << "---" << std::endl;
+
+  return 0;
 }

examples/component/gallery.cpp

@@ -97,7 +97,25 @@ int main() {
   });
   sliders = Wrap("Slider", sliders);
 
-  // -- Layout -----------------------------------------------------------------
+  // A large text:
+  auto lorel_ipsum = Renderer([] {
+    return vbox({
+        text("Lorem ipsum dolor sit amet, consectetur adipiscing elit. "),
+        text("Sed do eiusmod tempor incididunt ut labore et dolore magna "
+             "aliqua. "),
+        text("Ut enim ad minim veniam, quis nostrud exercitation ullamco "
+             "laboris nisi ut aliquip ex ea commodo consequat. "),
+        text("Duis aute irure dolor in reprehenderit in voluptate velit esse "
+             "cillum dolore eu fugiat nulla pariatur. "),
+        text("Excepteur sint occaecat cupidatat non proident, sunt in culpa "
+             "qui officia deserunt mollit anim id est laborum. "),
+
+    });
+  });
+  lorel_ipsum = Wrap("Lorel Ipsum", lorel_ipsum);
+
+  // -- Layout
+  // -----------------------------------------------------------------
   auto layout = Container::Vertical({
       menu,
       toggle,
@@ -106,6 +124,7 @@ int main() {
       input,
       sliders,
       button,
+      lorel_ipsum,
   });
 
   auto component = Renderer(layout, [&] {
@@ -123,6 +142,8 @@ int main() {
                sliders->Render(),
                separator(),
                button->Render(),
+               separator(),
+               lorel_ipsum->Render(),
            }) |
            xflex | size(WIDTH, GREATER_THAN, 40) | border;
   });

examples/component/homescreen.cpp

@@ -424,7 +424,7 @@ int main() {
   auto paragraph_renderer_left = Renderer([&] {
     std::string str =
         "Lorem Ipsum is simply dummy text of the printing and typesetting "
-        "industry. Lorem Ipsum has been the industry's standard dummy text "
+        "industry.\nLorem Ipsum has been the industry's standard dummy text "
         "ever since the 1500s, when an unknown printer took a galley of type "
         "and scrambled it to make a type specimen book.";
     return vbox({

examples/component/input_in_frame.cpp

@@ -0,0 +1,30 @@
+// Copyright 2021 Arthur Sonzogni. All rights reserved.
+// Use of this source code is governed by the MIT license that can be found in
+// the LICENSE file.
+#include <memory>  // for allocator, __shared_ptr_access
+#include <string>  // for string, basic_string, operator+, to_string
+#include <vector>  // for vector
+
+#include "ftxui/component/captured_mouse.hpp"  // for ftxui
+#include "ftxui/component/component.hpp"       // for Input, Renderer, Vertical
+#include "ftxui/component/component_base.hpp"  // for ComponentBase
+#include "ftxui/component/screen_interactive.hpp"  // for Component, ScreenInteractive
+#include "ftxui/dom/elements.hpp"  // for operator|, Element, size, border, frame, vscroll_indicator, HEIGHT, LESS_THAN
+
+int main() {
+  using namespace ftxui;
+
+  Component input_list = Container::Vertical({});
+  std::vector<std::string> items(100, "");
+  for (size_t i = 0; i < items.size(); ++i) {
+    input_list->Add(Input(&(items[i]), "placeholder " + std::to_string(i)));
+  }
+
+  auto renderer = Renderer(input_list, [&] {
+    return input_list->Render() | vscroll_indicator | frame | border |
+           size(HEIGHT, LESS_THAN, 10);
+  });
+
+  auto screen = ScreenInteractive::TerminalOutput();
+  screen.Loop(renderer);
+}

examples/component/selection.cpp

@@ -0,0 +1,87 @@
+// Copyright 2020 Arthur Sonzogni. All rights reserved.
+// Use of this source code is governed by the MIT license that can be found in
+// the LICENSE file.
+#include <string>  // for char_traits, operator+, string, basic_string
+
+#include "ftxui/component/component.hpp"       // for Input, Renderer, Vertical
+#include "ftxui/component/component_base.hpp"  // for ComponentBase
+#include "ftxui/component/component_options.hpp"  // for InputOption
+#include "ftxui/component/screen_interactive.hpp"  // for Component, ScreenInteractive
+#include "ftxui/dom/elements.hpp"  // for text, hbox, separator, Element, operator|, vbox, border
+#include "ftxui/util/ref.hpp"  // for Ref
+
+using namespace ftxui;
+
+Element LoremIpsum() {
+  return vbox({
+      text("FTXUI: A powerful library for building user interfaces."),
+      text("Enjoy a rich set of components and a declarative style."),
+      text("Create beautiful and responsive UIs with minimal effort."),
+      text("Join the community and experience the power of FTXUI."),
+  });
+}
+
+int main() {
+  auto screen = ScreenInteractive::TerminalOutput();
+
+  auto quit =
+      Button("Quit", screen.ExitLoopClosure(), ButtonOption::Animated());
+
+  int selection_change_counter = 0;
+  std::string selection_content = "";
+  screen.SelectionChange([&] {
+    selection_change_counter++;
+    selection_content = screen.GetSelection();
+  });
+
+  // The components:
+  auto renderer = Renderer(quit, [&] {
+    return vbox({
+        text("Select changed: " + std::to_string(selection_change_counter) +
+             " times"),
+        text("Currently selected: "),
+        paragraph(selection_content) | vscroll_indicator | frame | border |
+            size(HEIGHT, EQUAL, 10),
+        window(text("Horizontal split"), hbox({
+                                             LoremIpsum(),
+                                             separator(),
+                                             LoremIpsum(),
+                                             separator(),
+                                             LoremIpsum(),
+                                         })),
+        window(text("Vertical split"), vbox({
+                                           LoremIpsum(),
+                                           separator(),
+                                           LoremIpsum(),
+                                           separator(),
+                                           LoremIpsum(),
+                                       })),
+        window(text("Grid split with different style"),
+               vbox({
+                   hbox({
+                       LoremIpsum(),
+                       separator(),
+                       LoremIpsum()                                   //
+                           | selectionBackgroundColor(Color::Yellow)  //
+                           | selectionColor(Color::Black)             //
+                           | selectionStyleReset,
+                       separator(),
+                       LoremIpsum() | selectionColor(Color::Blue),
+                   }),
+                   separator(),
+                   hbox({
+                       LoremIpsum() | selectionColor(Color::Red),
+                       separator(),
+                       LoremIpsum() | selectionStyle([](Pixel& pixel) {
+                         pixel.underlined_double = true;
+                       }),
+                       separator(),
+                       LoremIpsum(),
+                   }),
+               })),
+        quit->Render(),
+    });
+  });
+
+  screen.Loop(renderer);
+}

examples/component/slider_direction.cpp

@@ -19,7 +19,7 @@ using namespace ftxui;
 int main() {
   auto screen = ScreenInteractive::TerminalOutput();
   std::array<int, 30> values;
-  for (int i = 0; i < values.size(); ++i) {
+  for (size_t i = 0; i < values.size(); ++i) {
     values[i] = 50 + 20 * std::sin(i * 0.3);
   }
 

examples/dom/CMakeLists.txt

@@ -29,6 +29,7 @@ example(style_dim)
 example(style_gallery)
 example(style_hyperlink)
 example(style_inverted)
+example(style_italic)
 example(style_strikethrough)
 example(style_underlined)
 example(style_underlined_double)

examples/dom/color_truecolor_RGB.cpp

@@ -12,7 +12,6 @@
 int main() {
   using namespace ftxui;
 
-  int saturation = 255;
   Elements red_line;
   Elements green_line;
   Elements blue_line;

examples/dom/graph.cpp

@@ -10,6 +10,7 @@
 #include <memory>                   // for shared_ptr
 #include <string>                   // for operator<<, string
 #include <thread>                   // for sleep_for
+#include <utility>                  // for ignore
 #include <vector>                   // for vector
 
 #include "ftxui/dom/node.hpp"  // for Render
@@ -49,6 +50,7 @@ int main() {
 
   std::string reset_position;
   for (int i = 0;; ++i) {
+    std::ignore = i;
     auto document = hbox({
         vbox({
             graph(std::ref(my_graph)),

examples/dom/style_gallery.cpp

@@ -15,6 +15,7 @@ int main() {
     hbox({
       text("normal")                                    , text(" ") ,
       text("bold")               | bold                 , text(" ") ,
+      text("italic")             | italic               , text(" ") ,
       text("dim")                | dim                  , text(" ") ,
       text("inverted")           | inverted             , text(" ") ,
       text("underlined")         | underlined           , text(" ") ,

examples/dom/style_italic.cpp

@@ -0,0 +1,23 @@
+// Copyright 2025 Arthur Sonzogni. All rights reserved.
+// Use of this source code is governed by the MIT license that can be found in
+// the LICENSE file.
+#include <ftxui/dom/elements.hpp>  // for text, operator|, inverted, Fit, hbox, Element
+#include <ftxui/screen/screen.hpp>  // for Full, Screen
+#include <memory>                   // for allocator
+
+#include "ftxui/dom/node.hpp"      // for Render
+#include "ftxui/screen/color.hpp"  // for ftxui
+
+int main() {
+  using namespace ftxui;
+  auto document = hbox({
+      text("This text is "),
+      text("italic") | italic,
+      text(". Do you like it?"),
+  });
+  auto screen = Screen::Create(Dimension::Full(), Dimension::Fit(document));
+  Render(screen, document);
+  screen.Print();
+
+  return 0;
+}

include/ftxui/component/component_base.hpp

@@ -50,7 +50,10 @@ class ComponentBase {
   void DetachAllChildren();
 
   // Renders the component.
-  virtual Element Render();
+  Element Render();
+
+  // Override this function modify how `Render` works.
+  virtual Element OnRender();
 
   // Handles an event.
   // By default, reduce on children with a lazy OR.
@@ -94,6 +97,7 @@ class ComponentBase {
 
  private:
   ComponentBase* parent_ = nullptr;
+  bool in_render = false;
 };
 
 }  // namespace ftxui

include/ftxui/component/screen_interactive.hpp

@@ -16,6 +16,7 @@
 #include "ftxui/component/captured_mouse.hpp"  // for CapturedMouse
 #include "ftxui/component/event.hpp"           // for Event
 #include "ftxui/component/task.hpp"            // for Task, Closure
+#include "ftxui/dom/selection.hpp"             // for SelectionOption
 #include "ftxui/screen/screen.hpp"             // for Screen
 
 namespace ftxui {
@@ -68,6 +69,10 @@ class ScreenInteractive : public Screen {
   void ForceHandleCtrlC(bool force);
   void ForceHandleCtrlZ(bool force);
 
+  // Selection API.
+  std::string GetSelection();
+  void SelectionChange(std::function<void()> callback);
+
  private:
   void ExitNow();
 
@@ -82,6 +87,8 @@ class ScreenInteractive : public Screen {
   void RunOnceBlocking(Component component);
 
   void HandleTask(Component component, Task& task);
+  bool HandleSelection(bool handled, Event event);
+  void RefreshSelection();
   void Draw(Component component);
   void ResetCursorPosition();
 
@@ -129,6 +136,22 @@ class ScreenInteractive : public Screen {
   // The style of the cursor to restore on exit.
   int cursor_reset_shape_ = 1;
 
+  // Selection API:
+  CapturedMouse selection_pending_;
+  struct SelectionData {
+    int start_x = -1;
+    int start_y = -1;
+    int end_x = -2;
+    int end_y = -2;
+    bool empty = true;
+    bool operator==(const SelectionData& other) const;
+    bool operator!=(const SelectionData& other) const;
+  };
+  SelectionData selection_data_;
+  SelectionData selection_data_previous_;
+  std::unique_ptr<Selection> selection_;
+  std::function<void()> selection_on_change_;
+
   friend class Loop;
 
  public:

include/ftxui/dom/elements.hpp

@@ -95,6 +95,7 @@ Element canvas(std::function<void(Canvas&)>);
 // -- Decorator ---
 Element bold(Element);
 Element dim(Element);
+Element italic(Element);
 Element inverted(Element);
 Element underlined(Element);
 Element underlinedDouble(Element);
@@ -113,6 +114,11 @@ Decorator focusPositionRelative(float x, float y);
 Element automerge(Element child);
 Decorator hyperlink(std::string link);
 Element hyperlink(std::string link, Element child);
+Element selectionStyleReset(Element);
+Decorator selectionColor(Color foreground);
+Decorator selectionBackgroundColor(Color foreground);
+Decorator selectionForegroundColor(Color foreground);
+Decorator selectionStyle(std::function<void(Pixel&)> style);
 
 // --- Layout is
 // Horizontal, Vertical or stacked set of elements.
@@ -156,7 +162,7 @@ Element frame(Element);
 Element xframe(Element);
 Element yframe(Element);
 Element focus(Element);
-Element select(Element);
+Element select(Element e);  // Deprecated - Alias for focus.
 
 // --- Cursor ---
 // Those are similar to `focus`, but also change the shape of the cursor.

include/ftxui/dom/node.hpp

@@ -8,6 +8,7 @@
 #include <vector>  // for vector
 
 #include "ftxui/dom/requirement.hpp"  // for Requirement
+#include "ftxui/dom/selection.hpp"    // for Selection
 #include "ftxui/screen/box.hpp"       // for Box
 #include "ftxui/screen/screen.hpp"
 
@@ -40,9 +41,15 @@ class Node {
   //         Propagated from Parents to Children.
   virtual void SetBox(Box box);
 
-  // Step 3: Draw this element.
+  // Step 3: (optional) Selection
+  //         Propagated from Parents to Children.
+  virtual void Select(Selection& selection);
+
+  // Step 4: Draw this element.
   virtual void Render(Screen& screen);
 
+  virtual std::string GetSelectedContent(Selection& selection);
+
   // Layout may not resolve within a single iteration for some elements. This
   // allows them to request additionnal iterations. This signal must be
   // forwarded to children at least once.
@@ -52,6 +59,8 @@ class Node {
   };
   virtual void Check(Status* status);
 
+  friend void Render(Screen& screen, Node* node, Selection& selection);
+
  protected:
   Elements children_;
   Requirement requirement_;
@@ -60,6 +69,10 @@ class Node {
 
 void Render(Screen& screen, const Element& element);
 void Render(Screen& screen, Node* node);
+void Render(Screen& screen, Node* node, Selection& selection);
+std::string GetNodeSelectedContent(Screen& screen,
+                                   Node* node,
+                                   Selection& selection);
 
 }  // namespace ftxui
 

include/ftxui/dom/requirement.hpp

@@ -5,8 +5,10 @@
 #define FTXUI_DOM_REQUIREMENT_HPP
 
 #include "ftxui/screen/box.hpp"
+#include "ftxui/screen/screen.hpp"
 
 namespace ftxui {
+class Node;
 
 struct Requirement {
   // The required size to fully draw the element.
@@ -20,13 +22,28 @@ struct Requirement {
   int flex_shrink_y = 0;
 
   // Focus management to support the frame/focus/select element.
-  enum Selection {
-    NORMAL = 0,
-    SELECTED = 1,
-    FOCUSED = 2,
+  struct Focused {
+    bool enabled = false;
+    Box box;
+    Node* node = nullptr;
+    Screen::Cursor::Shape cursor_shape = Screen::Cursor::Shape::Hidden;
+
+    // Internal for interactions with components.
+    bool component_active = false;
+
+    // Return whether this requirement should be preferred over the other.
+    bool Prefer(const Focused& other) const {
+      if (!other.enabled) {
+        return false;
+      }
+      if (!enabled) {
+        return true;
+      }
+
+      return other.component_active && !component_active;
+    }
   };
-  Selection selection = NORMAL;
-  Box selected_box;
+  Focused focused;
 };
 
 }  // namespace ftxui

include/ftxui/dom/selection.hpp

@@ -0,0 +1,50 @@
+// Copyright 2024 Arthur Sonzogni. All rights reserved.
+// Use of this source code is governed by the MIT license that can be found in
+// the LICENSE file.
+
+#ifndef FTXUI_DOM_SELECTION_HPP
+#define FTXUI_DOM_SELECTION_HPP
+
+#include <functional>
+
+#include <sstream>
+#include "ftxui/screen/box.hpp"    // for Box
+#include "ftxui/screen/pixel.hpp"  // for Pixel
+
+namespace ftxui {
+
+/// @brief Represent a selection in the terminal.
+class Selection {
+ public:
+  Selection();  // Empty selection.
+  Selection(int start_x, int start_y, int end_x, int end_y);
+
+  const Box& GetBox() const;
+
+  Selection SaturateHorizontal(Box box);
+  Selection SaturateVertical(Box box);
+  bool IsEmpty() const { return empty_; }
+
+  void AddPart(const std::string& part, int y, int left, int right);
+  std::string GetParts() { return parts_.str(); }
+
+ private:
+  Selection(int start_x, int start_y, int end_x, int end_y, Selection* parent);
+
+  const int start_x_ = 0;
+  const int start_y_ = 0;
+  const int end_x_ = 0;
+  const int end_y_ = 0;
+  const Box box_ = {};
+  Selection* const parent_ = this;
+  const bool empty_ = true;
+  std::stringstream parts_;
+
+  // The position of the last inserted part.
+  int x_ = 0;
+  int y_ = 0;
+};
+
+}  // namespace ftxui
+
+#endif /* end of include guard: FTXUI_DOM_SELECTION_HPP */

include/ftxui/screen/box.hpp

@@ -14,6 +14,7 @@ struct Box {
 
   static auto Intersection(Box a, Box b) -> Box;
   static auto Union(Box a, Box b) -> Box;
+  void Shift(int x, int y);
   bool Contain(int x, int y) const;
   bool IsEmpty() const;
   bool operator==(const Box& other) const;

include/ftxui/screen/pixel.hpp

@@ -17,6 +17,7 @@ struct Pixel {
       : blink(false),
         bold(false),
         dim(false),
+        italic(false),
         inverted(false),
         underlined(false),
         underlined_double(false),
@@ -27,6 +28,7 @@ struct Pixel {
   bool blink : 1;
   bool bold : 1;
   bool dim : 1;
+  bool italic : 1;
   bool inverted : 1;
   bool underlined : 1;
   bool underlined_double : 1;

include/ftxui/screen/screen.hpp

@@ -4,12 +4,14 @@
 #ifndef FTXUI_SCREEN_SCREEN_HPP
 #define FTXUI_SCREEN_SCREEN_HPP
 
-#include <cstdint>  // for uint8_t
-#include <string>   // for string, basic_string, allocator
-#include <vector>   // for vector
+#include <cstdint>     // for uint8_t
+#include <functional>  // for function
+#include <string>      // for string, basic_string, allocator
+#include <vector>      // for vector
 
 #include "ftxui/screen/image.hpp"     // for Pixel, Image
 #include "ftxui/screen/terminal.hpp"  // for Dimensions
+#include "ftxui/util/autoreset.hpp"   // for AutoReset
 
 namespace ftxui {
 
@@ -67,9 +69,18 @@ class Screen : public Image {
   uint8_t RegisterHyperlink(const std::string& link);
   const std::string& Hyperlink(uint8_t id) const;
 
+  using SelectionStyle = std::function<void(Pixel&)>;
+  const SelectionStyle& GetSelectionStyle() const;
+  void SetSelectionStyle(SelectionStyle decorator);
+
  protected:
   Cursor cursor_;
   std::vector<std::string> hyperlinks_ = {""};
+
+  // The current selection style. This is overridden by various dom elements.
+  SelectionStyle selection_style_ = [](Pixel& pixel) {
+    pixel.inverted ^= true;
+  };
 };
 
 }  // namespace ftxui

src/ftxui/component.cppm

@@ -0,0 +1,18 @@
+/**
+ * @file component.cppm
+ * @brief Module file for FTXUI component operations.
+ */
+
+export module ftxui.component;
+
+export import ftxui.component.Animation;
+export import ftxui.component.CapturedMouse;
+export import ftxui.component.Component;
+export import ftxui.component.ComponentBase;
+export import ftxui.component.ComponentOptions;
+export import ftxui.component.Event;
+export import ftxui.component.Loop;
+export import ftxui.component.Mouse;
+export import ftxui.component.Receiver;
+export import ftxui.component.ScreenInteractive;
+export import ftxui.component.Task;

src/ftxui/component/Animation.cppm

@@ -0,0 +1,66 @@
+/**
+ * @file Animation.cppm
+ * @brief Module file for the Animation namespace of the Component module
+ */
+
+module;
+
+#include <ftxui/component/animation.hpp>
+
+export module ftxui.component.Animation;
+
+/**
+ * @namespace ftxui::animation
+ * @brief The FTXUI ftxui::animation:: namespace
+ */
+export namespace ftxui::animation {
+    using ftxui::animation::RequestAnimationFrame;
+
+    using ftxui::animation::Clock;
+    using ftxui::animation::TimePoint;
+    using ftxui::animation::Duration;
+
+    using ftxui::animation::Params;
+
+    /**
+     * @namespace easing
+     * @brief The FTXUI sf::animation::easing:: namespace
+     */
+    namespace easing {
+        using ftxui::animation::easing::Function;
+
+        using ftxui::animation::easing::Linear;
+        using ftxui::animation::easing::QuadraticIn;
+        using ftxui::animation::easing::QuadraticOut;
+        using ftxui::animation::easing::QuadraticInOut;
+        using ftxui::animation::easing::CubicIn;
+        using ftxui::animation::easing::CubicOut;
+        using ftxui::animation::easing::CubicInOut;
+        using ftxui::animation::easing::QuarticIn;
+        using ftxui::animation::easing::QuarticOut;
+        using ftxui::animation::easing::QuarticInOut;
+        using ftxui::animation::easing::QuinticIn;
+        using ftxui::animation::easing::QuinticOut;
+        using ftxui::animation::easing::QuinticInOut;
+        using ftxui::animation::easing::SineIn;
+        using ftxui::animation::easing::SineOut;
+        using ftxui::animation::easing::SineInOut;
+        using ftxui::animation::easing::CircularIn;
+        using ftxui::animation::easing::CircularOut;
+        using ftxui::animation::easing::CircularInOut;
+        using ftxui::animation::easing::ExponentialIn;
+        using ftxui::animation::easing::ExponentialOut;
+        using ftxui::animation::easing::ExponentialInOut;
+        using ftxui::animation::easing::ElasticIn;
+        using ftxui::animation::easing::ElasticOut;
+        using ftxui::animation::easing::ElasticInOut;
+        using ftxui::animation::easing::BackIn;
+        using ftxui::animation::easing::BackOut;
+        using ftxui::animation::easing::BackInOut;
+        using ftxui::animation::easing::BounceIn;
+        using ftxui::animation::easing::BounceOut;
+        using ftxui::animation::easing::BounceInOut;
+    }
+
+    using ftxui::animation::Animator;
+}

src/ftxui/component/CapturedMouse.cppm

@@ -0,0 +1,18 @@
+/**
+ * @file CapturedMouse.cppm
+ * @brief Module file for the CapturedMouseInterface class of the Component module
+ */
+
+module;
+
+#include <ftxui/component/captured_mouse.hpp>
+
+export module ftxui.component.CapturedMouse;
+
+/**
+ * @namespace ftxui
+ * @brief The FTXUI ftxui:: namespace
+ */
+export namespace ftxui {
+    using ftxui::CapturedMouseInterface;
+}

src/ftxui/component/Component.cppm

@@ -0,0 +1,61 @@
+/**
+ * @file Component.cppm
+ * @brief Module file for the Component classes of the Component module
+ */
+
+module;
+
+#include <ftxui/component/component.hpp>
+
+export module ftxui.component.Component;
+
+/**
+ * @namespace ftxui
+ * @brief The FTXUI ftxui:: namespace
+ */
+export namespace ftxui {
+    using ftxui::ButtonOption;
+    using ftxui::CheckboxOption;
+    using ftxui::Event;
+    using ftxui::InputOption;
+    using ftxui::MenuOption;
+    using ftxui::RadioboxOption;
+    using ftxui::MenuEntryOption;
+
+    using ftxui::Make;
+
+    using ftxui::ComponentDecorator;
+    using ftxui::ElementDecorator;
+
+    using ftxui::operator|;
+    using ftxui::operator|=;
+
+    namespace Container {
+        using ftxui::Container::Vertical;
+        using ftxui::Container::Horizontal;
+        using ftxui::Container::Tab;
+        using ftxui::Container::Stacked;
+    }
+    
+    using ftxui::Button;
+    using ftxui::Checkbox;
+    using ftxui::Input;
+    using ftxui::Menu;
+    using ftxui::MenuEntry;
+    using ftxui::Radiobox;
+    using ftxui::Dropdown;
+    using ftxui::Toggle;
+    using ftxui::Slider;
+    using ftxui::ResizableSplit;
+    using ftxui::ResizableSplitLeft;
+    using ftxui::ResizableSplitRight;
+    using ftxui::ResizableSplitTop;
+    using ftxui::ResizableSplitBottom;
+    using ftxui::Renderer;
+    using ftxui::CatchEvent;
+    using ftxui::Maybe;
+    using ftxui::Modal;
+    using ftxui::Collapsible;
+    using ftxui::Hoverable;
+    using ftxui::Window;
+}

src/ftxui/component/ComponentBase.cppm

@@ -0,0 +1,28 @@
+/**
+ * @file ComponentBase.cppm
+ * @brief Module file for the ComponentBase class of the Component module
+ */
+
+module;
+
+#include <ftxui/component/component_base.hpp>
+
+export module ftxui.component.ComponentBase;
+
+/**
+ * @namespace ftxui
+ * @brief The FTXUI ftxui:: namespace
+ */
+export namespace ftxui {
+    using ftxui::Delegate;
+    using ftxui::Focus;
+    using ftxui::Event;
+
+    namespace animation {
+        using ftxui::animation::Params;
+    }
+
+    using ftxui::ComponentBase;
+    using ftxui::Component;
+    using ftxui::Components;
+}

src/ftxui/component/ComponentOptions.cppm

@@ -0,0 +1,33 @@
+/**
+ * @file ComponentOptions.cppm
+ * @brief Module file for options for the Component class of the Component module
+ */
+
+module;
+
+#include <ftxui/component/component_options.hpp>
+
+export module ftxui.component.ComponentOptions;
+
+/**
+ * @namespace ftxui
+ * @brief The FTXUI ftxui:: namespace
+ */
+export namespace ftxui {
+    using ftxui::EntryState;
+    using ftxui::UnderlineOption;
+    using ftxui::AnimatedColorOption;
+    using ftxui::AnimatedColorsOption;
+    using ftxui::MenuEntryOption;
+    using ftxui::MenuOption;
+    using ftxui::ButtonOption;
+    using ftxui::CheckboxOption;
+    using ftxui::InputState;
+    using ftxui::InputOption;
+    using ftxui::RadioboxOption;
+    using ftxui::ResizableSplitOption;
+    using ftxui::SliderOption;
+    using ftxui::WindowRenderState;
+    using ftxui::WindowOptions;
+    using ftxui::DropdownOption;
+}

src/ftxui/component/Event.cppm

@@ -0,0 +1,21 @@
+/**
+ * @file Event.cppm
+ * @brief Module file for the Event struct of the Component module
+ */
+
+module;
+
+#include <ftxui/component/event.hpp>
+
+export module ftxui.component.Event;
+
+/**
+ * @namespace ftxui
+ * @brief The FTXUI ftxui:: namespace
+ */
+export namespace ftxui {
+    using ftxui::ScreenInteractive;
+    using ftxui::ComponentBase;
+
+    using ftxui::Event;
+}

src/ftxui/component/Loop.cppm

@@ -0,0 +1,22 @@
+/**
+ * @file Loop.cppm
+ * @brief Module file for the Loop class of the Component module
+ */
+
+module;
+
+#include <ftxui/component/loop.hpp>
+
+export module ftxui.component.Loop;
+
+/**
+ * @namespace ftxui
+ * @brief The FTXUI ftxui:: namespace
+ */
+export namespace ftxui {
+    using ftxui::ComponentBase;
+    using ftxui::Component;
+    using ftxui::ScreenInteractive;
+
+    using ftxui::Loop;
+}

src/ftxui/component/Mouse.cppm

@@ -0,0 +1,18 @@
+/**
+ * @file Mouse.cppm
+ * @brief Module file for the Mouse struct of the Component module
+ */
+
+module;
+
+#include <ftxui/component/mouse.hpp>
+
+export module ftxui.component.Mouse;
+
+/**
+ * @namespace ftxui
+ * @brief The FTXUI ftxui:: namespace
+ */
+export namespace ftxui {
+    using ftxui::Mouse;
+}

src/ftxui/component/Receiver.cppm

@@ -0,0 +1,22 @@
+/**
+ * @file Receiver.cppm
+ * @brief Module file for the Receiver class of the Component module
+ */
+
+module;
+
+#include <ftxui/component/receiver.hpp>
+
+export module ftxui.component.Receiver;
+
+/**
+ * @namespace ftxui
+ * @brief The FTXUI ftxui:: namespace
+ */
+export namespace ftxui {
+    using ftxui::SenderImpl;
+    using ftxui::ReceiverImpl;
+    using ftxui::Sender;
+    using ftxui::Receiver;
+    using ftxui::MakeReceiver;
+}

src/ftxui/component/ScreenInteractive.cppm

@@ -0,0 +1,25 @@
+/**
+ * @file ScreenInteractive.cppm
+ * @brief Module file for the ScreenInteractive class of the Component module
+ */
+
+module;
+
+#include <ftxui/component/screen_interactive.hpp>
+
+export module ftxui.component.ScreenInteractive;
+
+/**
+ * @namespace ftxui
+ * @brief The FTXUI ftxui:: namespace
+ */
+export namespace ftxui {
+    using ftxui::ComponentBase;
+    using ftxui::Loop;
+    using ftxui::Event;
+    using ftxui::Component;
+
+    using ftxui::Screen;
+    using ftxui::ScreenInteractivePrivate;
+    using ftxui::ScreenInteractive;
+}

src/ftxui/component/Task.cppm

@@ -0,0 +1,20 @@
+/**
+ * @file Task.cppm
+ * @brief Module file for the Task class of the Component module
+ */
+
+module;
+
+#include <ftxui/component/task.hpp>
+
+export module ftxui.component.Task;
+
+/**
+ * @namespace ftxui
+ * @brief The FTXUI ftxui:: namespace
+ */
+export namespace ftxui {
+    using ftxui::AnimationTask;
+    using ftxui::Closure;
+    using ftxui::Task;
+}

src/ftxui/component/button.cpp

@@ -37,7 +37,7 @@ class ButtonBase : public ComponentBase, public ButtonOption {
   explicit ButtonBase(ButtonOption option) : ButtonOption(std::move(option)) {}
 
   // Component implementation:
-  Element Render() override {
+  Element OnRender() override {
     const bool active = Active();
     const bool focused = Focused();
     const bool focused_or_hover = focused || mouse_hover_;
@@ -47,14 +47,16 @@ class ButtonBase : public ComponentBase, public ButtonOption {
       SetAnimationTarget(target);
     }
 
-    auto focus_management = focused ? focus : active ? select : nothing;
     const EntryState state{
         *label, false, active, focused_or_hover, Index(),
     };
 
     auto element = (transform ? transform : DefaultTransform)  //
         (state);
-    return element | AnimatedColorStyle() | focus_management | reflect(box_);
+    element |= AnimatedColorStyle();
+    element |= focus;
+    element |= reflect(box_);
+    return element;
   }
 
   Decorator AnimatedColorStyle() {

src/ftxui/component/checkbox.cpp

@@ -23,16 +23,17 @@ class CheckboxBase : public ComponentBase, public CheckboxOption {
 
  private:
   // Component implementation.
-  Element Render() override {
+  Element OnRender() override {
     const bool is_focused = Focused();
     const bool is_active = Active();
-    auto focus_management = is_focused ? focus : is_active ? select : nothing;
     auto entry_state = EntryState{
         *label, *checked, is_active, is_focused || hovered_, -1,
     };
     auto element = (transform ? transform : CheckboxOption::Simple().transform)(
         entry_state);
-    return element | focus_management | reflect(box_);
+    element |= focus;
+    element |= reflect(box_);
+    return element;
   }
 
   bool OnEvent(Event event) override {
@@ -69,7 +70,6 @@ class CheckboxBase : public ComponentBase, public CheckboxOption {
         event.mouse().motion == Mouse::Pressed) {
       *checked = !*checked;
       on_change();
-      TakeFocus();
       return true;
     }
 

src/ftxui/component/component.cpp

@@ -15,6 +15,8 @@
 #include "ftxui/component/event.hpp"           // for Event
 #include "ftxui/component/screen_interactive.hpp"  // for Component, ScreenInteractive
 #include "ftxui/dom/elements.hpp"                  // for text, Element
+#include "ftxui/dom/node.hpp"                      // for Node, Elements
+#include "ftxui/screen/box.hpp"                    // for Box
 
 namespace ftxui::animation {
 class Params;
@@ -103,10 +105,46 @@ void ComponentBase::DetachAllChildren() {
 }
 
 /// @brief Draw the component.
-/// Build a ftxui::Element to be drawn on the ftxi::Screen representing this
-/// ftxui::ComponentBase.
+/// Build a ftxui::Element to be drawn on the ftxui::Screen representing this
+/// ftxui::ComponentBase. Please override OnRender() to modify the rendering.
 /// @ingroup component
 Element ComponentBase::Render() {
+  // Some users might call `ComponentBase::Render()` from
+  // `T::OnRender()`. To avoid infinite recursion, we use a flag.
+  if (in_render) {
+    return ComponentBase::OnRender();
+  }
+
+  in_render = true;
+  Element element = OnRender();
+  in_render = false;
+
+  class Wrapper : public Node {
+   public:
+    bool active_ = false;
+
+    Wrapper(Element child, bool active)
+        : Node({std::move(child)}), active_(active) {}
+
+    void SetBox(Box box) override {
+      Node::SetBox(box);
+      children_[0]->SetBox(box);
+    }
+
+    void ComputeRequirement() override {
+      Node::ComputeRequirement();
+      requirement_.focused.component_active = active_;
+    }
+  };
+
+  return std::make_shared<Wrapper>(std::move(element), Active());
+}
+
+/// @brief Draw the component.
+/// Build a ftxui::Element to be drawn on the ftxi::Screen representing this
+/// ftxui::ComponentBase. This function is means to be overridden.
+/// @ingroup component
+Element ComponentBase::OnRender() {
   if (children_.size() == 1) {
     return children_.front()->Render();
   }

src/ftxui/component/container.cpp

@@ -98,7 +98,7 @@ class VerticalContainer : public ContainerBase {
  public:
   using ContainerBase::ContainerBase;
 
-  Element Render() override {
+  Element OnRender() override {
     Elements elements;
     elements.reserve(children_.size());
     for (auto& it : children_) {
@@ -163,6 +163,7 @@ class VerticalContainer : public ContainerBase {
       return false;
     }
 
+    const int old_selected = *selector_;
     if (event.mouse().button == Mouse::WheelUp) {
       MoveSelector(-1);
     }
@@ -171,7 +172,7 @@ class VerticalContainer : public ContainerBase {
     }
     *selector_ = std::max(0, std::min(int(children_.size()) - 1, *selector_));
 
-    return true;
+    return old_selected != *selector_;
   }
 
   Box box_;
@@ -181,7 +182,7 @@ class HorizontalContainer : public ContainerBase {
  public:
   using ContainerBase::ContainerBase;
 
-  Element Render() override {
+  Element OnRender() override {
     Elements elements;
     elements.reserve(children_.size());
     for (auto& it : children_) {
@@ -217,7 +218,7 @@ class TabContainer : public ContainerBase {
  public:
   using ContainerBase::ContainerBase;
 
-  Element Render() override {
+  Element OnRender() override {
     const Component active_child = ActiveChild();
     if (active_child) {
       return active_child->Render();
@@ -243,7 +244,7 @@ class StackedContainer : public ContainerBase {
       : ContainerBase(std::move(children), nullptr) {}
 
  private:
-  Element Render() final {
+  Element OnRender() final {
     Elements elements;
     for (auto& child : children_) {
       elements.push_back(child->Render());
@@ -333,7 +334,7 @@ Component Vertical(Components children) {
 ///   children_2,
 ///   children_3,
 ///   children_4,
-/// });
+/// }, &selected_children);
 /// ```
 Component Vertical(Components children, int* selector) {
   return std::make_shared<VerticalContainer>(std::move(children), selector);
@@ -354,7 +355,7 @@ Component Vertical(Components children, int* selector) {
 ///   children_2,
 ///   children_3,
 ///   children_4,
-/// }, &selected_children);
+/// });
 /// ```
 Component Horizontal(Components children) {
   return Horizontal(std::move(children), nullptr);

src/ftxui/component/dropdown.cpp

@@ -44,10 +44,14 @@ Component Dropdown(DropdownOption option) {
       }));
     }
 
-    Element Render() override {
-      radiobox.selected =
+    Element OnRender() override {
+      selected_ =
           util::clamp(radiobox.selected(), 0, int(radiobox.entries.size()) - 1);
-      title_ = radiobox.entries[selected_()];
+      selected_ = util::clamp(selected_(), 0, int(radiobox.entries.size()) - 1);
+
+      if (selected_() >= 0 && selected_() < int(radiobox.entries.size())) {
+        title_ = radiobox.entries[selected_()];
+      }
 
       return transform(*open_, checkbox_->Render(), radiobox_->Render());
     }
@@ -66,10 +70,13 @@ Component Dropdown(DropdownOption option) {
       // Auto-close the dropdown when the user selects an item, even if the item
       // it the same as the previous one.
       if (open_old && open_()) {
-        const bool should_close = (selected_() != selected_old) ||     //
-                                  (event == Event::Return) ||          //
-                                  (event == Event::Character(' ')) ||  //
-                                  (event == Event::Escape);            //
+        const bool should_close =
+            (selected_() != selected_old) ||     //
+            (event == Event::Return) ||          //
+            (event == Event::Character(' ')) ||  //
+            (event == Event::Escape) ||          //
+            (event.is_mouse() && event.mouse().button == Mouse::Left &&
+             event.mouse().motion == Mouse::Pressed);
 
         if (should_close) {
           checkbox_->TakeFocus();

src/ftxui/component/dropdown_test.cpp

@@ -0,0 +1,34 @@
+// Copyright 2025 Arthur Sonzogni. All rights reserved.
+// Use of this source code is governed by the MIT license that can be found in
+// the LICENSE file.
+
+#include "ftxui/component/component.hpp"  // for Horizontal, Vertical, Button, Tab
+#include "ftxui/component/component_base.hpp"  // for ComponentBase, Component
+#include "ftxui/component/event.hpp"  // for Event, Event::Tab, Event::TabReverse, Event::ArrowDown, Event::ArrowLeft, Event::ArrowRight, Event::ArrowUp
+#include "gtest/gtest.h"  // for AssertionResult, Message, TestPartResult, EXPECT_EQ, EXPECT_FALSE, Test, EXPECT_TRUE, TEST
+
+namespace ftxui {
+
+TEST(DropdownTest, Empty) {
+  std::vector<std::string> list = {};
+  int index = 0;
+  auto dropdown = Dropdown(list, &index);
+
+  dropdown->OnEvent(Event::Return);
+
+  auto screen = Screen(8, 8);
+  auto document = dropdown->Render();
+  Render(screen, document);
+
+  EXPECT_EQ(screen.ToString(),
+            "╭──────╮\r\n"
+            "│↓     │\r\n"
+            "├──────┤\r\n"
+            "│      │\r\n"
+            "│      │\r\n"
+            "│      │\r\n"
+            "│      │\r\n"
+            "╰──────╯");
+}
+
+}  // namespace ftxui

src/ftxui/component/hoverable.cpp

@@ -49,8 +49,8 @@ Component Hoverable(Component component, bool* hover) {
     }
 
    private:
-    Element Render() override {
-      return ComponentBase::Render() | reflect(box_);
+    Element OnRender() override {
+      return ComponentBase::OnRender() | reflect(box_);
     }
 
     bool OnEvent(Event event) override {
@@ -98,8 +98,8 @@ Component Hoverable(Component component,
     }
 
    private:
-    Element Render() override {
-      return ComponentBase::Render() | reflect(box_);
+    Element OnRender() override {
+      return ComponentBase::OnRender() | reflect(box_);
     }
 
     bool OnEvent(Event event) override {

src/ftxui/component/input.cpp

@@ -96,9 +96,9 @@ class InputBase : public ComponentBase, public InputOption {
 
  private:
   // Component implementation:
-  Element Render() override {
+  Element OnRender() override {
     const bool is_focused = Focused();
-    const auto focused = (!is_focused && !hovered_) ? select
+    const auto focused = (!is_focused && !hovered_) ? nothing
                          : insert()                 ? focusCursorBarBlinking
                                                     : focusCursorBlockBlinking;
 
@@ -108,15 +108,12 @@ class InputBase : public ComponentBase, public InputOption {
     // placeholder.
     if (content->empty()) {
       auto element = text(placeholder()) | xflex | frame;
-      if (is_focused) {
-        element |= focus;
-      }
 
       return transform_func({
                  std::move(element), hovered_, is_focused,
                  true  // placeholder
              }) |
-             reflect(box_);
+             focus | reflect(box_);
     }
 
     Elements elements;
@@ -176,7 +173,7 @@ class InputBase : public ComponentBase, public InputOption {
       elements.push_back(element);
     }
 
-    auto element = vbox(std::move(elements)) | frame;
+    auto element = vbox(std::move(elements), cursor_line) | frame;
     return transform_func({
                std::move(element), hovered_, is_focused,
                false  // placeholder

src/ftxui/component/maybe.cpp

@@ -24,8 +24,8 @@ Component Maybe(Component child, std::function<bool()> show) {
     explicit Impl(std::function<bool()> show) : show_(std::move(show)) {}
 
    private:
-    Element Render() override {
-      return show_() ? ComponentBase::Render() : std::make_unique<Node>();
+    Element OnRender() override {
+      return show_() ? ComponentBase::OnRender() : std::make_unique<Node>();
     }
     bool Focusable() const override {
       return show_() && ComponentBase::Focusable();

src/ftxui/component/menu.cpp

@@ -105,7 +105,7 @@ class MenuBase : public ComponentBase, public MenuOption {
     }
   }
 
-  Element Render() override {
+  Element OnRender() override {
     Clamp();
     UpdateAnimationTarget();
 
@@ -126,16 +126,15 @@ class MenuBase : public ComponentBase, public MenuOption {
           entries[i], false, is_selected, is_focused, i,
       };
 
-      auto focus_management = (selected_focus_ != i) ? nothing
-                              : is_menu_focused      ? focus
-                                                     : select;
-
-      const Element element =
-          (entries_option.transform ? entries_option.transform
-                                    : DefaultOptionTransform)  //
+      Element element = (entries_option.transform ? entries_option.transform
+                                                  : DefaultOptionTransform)  //
           (state);
-      elements.push_back(element | AnimatedColorStyle(i) | reflect(boxes_[i]) |
-                         focus_management);
+      if (selected_focus_ == i) {
+        element |= focus;
+      }
+      element |= AnimatedColorStyle(i);
+      element |= reflect(boxes_[i]);
+      elements.push_back(element);
     }
     if (elements_postfix) {
       elements.push_back(elements_postfix());
@@ -145,8 +144,9 @@ class MenuBase : public ComponentBase, public MenuOption {
       std::reverse(elements.begin(), elements.end());
     }
 
-    const Element bar =
-        IsHorizontal() ? hbox(std::move(elements)) : vbox(std::move(elements));
+    const Element bar = IsHorizontal()
+                            ? hbox(std::move(elements), selected_focus_)
+                            : vbox(std::move(elements), selected_focus_);
 
     if (!underline.enabled) {
       return bar | reflect(box_);
@@ -618,20 +618,22 @@ Component MenuEntry(MenuEntryOption option) {
         : MenuEntryOption(std::move(option)) {}
 
    private:
-    Element Render() override {
-      const bool focused = Focused();
+    Element OnRender() override {
+      const bool is_focused = Focused();
       UpdateAnimationTarget();
 
       const EntryState state{
-          label(), false, hovered_, focused, Index(),
+          label(), false, hovered_, is_focused, Index(),
       };
 
-      const Element element =
-          (transform ? transform : DefaultOptionTransform)  //
+      Element element = (transform ? transform : DefaultOptionTransform)  //
           (state);
 
-      auto focus_management = focused ? select : nothing;
-      return element | AnimatedColorStyle() | focus_management | reflect(box_);
+      if (is_focused) {
+        element |= focus;
+      }
+
+      return element | AnimatedColorStyle() | reflect(box_);
     }
 
     void UpdateAnimationTarget() {
@@ -692,7 +694,6 @@ Component MenuEntry(MenuEntryOption option) {
       animator_foreground_.OnAnimation(params);
     }
 
-    MenuEntryOption option_;
     Box box_;
     bool hovered_ = false;
 

src/ftxui/component/menu_test.cpp

@@ -266,7 +266,7 @@ TEST(MenuTest, MenuEntryIndex) {
   menu->OnEvent(Event::ArrowDown);
   menu->OnEvent(Event::ArrowDown);
   menu->OnEvent(Event::Return);
-  for (int index = 0; index < menu->ChildCount(); index++) {
+  for (size_t index = 0; index < menu->ChildCount(); index++) {
     EXPECT_EQ(menu->ChildAt(index)->Index(), index);
   }
 }

src/ftxui/component/modal.cpp

@@ -26,7 +26,7 @@ Component Modal(Component main, Component modal, const bool* show_modal) {
     }
 
    private:
-    Element Render() override {
+    Element OnRender() override {
       selector_ = *show_modal_;
       auto document = main_->Render();
       if (*show_modal_) {

src/ftxui/component/radiobox.cpp

@@ -28,7 +28,7 @@ class RadioboxBase : public ComponentBase, public RadioboxOption {
       : RadioboxOption(option) {}
 
  private:
-  Element Render() override {
+  Element OnRender() override {
     Clamp();
     Elements elements;
     const bool is_menu_focused = Focused();
@@ -36,18 +36,17 @@ class RadioboxBase : public ComponentBase, public RadioboxOption {
     for (int i = 0; i < size(); ++i) {
       const bool is_focused = (focused_entry() == i) && is_menu_focused;
       const bool is_selected = (hovered_ == i);
-      auto focus_management = !is_selected      ? nothing
-                              : is_menu_focused ? focus
-                                                : select;
       auto state = EntryState{
           entries[i], selected() == i, is_selected, is_focused, i,
       };
       auto element =
           (transform ? transform : RadioboxOption::Simple().transform)(state);
-
-      elements.push_back(element | focus_management | reflect(boxes_[i]));
+      if (is_selected) {
+        element |= focus;
+      }
+      elements.push_back(element | reflect(boxes_[i]));
     }
-    return vbox(std::move(elements)) | reflect(box_);
+    return vbox(std::move(elements), hovered_) | reflect(box_);
   }
 
   // NOLINTNEXTLINE(readability-function-cognitive-complexity)

src/ftxui/component/renderer.cpp

@@ -31,7 +31,7 @@ Component Renderer(std::function<Element()> render) {
    public:
     explicit Impl(std::function<Element()> render)
         : render_(std::move(render)) {}
-    Element Render() override { return render_(); }
+    Element OnRender() override { return render_(); }
     std::function<Element()> render_;
   };
 
@@ -88,7 +88,7 @@ Component Renderer(std::function<Element(bool)> render) {
         : render_(std::move(render)) {}
 
    private:
-    Element Render() override { return render_(Focused()) | reflect(box_); }
+    Element OnRender() override { return render_(Focused()) | reflect(box_); }
     bool Focusable() const override { return true; }
     bool OnEvent(Event event) override {
       if (event.is_mouse() && box_.Contain(event.mouse().x, event.mouse().y)) {

src/ftxui/component/resizable_split.cpp

@@ -77,16 +77,16 @@ class ResizableSplitBase : public ComponentBase {
 
     switch (options_->direction()) {
       case Direction::Left:
-        options_->main_size() = event.mouse().x - box_.x_min;
+        options_->main_size() = std::max(0, event.mouse().x - box_.x_min);
         return true;
       case Direction::Right:
-        options_->main_size() = box_.x_max - event.mouse().x;
+        options_->main_size() = std::max(0, box_.x_max - event.mouse().x);
         return true;
       case Direction::Up:
-        options_->main_size() = event.mouse().y - box_.y_min;
+        options_->main_size() = std::max(0, event.mouse().y - box_.y_min);
         return true;
       case Direction::Down:
-        options_->main_size() = box_.y_max - event.mouse().y;
+        options_->main_size() = std::max(0, box_.y_max - event.mouse().y);
         return true;
     }
 
@@ -94,7 +94,7 @@ class ResizableSplitBase : public ComponentBase {
     return false;
   }
 
-  Element Render() final {
+  Element OnRender() final {
     switch (options_->direction()) {
       case Direction::Left:
         return RenderLeft();

src/ftxui/component/screen_interactive.cpp

@@ -34,6 +34,7 @@
 #include "ftxui/dom/requirement.hpp"                  // for Requirement
 #include "ftxui/screen/pixel.hpp"                     // for Pixel
 #include "ftxui/screen/terminal.hpp"                  // for Dimensions, Size
+#include "ftxui/screen/util.hpp"                      // for util::clamp
 
 #if defined(_WIN32)
 #define DEFINE_CONSOLEV2_PROPERTIES
@@ -576,6 +577,18 @@ void ScreenInteractive::ForceHandleCtrlZ(bool force) {
   force_handle_ctrl_z_ = force;
 }
 
+/// @brief Returns the content of the current selection
+std::string ScreenInteractive::GetSelection() {
+  if (!selection_) {
+    return "";
+  }
+  return selection_->GetParts();
+}
+
+void ScreenInteractive::SelectionChange(std::function<void()> callback) {
+  selection_on_change_ = std::move(callback);
+}
+
 /// @brief Return the currently active screen, or null if none.
 // static
 ScreenInteractive* ScreenInteractive::Active() {
@@ -751,6 +764,14 @@ void ScreenInteractive::RunOnce(Component component) {
     ExecuteSignalHandlers();
   }
   Draw(std::move(component));
+
+  if (selection_data_previous_ != selection_data_) {
+    selection_data_previous_ = selection_data_;
+    if (selection_on_change_) {
+      selection_on_change_();
+      Post(Event::Custom);
+    }
+  }
 }
 
 // private
@@ -781,7 +802,9 @@ void ScreenInteractive::HandleTask(Component component, Task& task) {
 
       arg.screen_ = this;
 
-      const bool handled = component->OnEvent(arg);
+      bool handled = component->OnEvent(arg);
+
+      handled = HandleSelection(handled, arg);
 
       if (arg == Event::CtrlC && (!handled || force_handle_ctrl_c_)) {
         RecordSignal(SIGABRT);
@@ -824,6 +847,59 @@ void ScreenInteractive::HandleTask(Component component, Task& task) {
   // clang-format on
 }
 
+// private
+bool ScreenInteractive::HandleSelection(bool handled, Event event) {
+  if (handled) {
+    selection_pending_ = nullptr;
+    selection_data_.empty = true;
+    selection_ = nullptr;
+    return true;
+  }
+
+  if (!event.is_mouse()) {
+    return false;
+  }
+
+  auto& mouse = event.mouse();
+  if (mouse.button != Mouse::Left) {
+    return false;
+  }
+
+  if (mouse.motion == Mouse::Pressed) {
+    selection_pending_ = CaptureMouse();
+    selection_data_.start_x = mouse.x;
+    selection_data_.start_y = mouse.y;
+    selection_data_.end_x = mouse.x;
+    selection_data_.end_y = mouse.y;
+    return false;
+  }
+
+  if (!selection_pending_) {
+    return false;
+  }
+
+  if (mouse.motion == Mouse::Moved) {
+    if ((mouse.x != selection_data_.end_x) ||
+        (mouse.y != selection_data_.end_y)) {
+      selection_data_.end_x = mouse.x;
+      selection_data_.end_y = mouse.y;
+      selection_data_.empty = false;
+    }
+
+    return true;
+  }
+
+  if (mouse.motion == Mouse::Released) {
+    selection_pending_ = nullptr;
+    selection_data_.end_x = mouse.x;
+    selection_data_.end_y = mouse.y;
+    selection_data_.empty = false;
+    return true;
+  }
+
+  return false;
+}
+
 // private
 // NOLINTNEXTLINE
 void ScreenInteractive::Draw(Component component) {
@@ -842,15 +918,15 @@ void ScreenInteractive::Draw(Component component) {
       break;
     case Dimension::TerminalOutput:
       dimx = terminal.dimx;
-      dimy = document->requirement().min_y;
+      dimy = util::clamp(document->requirement().min_y, 0, terminal.dimy);
       break;
     case Dimension::Fullscreen:
       dimx = terminal.dimx;
       dimy = terminal.dimy;
       break;
     case Dimension::FitComponent:
-      dimx = std::min(document->requirement().min_x, terminal.dimx);
-      dimy = std::min(document->requirement().min_y, terminal.dimy);
+      dimx = util::clamp(document->requirement().min_x, 0, terminal.dimx);
+      dimy = util::clamp(document->requirement().min_y, 0, terminal.dimy);
       break;
   }
 
@@ -899,7 +975,12 @@ void ScreenInteractive::Draw(Component component) {
 #endif
   previous_frame_resized_ = resized;
 
-  Render(*this, document);
+  selection_ = selection_data_.empty
+                   ? std::make_unique<Selection>()
+                   : std::make_unique<Selection>(
+                         selection_data_.start_x, selection_data_.start_y,  //
+                         selection_data_.end_x, selection_data_.end_y);
+  Render(*this, document.get(), *selection_);
 
   // Set cursor position for user using tools to insert CJK characters.
   {
@@ -988,4 +1069,21 @@ void ScreenInteractive::Signal(int signal) {
 #endif
 }
 
+bool ScreenInteractive::SelectionData::operator==(
+    const ScreenInteractive::SelectionData& other) const {
+  if (empty && other.empty) {
+    return true;
+  }
+  if (empty || other.empty) {
+    return false;
+  }
+  return start_x == other.start_x && start_y == other.start_y &&
+         end_x == other.end_x && end_y == other.end_y;
+}
+
+bool ScreenInteractive::SelectionData::operator!=(
+    const ScreenInteractive::SelectionData& other) const {
+  return !(*this == other);
+}
+
 }  // namespace ftxui.

src/ftxui/component/slider.cpp

@@ -16,7 +16,6 @@
 #include "ftxui/dom/elements.hpp"  // for operator|, text, Element, xflex, hbox, color, underlined, reflect, Decorator, dim, vcenter, focus, nothing, select, yflex, gaugeDirection
 #include "ftxui/screen/box.hpp"    // for Box
 #include "ftxui/screen/color.hpp"  // for Color, Color::GrayDark, Color::White
-#include "ftxui/screen/util.hpp"   // for clamp
 #include "ftxui/util/ref.hpp"      // for ConstRef, Ref, ConstStringRef
 
 namespace ftxui {
@@ -39,7 +38,7 @@ class SliderBase : public SliderOption<T>, public ComponentBase {
  public:
   explicit SliderBase(SliderOption<T> options) : SliderOption<T>(options) {}
 
-  Element Render() override {
+  Element OnRender() override {
     auto gauge_color =
         Focused() ? color(this->color_active) : color(this->color_inactive);
     const float percent =
@@ -134,53 +133,52 @@ class SliderBase : public SliderOption<T>, public ComponentBase {
     return ComponentBase::OnEvent(event);
   }
 
+  bool OnCapturedMouseEvent(Event event) {
+    if (event.mouse().motion == Mouse::Released) {
+      captured_mouse_ = nullptr;
+      return true;
+    }
+
+    T old_value = this->value();
+    switch (this->direction) {
+      case Direction::Right: {
+        this->value() = this->min() + (event.mouse().x - gauge_box_.x_min) *
+                                          (this->max() - this->min()) /
+                                          (gauge_box_.x_max - gauge_box_.x_min);
+
+        break;
+      }
+      case Direction::Left: {
+        this->value() = this->max() - (event.mouse().x - gauge_box_.x_min) *
+                                          (this->max() - this->min()) /
+                                          (gauge_box_.x_max - gauge_box_.x_min);
+        break;
+      }
+      case Direction::Down: {
+        this->value() = this->min() + (event.mouse().y - gauge_box_.y_min) *
+                                          (this->max() - this->min()) /
+                                          (gauge_box_.y_max - gauge_box_.y_min);
+        break;
+      }
+      case Direction::Up: {
+        this->value() = this->max() - (event.mouse().y - gauge_box_.y_min) *
+                                          (this->max() - this->min()) /
+                                          (gauge_box_.y_max - gauge_box_.y_min);
+        break;
+      }
+    }
+
+    this->value() = std::max(this->min(), std::min(this->max(), this->value()));
+
+    if (old_value != this->value() && this->on_change) {
+      this->on_change();
+    }
+    return true;
+  }
+
   bool OnMouseEvent(Event event) {
     if (captured_mouse_) {
-      if (event.mouse().motion == Mouse::Released) {
-        captured_mouse_ = nullptr;
-        return true;
-      }
-
-      T old_value = this->value();
-      switch (this->direction) {
-        case Direction::Right: {
-          this->value() =
-              this->min() + (event.mouse().x - gauge_box_.x_min) *
-                                (this->max() - this->min()) /
-                                (gauge_box_.x_max - gauge_box_.x_min);
-
-          break;
-        }
-        case Direction::Left: {
-          this->value() =
-              this->max() - (event.mouse().x - gauge_box_.x_min) *
-                                (this->max() - this->min()) /
-                                (gauge_box_.x_max - gauge_box_.x_min);
-          break;
-        }
-        case Direction::Down: {
-          this->value() =
-              this->min() + (event.mouse().y - gauge_box_.y_min) *
-                                (this->max() - this->min()) /
-                                (gauge_box_.y_max - gauge_box_.y_min);
-          break;
-        }
-        case Direction::Up: {
-          this->value() =
-              this->max() - (event.mouse().y - gauge_box_.y_min) *
-                                (this->max() - this->min()) /
-                                (gauge_box_.y_max - gauge_box_.y_min);
-          break;
-        }
-      }
-
-      this->value() =
-          std::max(this->min(), std::min(this->max(), this->value()));
-
-      if (old_value != this->value() && this->on_change) {
-        this->on_change();
-      }
-      return true;
+      return OnCapturedMouseEvent(event);
     }
 
     if (event.mouse().button != Mouse::Left) {
@@ -198,7 +196,7 @@ class SliderBase : public SliderOption<T>, public ComponentBase {
 
     if (captured_mouse_) {
       TakeFocus();
-      return true;
+      return OnCapturedMouseEvent(event);
     }
 
     return false;
@@ -242,19 +240,21 @@ class SliderWithLabel : public ComponentBase {
     return true;
   }
 
-  Element Render() override {
-    auto focus_management = Focused() ? focus : Active() ? select : nothing;
+  Element OnRender() override {
     auto gauge_color = (Focused() || mouse_hover_) ? color(Color::White)
                                                    : color(Color::GrayDark);
-    return hbox({
-               text(label_()) | dim | vcenter,
-               hbox({
-                   text("["),
-                   ComponentBase::Render() | underlined,
-                   text("]"),
-               }) | xflex,
-           }) |
-           gauge_color | xflex | reflect(box_) | focus_management;
+    auto element = hbox({
+                       text(label_()) | dim | vcenter,
+                       hbox({
+                           text("["),
+                           ComponentBase::Render() | underlined,
+                           text("]"),
+                       }) | xflex,
+                   }) |
+                   gauge_color | xflex | reflect(box_);
+
+    element |= focus;
+    return element;
   }
 
   ConstStringRef label_;

src/ftxui/component/slider_test.cpp

@@ -60,17 +60,17 @@ TEST(SliderTest, Right) {
   EXPECT_EQ(value, 50);
   EXPECT_EQ(updated, 0);
   EXPECT_TRUE(slider->OnEvent(MousePressed(3, 0)));
-  EXPECT_EQ(value, 50);
-  EXPECT_EQ(updated, 0);
+  EXPECT_EQ(value, 30);
+  EXPECT_EQ(updated, 1);
   EXPECT_TRUE(slider->OnEvent(MousePressed(9, 0)));
   EXPECT_EQ(value, 90);
-  EXPECT_EQ(updated, 1);
+  EXPECT_EQ(updated, 2);
   EXPECT_TRUE(slider->OnEvent(MousePressed(9, 2)));
   EXPECT_EQ(value, 90);
-  EXPECT_EQ(updated, 1);
+  EXPECT_EQ(updated, 2);
   EXPECT_TRUE(slider->OnEvent(MousePressed(5, 2)));
   EXPECT_EQ(value, 50);
-  EXPECT_EQ(updated, 2);
+  EXPECT_EQ(updated, 3);
   EXPECT_TRUE(slider->OnEvent(MouseReleased(5, 2)));
   EXPECT_FALSE(slider->OnEvent(MousePressed(5, 2)));
   EXPECT_EQ(value, 50);
@@ -92,17 +92,17 @@ TEST(SliderTest, Left) {
   EXPECT_EQ(value, 50);
   EXPECT_EQ(updated, 0);
   EXPECT_TRUE(slider->OnEvent(MousePressed(3, 0)));
-  EXPECT_EQ(value, 50);
-  EXPECT_EQ(updated, 0);
+  EXPECT_EQ(value, 70);
+  EXPECT_EQ(updated, 1);
   EXPECT_TRUE(slider->OnEvent(MousePressed(9, 0)));
   EXPECT_EQ(value, 10);
-  EXPECT_EQ(updated, 1);
+  EXPECT_EQ(updated, 2);
   EXPECT_TRUE(slider->OnEvent(MousePressed(9, 2)));
   EXPECT_EQ(value, 10);
-  EXPECT_EQ(updated, 1);
+  EXPECT_EQ(updated, 2);
   EXPECT_TRUE(slider->OnEvent(MousePressed(5, 2)));
   EXPECT_EQ(value, 50);
-  EXPECT_EQ(updated, 2);
+  EXPECT_EQ(updated, 3);
   EXPECT_TRUE(slider->OnEvent(MouseReleased(5, 2)));
   EXPECT_FALSE(slider->OnEvent(MousePressed(5, 2)));
   EXPECT_EQ(value, 50);
@@ -124,21 +124,21 @@ TEST(SliderTest, Down) {
   EXPECT_EQ(value, 50);
   EXPECT_EQ(updated, 0);
   EXPECT_TRUE(slider->OnEvent(MousePressed(0, 3)));
-  EXPECT_EQ(value, 50);
-  EXPECT_EQ(updated, 0);
+  EXPECT_EQ(value, 30);
+  EXPECT_EQ(updated, 1);
   EXPECT_TRUE(slider->OnEvent(MousePressed(0, 9)));
   EXPECT_EQ(value, 90);
-  EXPECT_EQ(updated, 1);
+  EXPECT_EQ(updated, 2);
   EXPECT_TRUE(slider->OnEvent(MousePressed(2, 9)));
   EXPECT_EQ(value, 90);
-  EXPECT_EQ(updated, 1);
+  EXPECT_EQ(updated, 2);
   EXPECT_TRUE(slider->OnEvent(MousePressed(2, 5)));
   EXPECT_EQ(value, 50);
-  EXPECT_EQ(updated, 2);
+  EXPECT_EQ(updated, 3);
   EXPECT_TRUE(slider->OnEvent(MouseReleased(2, 5)));
   EXPECT_FALSE(slider->OnEvent(MousePressed(2, 5)));
   EXPECT_EQ(value, 50);
-  EXPECT_EQ(updated, 2);
+  EXPECT_EQ(updated, 3);
 }
 
 TEST(SliderTest, Up) {
@@ -157,17 +157,17 @@ TEST(SliderTest, Up) {
   EXPECT_EQ(value, 50);
   EXPECT_EQ(updated, 0);
   EXPECT_TRUE(slider->OnEvent(MousePressed(0, 3)));
-  EXPECT_EQ(value, 50);
-  EXPECT_EQ(updated, 0);
+  EXPECT_EQ(value, 70);
+  EXPECT_EQ(updated, 1);
   EXPECT_TRUE(slider->OnEvent(MousePressed(0, 9)));
   EXPECT_EQ(value, 10);
-  EXPECT_EQ(updated, 1);
+  EXPECT_EQ(updated, 2);
   EXPECT_TRUE(slider->OnEvent(MousePressed(2, 9)));
   EXPECT_EQ(value, 10);
-  EXPECT_EQ(updated, 1);
+  EXPECT_EQ(updated, 2);
   EXPECT_TRUE(slider->OnEvent(MousePressed(2, 5)));
   EXPECT_EQ(value, 50);
-  EXPECT_EQ(updated, 2);
+  EXPECT_EQ(updated, 3);
   EXPECT_TRUE(slider->OnEvent(MouseReleased(2, 5)));
   EXPECT_FALSE(slider->OnEvent(MousePressed(2, 5)));
   EXPECT_EQ(value, 50);

src/ftxui/component/window.cpp

@@ -124,7 +124,7 @@ class WindowImpl : public ComponentBase, public WindowOptions {
   }
 
  private:
-  Element Render() final {
+  Element OnRender() final {
     auto element = ComponentBase::Render();
 
     const bool captureable =

src/ftxui/dom.cppm

@@ -0,0 +1,17 @@
+/**
+ * @file dom.cppm
+ * @brief Module file for FTXUI main operations.
+ */
+
+export module ftxui.dom;
+
+export import ftxui.dom.Canvas;
+export import ftxui.dom.Deprecated;
+export import ftxui.dom.Direction;
+export import ftxui.dom.Elements;
+export import ftxui.dom.FlexboxConfig;
+export import ftxui.dom.LinearGradient;
+export import ftxui.dom.Node;
+export import ftxui.dom.Requirement;
+export import ftxui.dom.Selection;
+export import ftxui.dom.Table;

src/ftxui/dom/Canvas.cppm

@@ -0,0 +1,18 @@
+/**
+ * @file Canvas.cppm
+ * @brief Module file for the Canvas struct of the Dom module
+ */
+
+module;
+
+#include <ftxui/dom/canvas.hpp>
+
+export module ftxui.dom.Canvas;
+
+/**
+ * @namespace ftxui
+ * @brief The FTXUI ftxui:: namespace
+ */
+export namespace ftxui {
+    using ftxui::Canvas;
+}

src/ftxui/dom/Deprecated.cppm

@@ -0,0 +1,20 @@
+/**
+ * @file Deprecated.cppm
+ * @brief Module file for deprecated parts of the Dom module
+ */
+
+module;
+
+#include <ftxui/dom/deprecated.hpp>
+
+export module ftxui.dom.Deprecated;
+
+/**
+ * @namespace ftxui
+ * @brief The FTXUI ftxui:: namespace
+ */
+export namespace ftxui {
+    using ftxui::text;
+    using ftxui::vtext;
+    using ftxui::paragraph;
+}

src/ftxui/dom/Direction.cppm

@@ -0,0 +1,18 @@
+/**
+ * @file Direction.cppm
+ * @brief Module file for the Direction enum of the Dom module
+ */
+
+module;
+
+#include <ftxui/dom/direction.hpp>
+
+export module ftxui.dom.Direction;
+
+/**
+ * @namespace ftxui
+ * @brief The FTXUI ftxui:: namespace
+ */
+export namespace ftxui {
+    using ftxui::Direction;
+}

src/ftxui/dom/Elements.cppm

@@ -0,0 +1,130 @@
+/**
+ * @file Canvas.cppm
+ * @brief Module file for the Element classes and functions of the Dom module
+ */
+
+module;
+
+#include <ftxui/dom/elements.hpp>
+
+export module ftxui.dom.Elements;
+
+/**
+ * @namespace ftxui
+ * @brief The FTXUI ftxui:: namespace
+ */
+export namespace ftxui {
+    using ftxui::Node;
+    using ftxui::Element;
+    using ftxui::Elements;
+    using ftxui::Decorator;
+    using ftxui::GraphFunction;
+
+    using ftxui::BorderStyle;
+
+    using ftxui::operator|;
+    using ftxui::operator|=;
+
+    using ftxui::text;
+    using ftxui::vtext;
+    using ftxui::separator;
+    using ftxui::separatorLight;
+    using ftxui::separatorDashed;
+    using ftxui::separatorHeavy;
+    using ftxui::separatorDouble;
+    using ftxui::separatorEmpty;
+    using ftxui::separatorStyled;
+    using ftxui::separatorCharacter;
+    using ftxui::separatorHSelector;
+    using ftxui::separatorVSelector;
+    using ftxui::gauge;
+    using ftxui::gaugeLeft;
+    using ftxui::gaugeRight;
+    using ftxui::gaugeUp;
+    using ftxui::gaugeDown;
+    using ftxui::gaugeDirection;
+    using ftxui::border;
+    using ftxui::borderLight;
+    using ftxui::borderDashed;
+    using ftxui::borderHeavy;
+    using ftxui::borderDouble;
+    using ftxui::borderRounded;
+    using ftxui::borderEmpty;
+    using ftxui::borderStyled;
+    using ftxui::borderWith;
+    using ftxui::window;
+    using ftxui::spinner;
+    using ftxui::paragraph;
+    using ftxui::paragraphAlignLeft;
+    using ftxui::paragraphAlignRight;
+    using ftxui::paragraphAlignCenter;
+    using ftxui::paragraphAlignJustify;
+    using ftxui::graph;
+    using ftxui::emptyElement;
+    using ftxui::canvas;
+
+    using ftxui::bold;
+    using ftxui::dim;
+    using ftxui::inverted;
+    using ftxui::underlined;
+    using ftxui::underlinedDouble;
+    using ftxui::blink;
+    using ftxui::strikethrough;
+    using ftxui::color;
+    using ftxui::bgcolor;
+    using ftxui::focusPosition;
+    using ftxui::focusPositionRelative;
+    using ftxui::automerge;
+    using ftxui::hyperlink;
+    using ftxui::selectionStyleReset;
+    using ftxui::selectionColor;
+    using ftxui::selectionBackgroundColor;
+    using ftxui::selectionForegroundColor;
+    using ftxui::selectionStyle;
+
+    using ftxui::hbox;
+    using ftxui::vbox;
+    using ftxui::dbox;
+    using ftxui::flexbox;
+    using ftxui::gridbox;
+    using ftxui::hflow;
+    using ftxui::vflow;
+
+    using ftxui::flex;
+    using ftxui::flex_grow;
+    using ftxui::flex_shrink;
+    using ftxui::xflex;
+    using ftxui::xflex_grow;
+    using ftxui::xflex_shrink;
+    using ftxui::yflex;
+    using ftxui::yflex_grow;
+    using ftxui::yflex_shrink;
+    using ftxui::notflex;
+    using ftxui::filler;
+
+    using ftxui::WidthOrHeight;
+    using ftxui::Constraint;
+    using ftxui::size;
+
+    using ftxui::focusCursorBlock;
+    using ftxui::focusCursorBlockBlinking;
+    using ftxui::focusCursorBar;
+    using ftxui::focusCursorBarBlinking;
+    using ftxui::focusCursorUnderline;
+    using ftxui::focusCursorUnderlineBlinking;
+
+    using ftxui::vscroll_indicator;
+    using ftxui::hscroll_indicator;
+    using ftxui::reflect;
+    using ftxui::clear_under;
+
+    using ftxui::hcenter;
+    using ftxui::vcenter;
+    using ftxui::center;
+    using ftxui::align_right;
+    using ftxui::nothing;
+
+    namespace Dimension {
+        using ftxui::Dimension::Fit;
+    }
+}

src/ftxui/dom/FlexboxConfig.cppm

@@ -0,0 +1,18 @@
+/**
+ * @file FlexboxConfig.cppm
+ * @brief Module file for the FlexboxConfig struct of the Dom module
+ */
+
+module;
+
+#include <ftxui/dom/flexbox_config.hpp>
+
+export module ftxui.dom.FlexboxConfig;
+
+/**
+ * @namespace ftxui
+ * @brief The FTXUI ftxui:: namespace
+ */
+export namespace ftxui {
+    using ftxui::FlexboxConfig;
+}

src/ftxui/dom/LinearGradient.cppm

@@ -0,0 +1,18 @@
+/**
+ * @file LinearGradient.cppm
+ * @brief Module file for the LinearGradient struct of the Dom module
+ */
+
+module;
+
+#include <ftxui/dom/linear_gradient.hpp>
+
+export module ftxui.dom.LinearGradient;
+
+/**
+ * @namespace ftxui
+ * @brief The FTXUI ftxui:: namespace
+ */
+export namespace ftxui {
+    using ftxui::LinearGradient;
+}

src/ftxui/dom/Node.cppm

@@ -0,0 +1,25 @@
+/**
+ * @file Node.cppm
+ * @brief Module file for the Node class of the Dom module
+ */
+
+module;
+
+#include <ftxui/dom/node.hpp>
+
+export module ftxui.dom.Node;
+
+/**
+ * @namespace ftxui
+ * @brief The FTXUI ftxui:: namespace
+ */
+export namespace ftxui {
+    using ftxui::Node;
+    using ftxui::Screen;
+
+    using ftxui::Element;
+    using ftxui::Elements;
+
+    using ftxui::Render;
+    using ftxui::GetNodeSelectedContent;
+}

src/ftxui/dom/Requirement.cppm

@@ -0,0 +1,18 @@
+/**
+ * @file Requirement.cppm
+ * @brief Module file for the Requirement struct of the Dom module
+ */
+
+module;
+
+#include <ftxui/dom/requirement.hpp>
+
+export module ftxui.dom.Requirement;
+
+/**
+ * @namespace ftxui
+ * @brief The FTXUI ftxui:: namespace
+ */
+export namespace ftxui {
+    using ftxui::Requirement;
+}

src/ftxui/dom/Selection.cppm

@@ -0,0 +1,18 @@
+/**
+ * @file Selection.cppm
+ * @brief Module file for the Selection class of the Dom module
+ */
+
+module;
+
+#include <ftxui/dom/selection.hpp>
+
+export module ftxui.dom.Selection;
+
+/**
+ * @namespace ftxui
+ * @brief The FTXUI ftxui:: namespace
+ */
+export namespace ftxui {
+    using ftxui::Selection;
+}

src/ftxui/dom/Table.cppm

@@ -0,0 +1,19 @@
+/**
+ * @file Table.cppm
+ * @brief Module file for the Table class of the Dom module
+ */
+
+module;
+
+#include <ftxui/dom/table.hpp>
+
+export module ftxui.dom.Table;
+
+/**
+ * @namespace ftxui
+ * @brief The FTXUI ftxui:: namespace
+ */
+export namespace ftxui {
+    using ftxui::Table;
+    using ftxui::TableSelection;
+}

src/ftxui/dom/border.cpp

@@ -54,10 +54,10 @@ class Border : public Node {
       requirement_.min_x =
           std::max(requirement_.min_x, children_[1]->requirement().min_x + 2);
     }
-    requirement_.selected_box.x_min++;
-    requirement_.selected_box.x_max++;
-    requirement_.selected_box.y_min++;
-    requirement_.selected_box.y_max++;
+    requirement_.focused.box.x_min++;
+    requirement_.focused.box.x_max++;
+    requirement_.focused.box.y_min++;
+    requirement_.focused.box.y_max++;
   }
 
   void SetBox(Box box) override {
@@ -65,7 +65,8 @@ class Border : public Node {
     if (children_.size() == 2) {
       Box title_box;
       title_box.x_min = box.x_min + 1;
-      title_box.x_max = std::min(box.x_max - 1, box.x_min + children_[1]->requirement().min_x);
+      title_box.x_max = std::min(box.x_max - 1,
+                                 box.x_min + children_[1]->requirement().min_x);
       title_box.y_min = box.y_min;
       title_box.y_max = box.y_min;
       children_[1]->SetBox(title_box);
@@ -145,10 +146,8 @@ class BorderPixel : public Node {
       requirement_.min_x =
           std::max(requirement_.min_x, children_[1]->requirement().min_x + 2);
     }
-    requirement_.selected_box.x_min++;
-    requirement_.selected_box.x_max++;
-    requirement_.selected_box.y_min++;
-    requirement_.selected_box.y_max++;
+
+    requirement_.focused.box.Shift(1, 1);
   }
 
   void SetBox(Box box) override {

src/ftxui/dom/box_helper.hpp

@@ -5,6 +5,7 @@
 #define FTXUI_DOM_BOX_HELPER_HPP
 
 #include <vector>
+#include "ftxui/dom/requirement.hpp"
 
 namespace ftxui::box_helper {
 
@@ -19,7 +20,6 @@ struct Element {
 };
 
 void Compute(std::vector<Element>* elements, int target_size);
-
 }  // namespace ftxui::box_helper
 
 #endif /* end of include guard: FTXUI_DOM_BOX_HELPER_HPP */

src/ftxui/dom/dbox.cpp

@@ -21,24 +21,20 @@ class DBox : public Node {
   explicit DBox(Elements children) : Node(std::move(children)) {}
 
   void ComputeRequirement() override {
-    requirement_.min_x = 0;
-    requirement_.min_y = 0;
-    requirement_.flex_grow_x = 0;
-    requirement_.flex_grow_y = 0;
-    requirement_.flex_shrink_x = 0;
-    requirement_.flex_shrink_y = 0;
-    requirement_.selection = Requirement::NORMAL;
+    requirement_ = Requirement{};
     for (auto& child : children_) {
       child->ComputeRequirement();
+
+      // Propagate the focused requirement.
+      if (requirement_.focused.Prefer(child->requirement().focused)) {
+        requirement_.focused = child->requirement().focused;
+      }
+
+      // Extend the min_x and min_y to contain all the children
       requirement_.min_x =
           std::max(requirement_.min_x, child->requirement().min_x);
       requirement_.min_y =
           std::max(requirement_.min_y, child->requirement().min_y);
-
-      if (requirement_.selection < child->requirement().selection) {
-        requirement_.selection = child->requirement().selection;
-        requirement_.selected_box = child->requirement().selected_box;
-      }
     }
   }
 
@@ -79,6 +75,7 @@ class DBox : public Node {
             acc->bold = pixel.bold;
             acc->dim = pixel.dim;
             acc->inverted = pixel.inverted;
+            acc->italic = pixel.italic;
             acc->underlined = pixel.underlined;
             acc->underlined_double = pixel.underlined_double;
             acc->strikethrough = pixel.strikethrough;

src/ftxui/dom/flex.cpp

@@ -80,6 +80,7 @@ class Flex : public Node {
   }
 
   void SetBox(Box box) override {
+    Node::SetBox(box);
     if (children_.empty()) {
       return;
     }

src/ftxui/dom/flexbox.cpp

@@ -4,6 +4,7 @@
 #include <algorithm>  // for min, max
 #include <cstddef>    // for size_t
 #include <memory>  // for __shared_ptr_access, shared_ptr, allocator_traits<>::value_type, make_shared
+#include <tuple>   // for ignore
 #include <utility>  // for move, swap
 #include <vector>   // for vector
 
@@ -12,6 +13,7 @@
 #include "ftxui/dom/flexbox_helper.hpp"  // for Block, Global, Compute
 #include "ftxui/dom/node.hpp"            // for Node, Elements, Node::Status
 #include "ftxui/dom/requirement.hpp"     // for Requirement
+#include "ftxui/dom/selection.hpp"       // for Selection
 #include "ftxui/screen/box.hpp"          // for Box
 
 namespace ftxui {
@@ -89,37 +91,32 @@ class Flexbox : public Node {
   }
 
   void ComputeRequirement() override {
+    requirement_ = Requirement{};
     for (auto& child : children_) {
       child->ComputeRequirement();
     }
-    flexbox_helper::Global global;
-    global.config = config_normalized_;
+    global_ = flexbox_helper::Global();
+    global_.config = config_normalized_;
     if (IsColumnOriented()) {
-      global.size_x = 100000;  // NOLINT
-      global.size_y = asked_;
+      global_.size_x = 100000;  // NOLINT
+      global_.size_y = asked_;
     } else {
-      global.size_x = asked_;
-      global.size_y = 100000;  // NOLINT
+      global_.size_x = asked_;
+      global_.size_y = 100000;  // NOLINT
     }
-    Layout(global, true);
+    Layout(global_, true);
 
-    // Reset:
-    requirement_.selection = Requirement::Selection::NORMAL;
-    requirement_.selected_box = Box();
-    requirement_.min_x = 0;
-    requirement_.min_y = 0;
-
-    if (global.blocks.empty()) {
+    if (global_.blocks.empty()) {
       return;
     }
 
     // Compute the union of all the blocks:
     Box box;
-    box.x_min = global.blocks[0].x;
-    box.y_min = global.blocks[0].y;
-    box.x_max = global.blocks[0].x + global.blocks[0].dim_x;
-    box.y_max = global.blocks[0].y + global.blocks[0].dim_y;
-    for (auto& b : global.blocks) {
+    box.x_min = global_.blocks[0].x;
+    box.y_min = global_.blocks[0].y;
+    box.x_max = global_.blocks[0].x + global_.blocks[0].dim_x;
+    box.y_max = global_.blocks[0].y + global_.blocks[0].dim_y;
+    for (auto& b : global_.blocks) {
       box.x_min = std::min(box.x_min, b.x);
       box.y_min = std::min(box.y_min, b.y);
       box.x_max = std::max(box.x_max, b.x + b.dim_x);
@@ -130,19 +127,14 @@ class Flexbox : public Node {
 
     // Find the selection:
     for (size_t i = 0; i < children_.size(); ++i) {
-      if (requirement_.selection >= children_[i]->requirement().selection) {
-        continue;
+      if (requirement_.focused.Prefer(children_[i]->requirement().focused)) {
+        requirement_.focused = children_[i]->requirement().focused;
+        // Shift |focused.box| according to its position inside this component:
+        auto& b = global_.blocks[i];
+        requirement_.focused.box.Shift(b.x, b.y);
+        requirement_.focused.box =
+            Box::Intersection(requirement_.focused.box, box);
       }
-      requirement_.selection = children_[i]->requirement().selection;
-      Box selected_box = children_[i]->requirement().selected_box;
-
-      // Shift |selected_box| according to its position inside this component:
-      auto& b = global.blocks[i];
-      selected_box.x_min += b.x;
-      selected_box.y_min += b.y;
-      selected_box.x_max += b.x;
-      selected_box.y_max += b.y;
-      requirement_.selected_box = Box::Intersection(selected_box, box);
     }
   }
 
@@ -177,6 +169,43 @@ class Flexbox : public Node {
     }
   }
 
+  void Select(Selection& selection) override {
+    // If this Node box_ doesn't intersect with the selection, then no
+    // selection.
+    if (Box::Intersection(selection.GetBox(), box_).IsEmpty()) {
+      return;
+    }
+
+    Selection selection_lines = IsColumnOriented()
+                                    ? selection.SaturateVertical(box_)
+                                    : selection.SaturateHorizontal(box_);
+
+    size_t i = 0;
+    for (auto& line : global_.lines) {
+      Box box;
+      box.x_min = box_.x_min + line.x;
+      box.x_max = box_.x_min + line.x + line.dim_x - 1;
+      box.y_min = box_.y_min + line.y;
+      box.y_max = box_.y_min + line.y + line.dim_y - 1;
+
+      // If the line box doesn't intersect with the selection, then no
+      // selection.
+      if (Box::Intersection(selection.GetBox(), box).IsEmpty()) {
+        continue;
+      }
+
+      Selection selection_line = IsColumnOriented()
+                                     ? selection_lines.SaturateHorizontal(box)
+                                     : selection_lines.SaturateVertical(box);
+
+      for (auto& block : line.blocks) {
+        std::ignore = block;
+        children_[i]->Select(selection_line);
+        i++;
+      }
+    }
+  }
+
   void Check(Status* status) override {
     for (auto& child : children_) {
       child->Check(status);
@@ -194,6 +223,7 @@ class Flexbox : public Node {
   bool need_iteration_ = true;
   const FlexboxConfig config_;
   const FlexboxConfig config_normalized_;
+  flexbox_helper::Global global_;
 };
 
 }  // namespace

src/ftxui/dom/flexbox_helper.cpp

@@ -68,6 +68,10 @@ void SymmetryXY(Global& g) {
     std::swap(b.x, b.y);
     std::swap(b.dim_x, b.dim_y);
   }
+  for (auto& l : g.lines) {
+    std::swap(l.x, l.y);
+    std::swap(l.dim_x, l.dim_y);
+  }
 }
 
 void SymmetryX(Global& g) {
@@ -75,6 +79,9 @@ void SymmetryX(Global& g) {
   for (auto& b : g.blocks) {
     b.x = g.size_x - b.x - b.dim_x;
   }
+  for (auto& l : g.lines) {
+    l.x = g.size_x - l.x - l.dim_x;
+  }
 }
 
 void SymmetryY(Global& g) {
@@ -82,14 +89,13 @@ void SymmetryY(Global& g) {
   for (auto& b : g.blocks) {
     b.y = g.size_y - b.y - b.dim_y;
   }
+  for (auto& l : g.lines) {
+    l.y = g.size_y - l.y - l.dim_y;
+  }
 }
 
-struct Line {
-  std::vector<Block*> blocks;
-};
-
-void SetX(Global& global, std::vector<Line> lines) {
-  for (auto& line : lines) {
+void SetX(Global& global) {
+  for (auto& line : global.lines) {
     std::vector<box_helper::Element> elements;
     elements.reserve(line.blocks.size());
     for (auto* block : line.blocks) {
@@ -110,19 +116,24 @@ void SetX(Global& global, std::vector<Line> lines) {
 
     int x = 0;
     for (size_t i = 0; i < line.blocks.size(); ++i) {
-      line.blocks[i]->dim_x = elements[i].size;
       line.blocks[i]->x = x;
+      line.blocks[i]->dim_x = elements[i].size;
       x += elements[i].size;
       x += global.config.gap_x;
     }
   }
+
+  for (auto& line : global.lines) {
+    line.x = 0;
+    line.dim_x = global.size_x;
+  }
 }
 
 // NOLINTNEXTLINE(readability-function-cognitive-complexity)
-void SetY(Global& g, std::vector<Line> lines) {
+void SetY(Global& g) {
   std::vector<box_helper::Element> elements;
-  elements.reserve(lines.size());
-  for (auto& line : lines) {
+  elements.reserve(g.lines.size());
+  for (auto& line : g.lines) {
     box_helper::Element element;
     element.flex_shrink = line.blocks.front()->flex_shrink_y;
     element.flex_grow = line.blocks.front()->flex_grow_y;
@@ -202,9 +213,9 @@ void SetY(Global& g, std::vector<Line> lines) {
   }
 
   // [Align items]
-  for (size_t i = 0; i < lines.size(); ++i) {
+  for (size_t i = 0; i < g.lines.size(); ++i) {
     auto& element = elements[i];
-    for (auto* block : lines[i].blocks) {
+    for (auto* block : g.lines[i].blocks) {
       const bool stretch =
           block->flex_grow_y != 0 ||
           g.config.align_content == FlexboxConfig::AlignContent::Stretch;
@@ -237,10 +248,16 @@ void SetY(Global& g, std::vector<Line> lines) {
       }
     }
   }
+
+  ys.push_back(g.size_y);
+  for (size_t i = 0; i < g.lines.size(); ++i) {
+    g.lines[i].y = ys[i];
+    g.lines[i].dim_y = ys[i + 1] - ys[i];
+  }
 }
 
-void JustifyContent(Global& g, std::vector<Line> lines) {
-  for (auto& line : lines) {
+void JustifyContent(Global& g) {
+  for (auto& line : g.lines) {
     Block* last = line.blocks.back();
     int remaining_space = g.size_x - last->x - last->dim_x;
     switch (g.config.justify_content) {
@@ -315,38 +332,36 @@ void Compute2(Global& global) {
 
 void Compute3(Global& global) {
   // Step 1: Lay out every elements into rows:
-  std::vector<Line> lines;
   {
     Line line;
     int x = 0;
-    line.blocks.reserve(global.blocks.size());
     for (auto& block : global.blocks) {
       // Does it fit the end of the row?
       // No? Then we need to start a new one:
       if (x + block.min_size_x > global.size_x) {
         x = 0;
         if (!line.blocks.empty()) {
-          lines.push_back(std::move(line));
+          global.lines.push_back(std::move(line));
         }
         line = Line();
       }
 
-      block.line = static_cast<int>(lines.size());
+      block.line = static_cast<int>(global.lines.size());
       block.line_position = static_cast<int>(line.blocks.size());
       line.blocks.push_back(&block);
       x += block.min_size_x + global.config.gap_x;
     }
     if (!line.blocks.empty()) {
-      lines.push_back(std::move(line));
+      global.lines.push_back(std::move(line));
     }
   }
 
   // Step 2: Set positions on the X axis.
-  SetX(global, lines);
-  JustifyContent(global, lines);  // Distribute remaining space.
+  SetX(global);
+  JustifyContent(global);  // Distribute remaining space.
 
   // Step 3: Set positions on the Y axis.
-  SetY(global, lines);
+  SetY(global);
 }
 
 }  // namespace

src/ftxui/dom/flexbox_helper.hpp

@@ -9,6 +9,7 @@
 
 namespace ftxui::flexbox_helper {
 
+// A block is a rectangle in the flexbox.
 struct Block {
   // Input:
   int min_size_x = 0;
@@ -28,8 +29,18 @@ struct Block {
   bool overflow = false;
 };
 
+// A line is a row of blocks.
+struct Line {
+  std::vector<Block*> blocks;
+  int x = 0;
+  int y = 0;
+  int dim_x = 0;
+  int dim_y = 0;
+};
+
 struct Global {
   std::vector<Block> blocks;
+  std::vector<Line> lines;
   FlexboxConfig config;
   int size_x;
   int size_y;

src/ftxui/dom/focus.cpp

@@ -36,13 +36,12 @@ Decorator focusPositionRelative(float x, float y) {
 
     void ComputeRequirement() override {
       NodeDecorator::ComputeRequirement();
-      requirement_.selection = Requirement::Selection::NORMAL;
-
-      Box& box = requirement_.selected_box;
-      box.x_min = int(float(requirement_.min_x) * x_);
-      box.y_min = int(float(requirement_.min_y) * y_);
-      box.x_max = int(float(requirement_.min_x) * x_);
-      box.y_max = int(float(requirement_.min_y) * y_);
+      requirement_.focused.enabled = true;
+      requirement_.focused.node = this;
+      requirement_.focused.box.x_min = int(float(requirement_.min_x) * x_);
+      requirement_.focused.box.y_min = int(float(requirement_.min_y) * y_);
+      requirement_.focused.box.x_max = int(float(requirement_.min_x) * x_);
+      requirement_.focused.box.y_max = int(float(requirement_.min_y) * y_);
     }
 
    private:
@@ -75,9 +74,9 @@ Decorator focusPosition(int x, int y) {
 
     void ComputeRequirement() override {
       NodeDecorator::ComputeRequirement();
-      requirement_.selection = Requirement::Selection::NORMAL;
+      requirement_.focused.enabled = false;
 
-      Box& box = requirement_.selected_box;
+      Box& box = requirement_.focused.box;
       box.x_min = x_;
       box.y_min = y_;
       box.x_max = x_;

src/ftxui/dom/frame.cpp

@@ -6,28 +6,28 @@
 #include <utility>    // for move
 
 #include "ftxui/dom/elements.hpp"  // for Element, unpack, Elements, focus, frame, select, xframe, yframe
-#include "ftxui/dom/node.hpp"  // for Node, Elements
-#include "ftxui/dom/requirement.hpp"  // for Requirement, Requirement::FOCUSED, Requirement::SELECTED
-#include "ftxui/screen/box.hpp"      // for Box
-#include "ftxui/screen/screen.hpp"   // for Screen, Screen::Cursor
-#include "ftxui/util/autoreset.hpp"  // for AutoReset
+#include "ftxui/dom/node.hpp"         // for Node, Elements
+#include "ftxui/dom/requirement.hpp"  // for Requirement
+#include "ftxui/screen/box.hpp"       // for Box
+#include "ftxui/screen/screen.hpp"    // for Screen, Screen::Cursor
+#include "ftxui/util/autoreset.hpp"   // for AutoReset
 
 namespace ftxui {
 
 namespace {
-class Select : public Node {
+class Focus : public Node {
  public:
-  explicit Select(Elements children) : Node(std::move(children)) {}
+  explicit Focus(Elements children) : Node(std::move(children)) {}
 
   void ComputeRequirement() override {
     Node::ComputeRequirement();
     requirement_ = children_[0]->requirement();
-    auto& selected_box = requirement_.selected_box;
-    selected_box.x_min = 0;
-    selected_box.y_min = 0;
-    selected_box.x_max = requirement_.min_x - 1;
-    selected_box.y_max = requirement_.min_y - 1;
-    requirement_.selection = Requirement::SELECTED;
+    requirement_.focused.enabled = true;
+    requirement_.focused.node = this;
+    requirement_.focused.box.x_min = 0;
+    requirement_.focused.box.y_min = 0;
+    requirement_.focused.box.x_max = requirement_.min_x - 1;
+    requirement_.focused.box.y_max = requirement_.min_y - 1;
   }
 
   void SetBox(Box box) override {
@@ -36,65 +36,21 @@ class Select : public Node {
   }
 };
 
-class Focus : public Select {
- public:
-  using Select::Select;
-
-  void ComputeRequirement() override {
-    Select::ComputeRequirement();
-    requirement_.selection = Requirement::FOCUSED;
-  }
-
-  void Render(Screen& screen) override {
-    Select::Render(screen);
-
-    // Setting the cursor to the right position allow folks using CJK (China,
-    // Japanese, Korean, ...) characters to see their [input method editor]
-    // displayed at the right location. See [issue].
-    //
-    // [input method editor]:
-    // https://en.wikipedia.org/wiki/Input_method
-    //
-    // [issue]:
-    // https://github.com/ArthurSonzogni/FTXUI/issues/2#issuecomment-505282355
-    //
-    // Unfortunately, Microsoft terminal do not handle properly hidding the
-    // cursor. Instead the character under the cursor is hidden, which is a big
-    // problem. As a result, we can't enable setting cursor to the right
-    // location. It will be displayed at the bottom right corner.
-    // See:
-    // https://github.com/microsoft/terminal/issues/1203
-    // https://github.com/microsoft/terminal/issues/3093
-#if !defined(FTXUI_MICROSOFT_TERMINAL_FALLBACK)
-    screen.SetCursor(Screen::Cursor{
-        box_.x_min,
-        box_.y_min,
-        Screen::Cursor::Shape::Hidden,
-    });
-#endif
-  }
-};
-
 class Frame : public Node {
  public:
   Frame(Elements children, bool x_frame, bool y_frame)
       : Node(std::move(children)), x_frame_(x_frame), y_frame_(y_frame) {}
 
-  void ComputeRequirement() override {
-    Node::ComputeRequirement();
-    requirement_ = children_[0]->requirement();
-  }
-
   void SetBox(Box box) override {
     Node::SetBox(box);
-    auto& selected_box = requirement_.selected_box;
+    auto& focused_box = requirement_.focused.box;
     Box children_box = box;
 
     if (x_frame_) {
       const int external_dimx = box.x_max - box.x_min;
       const int internal_dimx = std::max(requirement_.min_x, external_dimx);
-      const int focused_dimx = selected_box.x_max - selected_box.x_min;
-      int dx = selected_box.x_min - external_dimx / 2 + focused_dimx / 2;
+      const int focused_dimx = focused_box.x_max - focused_box.x_min;
+      int dx = focused_box.x_min - external_dimx / 2 + focused_dimx / 2;
       dx = std::max(0, std::min(internal_dimx - external_dimx - 1, dx));
       children_box.x_min = box.x_min - dx;
       children_box.x_max = box.x_min + internal_dimx - dx;
@@ -103,8 +59,8 @@ class Frame : public Node {
     if (y_frame_) {
       const int external_dimy = box.y_max - box.y_min;
       const int internal_dimy = std::max(requirement_.min_y, external_dimy);
-      const int focused_dimy = selected_box.y_max - selected_box.y_min;
-      int dy = selected_box.y_min - external_dimy / 2 + focused_dimy / 2;
+      const int focused_dimy = focused_box.y_max - focused_box.y_min;
+      int dy = focused_box.y_min - external_dimy / 2 + focused_dimy / 2;
       dy = std::max(0, std::min(internal_dimy - external_dimy - 1, dy));
       children_box.y_min = box.y_min - dy;
       children_box.y_max = box.y_min + internal_dimy - dy;
@@ -130,33 +86,29 @@ class FocusCursor : public Focus {
       : Focus(std::move(children)), shape_(shape) {}
 
  private:
-  void Render(Screen& screen) override {
-    Select::Render(screen);  // NOLINT
-    screen.SetCursor(Screen::Cursor{
-        box_.x_min,
-        box_.y_min,
-        shape_,
-    });
+  void ComputeRequirement() override {
+    Focus::ComputeRequirement();  // NOLINT
+    requirement_.focused.cursor_shape = shape_;
   }
   Screen::Cursor::Shape shape_;
 };
 
 }  // namespace
 
-/// @brief Set the `child` to be the one selected among its siblings.
-/// @param child The element to be selected.
-/// @ingroup dom
-Element select(Element child) {
-  return std::make_shared<Select>(unpack(std::move(child)));
-}
-
-/// @brief Set the `child` to be the one in focus globally.
+/// @brief Set the `child` to be the one focused among its siblings.
 /// @param child The element to be focused.
 /// @ingroup dom
 Element focus(Element child) {
   return std::make_shared<Focus>(unpack(std::move(child)));
 }
 
+/// This is deprecated. Use `focus` instead.
+/// @brief Set the `child` to be the one focused among its siblings.
+/// @param child The element to be focused.
+Element select(Element child) {
+  return focus(std::move(child));
+}
+
 /// @brief Allow an element to be displayed inside a 'virtual' area. It size can
 /// be larger than its container. In this case only a smaller portion is
 /// displayed. The view is scrollable to make the focused element visible.

src/ftxui/dom/gridbox.cpp

@@ -49,13 +49,7 @@ class GridBox : public Node {
   }
 
   void ComputeRequirement() override {
-    requirement_.min_x = 0;
-    requirement_.min_y = 0;
-    requirement_.flex_grow_x = 0;
-    requirement_.flex_grow_y = 0;
-    requirement_.flex_shrink_x = 0;
-    requirement_.flex_shrink_y = 0;
-
+    requirement_ = Requirement{};
     for (auto& line : lines_) {
       for (auto& cell : line) {
         cell->ComputeRequirement();
@@ -75,19 +69,15 @@ class GridBox : public Node {
     requirement_.min_x = Integrate(size_x);
     requirement_.min_y = Integrate(size_y);
 
-    // Forward the selected/focused child state:
-    requirement_.selection = Requirement::NORMAL;
+    // Forward the focused/focused child state:
     for (int x = 0; x < x_size; ++x) {
       for (int y = 0; y < y_size; ++y) {
-        if (requirement_.selection >= lines_[y][x]->requirement().selection) {
+        if (requirement_.focused.enabled ||
+            !lines_[y][x]->requirement().focused.enabled) {
           continue;
         }
-        requirement_.selection = lines_[y][x]->requirement().selection;
-        requirement_.selected_box = lines_[y][x]->requirement().selected_box;
-        requirement_.selected_box.x_min += size_x[x];
-        requirement_.selected_box.x_max += size_x[x];
-        requirement_.selected_box.y_min += size_y[y];
-        requirement_.selected_box.y_max += size_y[y];
+        requirement_.focused = lines_[y][x]->requirement().focused;
+        requirement_.focused.box.Shift(size_x[x], size_y[y]);
       }
     }
   }

src/ftxui/dom/gridbox_test.cpp

@@ -7,7 +7,7 @@
 #include <string>     // for allocator, basic_string, string
 #include <vector>     // for vector
 
-#include "ftxui/dom/elements.hpp"  // for text, operator|, Element, flex, Elements, flex_grow, flex_shrink, vtext, gridbox, vbox, focus, operator|=, border, frame
+#include "ftxui/dom/elements.hpp"  // for text, operator|, Element, flex, Elements, flex_grow, flex_shrink, vtext, gridbox, vbox, select, operator|=, border, frame
 #include "ftxui/dom/node.hpp"      // for Render
 #include "ftxui/screen/screen.hpp"  // for Screen
 

src/ftxui/dom/hbox.cpp

@@ -11,8 +11,8 @@
 #include "ftxui/dom/elements.hpp"     // for Element, Elements, hbox
 #include "ftxui/dom/node.hpp"         // for Node, Elements
 #include "ftxui/dom/requirement.hpp"  // for Requirement
+#include "ftxui/dom/selection.hpp"    // for Selection
 #include "ftxui/screen/box.hpp"       // for Box
-
 namespace ftxui {
 
 namespace {
@@ -20,22 +20,20 @@ class HBox : public Node {
  public:
   explicit HBox(Elements children) : Node(std::move(children)) {}
 
+ private:
   void ComputeRequirement() override {
-    requirement_.min_x = 0;
-    requirement_.min_y = 0;
-    requirement_.flex_grow_x = 0;
-    requirement_.flex_grow_y = 0;
-    requirement_.flex_shrink_x = 0;
-    requirement_.flex_shrink_y = 0;
-    requirement_.selection = Requirement::NORMAL;
+    requirement_ = Requirement{};
+
     for (auto& child : children_) {
       child->ComputeRequirement();
-      if (requirement_.selection < child->requirement().selection) {
-        requirement_.selection = child->requirement().selection;
-        requirement_.selected_box = child->requirement().selected_box;
-        requirement_.selected_box.x_min += requirement_.min_x;
-        requirement_.selected_box.x_max += requirement_.min_x;
+
+      // Propagate the focused requirement.
+      if (requirement_.focused.Prefer(child->requirement().focused)) {
+        requirement_.focused = child->requirement().focused;
+        requirement_.focused.box.Shift(requirement_.min_x, 0);
       }
+
+      // Extend the min_x and min_y to contain all the children
       requirement_.min_x += child->requirement().min_x;
       requirement_.min_y =
           std::max(requirement_.min_y, child->requirement().min_y);
@@ -64,6 +62,19 @@ class HBox : public Node {
       x = box.x_max + 1;
     }
   }
+
+  void Select(Selection& selection) override {
+    // If this Node box_ doesn't intersect with the selection, then no
+    // selection.
+    if (Box::Intersection(selection.GetBox(), box_).IsEmpty()) {
+      return;
+    }
+
+    Selection selection_saturated = selection.SaturateHorizontal(box_);
+    for (auto& child : children_) {
+      child->Select(selection_saturated);
+    }
+  }
 };
 
 }  // namespace

src/ftxui/dom/italic.cpp

@@ -0,0 +1,35 @@
+// Copyright 2025 Arthur Sonzogni. All rights reserved.
+// Use of this source code is governed by the MIT license that can be found in
+// the LICENSE file.
+#include <memory>   // for make_shared
+#include <utility>  // for move
+
+#include "ftxui/dom/elements.hpp"        // for Element, underlinedDouble
+#include "ftxui/dom/node.hpp"            // for Node
+#include "ftxui/dom/node_decorator.hpp"  // for NodeDecorator
+#include "ftxui/screen/box.hpp"          // for Box
+#include "ftxui/screen/screen.hpp"       // for Pixel, Screen
+
+namespace ftxui {
+
+/// @brief Apply a underlinedDouble to text.
+/// @ingroup dom
+Element italic(Element child) {
+  class Impl : public NodeDecorator {
+   public:
+    using NodeDecorator::NodeDecorator;
+
+    void Render(Screen& screen) override {
+      for (int y = box_.y_min; y <= box_.y_max; ++y) {
+        for (int x = box_.x_min; x <= box_.x_max; ++x) {
+          screen.PixelAt(x, y).italic = true;
+        }
+      }
+      Node::Render(screen);
+    }
+  };
+
+  return std::make_shared<Impl>(std::move(child));
+}
+
+}  // namespace ftxui

src/ftxui/dom/italic_test.cpp

@@ -0,0 +1,22 @@
+// Copyright 2025 Arthur Sonzogni. All rights reserved.
+// Use of this source code is governed by the MIT license that can be found in
+// the LICENSE file.
+#include <string>  // for allocator, string
+
+#include "ftxui/dom/elements.hpp"   // for operator|, text, bold, Element
+#include "ftxui/dom/node.hpp"       // for Render
+#include "ftxui/screen/screen.hpp"  // for Screen, Pixel
+#include "gtest/gtest.h"  // for Test, AssertionResult, EXPECT_TRUE, Message, TEST, TestPartResult
+
+// NOLINTBEGIN
+namespace ftxui {
+
+TEST(ItalicTest, Basic) {
+  auto element = text("text") | italic;
+  Screen screen(5, 1);
+  Render(screen, element);
+  EXPECT_TRUE(screen.PixelAt(0, 0).italic);
+}
+
+}  // namespace ftxui
+// NOLINTEND

src/ftxui/dom/linear_gradient.cpp

@@ -97,7 +97,11 @@ Color Interpolate(const LinearGradientNormalized& gradient, float t) {
   // Find the right color in the gradient's stops.
   size_t i = 1;
   while (true) {
-    if (i > gradient.positions.size()) {
+    // Note that `t` might be slightly greater than 1.0 due to floating point
+    // precision. This is why we need to handle the case where `t` is greater
+    // than the last stop's position.
+    // See https://github.com/ArthurSonzogni/FTXUI/issues/998
+    if (i >= gradient.positions.size()) {
       const float half = 0.5F;
       return Color::Interpolate(half, gradient.colors.back(),
                                 gradient.colors.back());

src/ftxui/dom/node.cpp

@@ -2,9 +2,12 @@
 // Use of this source code is governed by the MIT license that can be found in
 // the LICENSE file.
 #include <ftxui/screen/box.hpp>  // for Box
-#include <utility>               // for move
+#include <string>
+#include <utility>  // for move
 
+#include <cstddef>
 #include "ftxui/dom/node.hpp"
+#include "ftxui/dom/selection.hpp"  // for Selection
 #include "ftxui/screen/screen.hpp"  // for Screen
 
 namespace ftxui {
@@ -16,9 +19,23 @@ Node::~Node() = default;
 /// @brief Compute how much space an elements needs.
 /// @ingroup dom
 void Node::ComputeRequirement() {
+  if (children_.empty()) {
+    return;
+  }
   for (auto& child : children_) {
     child->ComputeRequirement();
   }
+
+  // By default, the requirement is the one of the first child.
+  requirement_ = children_[0]->requirement();
+
+  // Propagate the focused requirement.
+  for (size_t i = 1; i < children_.size(); ++i) {
+    if (!requirement_.focused.enabled &&
+        children_[i]->requirement().focused.enabled) {
+      requirement_.focused = children_[i]->requirement().focused;
+    }
+  }
 }
 
 /// @brief Assign a position and a dimension to an element for drawing.
@@ -27,6 +44,20 @@ void Node::SetBox(Box box) {
   box_ = box;
 }
 
+/// @brief Compute the selection of an element.
+/// @ingroup dom
+void Node::Select(Selection& selection) {
+  // If this Node box_ doesn't intersect with the selection, then no selection.
+  if (Box::Intersection(selection.GetBox(), box_).IsEmpty()) {
+    return;
+  }
+
+  // By default we defer the selection to the children.
+  for (auto& child : children_) {
+    child->Select(selection);
+  }
+}
+
 /// @brief Display an element on a ftxui::Screen.
 /// @ingroup dom
 void Node::Render(Screen& screen) {
@@ -42,15 +73,31 @@ void Node::Check(Status* status) {
   status->need_iteration |= (status->iteration == 0);
 }
 
+std::string Node::GetSelectedContent(Selection& selection) {
+  std::string content;
+
+  for (auto& child : children_) {
+    content += child->GetSelectedContent(selection);
+  }
+
+  return content;
+}
+
 /// @brief Display an element on a ftxui::Screen.
 /// @ingroup dom
 void Render(Screen& screen, const Element& element) {
-  Render(screen, element.get());
+  Selection selection;
+  Render(screen, element.get(), selection);
 }
 
 /// @brief Display an element on a ftxui::Screen.
 /// @ingroup dom
 void Render(Screen& screen, Node* node) {
+  Selection selection;
+  Render(screen, node, selection);
+}
+
+void Render(Screen& screen, Node* node, Selection& selection) {
   Box box;
   box.x_min = 0;
   box.y_min = 0;
@@ -73,12 +120,85 @@ void Render(Screen& screen, Node* node) {
     node->Check(&status);
   }
 
-  // Step 3: Draw the element.
+  // Step 3: Selection
+  if (!selection.IsEmpty()) {
+    node->Select(selection);
+  }
+
+  if (node->requirement().focused.enabled
+#if defined(FTXUI_MICROSOFT_TERMINAL_FALLBACK)
+      // Setting the cursor to the right position allow folks using CJK (China,
+      // Japanese, Korean, ...) characters to see their [input method editor]
+      // displayed at the right location. See [issue].
+      //
+      // [input method editor]:
+      // https://en.wikipedia.org/wiki/Input_method
+      //
+      // [issue]:
+      // https://github.com/ArthurSonzogni/FTXUI/issues/2#issuecomment-505282355
+      //
+      // Unfortunately, Microsoft terminal do not handle properly hiding the
+      // cursor. Instead the character under the cursor is hidden, which is a
+      // big problem. As a result, we can't enable setting cursor to the right
+      // location. It will be displayed at the bottom right corner.
+      // See:
+      // https://github.com/microsoft/terminal/issues/1203
+      // https://github.com/microsoft/terminal/issues/3093
+      &&
+      node->requirement().focused.cursor_shape != Screen::Cursor::Shape::Hidden
+#endif
+  ) {
+    screen.SetCursor(Screen::Cursor{
+        node->requirement().focused.node->box_.x_max,
+        node->requirement().focused.node->box_.y_max,
+        node->requirement().focused.cursor_shape,
+    });
+  } else {
+    screen.SetCursor(Screen::Cursor{
+        screen.dimx() - 1,
+        screen.dimy() - 1,
+        Screen::Cursor::Shape::Hidden,
+    });
+  }
+
+  // Step 4: Draw the element.
   screen.stencil = box;
   node->Render(screen);
 
-  // Step 4: Apply shaders
+  // Step 5: Apply shaders
   screen.ApplyShader();
 }
 
+std::string GetNodeSelectedContent(Screen& screen,
+                                   Node* node,
+                                   Selection& selection) {
+  Box box;
+  box.x_min = 0;
+  box.y_min = 0;
+  box.x_max = screen.dimx() - 1;
+  box.y_max = screen.dimy() - 1;
+
+  Node::Status status;
+  node->Check(&status);
+  const int max_iterations = 20;
+  while (status.need_iteration && status.iteration < max_iterations) {
+    // Step 1: Find what dimension this elements wants to be.
+    node->ComputeRequirement();
+
+    // Step 2: Assign a dimension to the element.
+    node->SetBox(box);
+
+    // Check if the element needs another iteration of the layout algorithm.
+    status.need_iteration = false;
+    status.iteration++;
+    node->Check(&status);
+  }
+
+  // Step 3: Selection
+  node->Select(selection);
+
+  // Step 4: get the selected content.
+  return node->GetSelectedContent(selection);
+}
+
 }  // namespace ftxui