Initialize

ftxui/examples/dom/CMakeLists.txt

@@ -0,0 +1,38 @@
+set(DIRECTORY_LIB dom)
+
+example(border)
+example(border_colored)
+example(border_style)
+example(canvas)
+example(color_gallery)
+example(color_info_palette256)
+example(color_truecolor_HSV)
+example(color_truecolor_RGB)
+example(dbox)
+example(gauge)
+example(gauge_direction)
+example(graph)
+example(gridbox)
+example(hflow)
+example(html_like)
+example(linear_gradient)
+example(package_manager)
+example(paragraph)
+example(separator)
+example(separator_style)
+example(size)
+example(spinner)
+example(style_blink)
+example(style_bold)
+example(style_color)
+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)
+example(table)
+example(vbox_hbox)
+example(vflow)

ftxui/examples/dom/border.cpp

@@ -0,0 +1,38 @@
+// 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 <stdlib.h>                // for EXIT_SUCCESS
+#include <ftxui/dom/elements.hpp>  // for text, operator|, vbox, border, Element, Fit, hbox
+#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({
+          vbox({
+              text("Line 1"),
+              text("Line 2"),
+              text("Line 3"),
+          }) | border,
+
+          vbox({
+              text("Line 4"),
+              text("Line 5"),
+              text("Line 6"),
+          }) | border,
+
+          vbox({
+              text("Line 7"),
+              text("Line 8"),
+              text("Line 9"),
+          }) | border,
+      });
+  auto screen = Screen::Create(Dimension::Full(), Dimension::Fit(document));
+  Render(screen, document);
+  screen.Print();
+  return EXIT_SUCCESS;
+}

ftxui/examples/dom/border_colored.cpp

@@ -0,0 +1,39 @@
+// 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 <ftxui/dom/elements.hpp>  // for operator|, text, Element, Fit, borderDouble, borderHeavy, borderLight, borderRounded, vbox
+#include <ftxui/screen/screen.hpp>  // for Screen
+#include <iostream>                 // for endl, cout, ostream
+#include <memory>                   // for allocator
+
+#include "ftxui/dom/node.hpp"      // for Render
+#include "ftxui/screen/color.hpp"  // for ftxui
+
+int main() {
+  using namespace ftxui;
+
+  auto make_boxed = [] {
+    return vbox({
+        text("borderLight") | borderStyled(LIGHT, Color::Red),
+        text("borderDashed") | borderStyled(DASHED, Color::Green),
+        text("borderHeavy") | borderStyled(HEAVY, Color::Blue),
+        text("borderDouble") | borderStyled(DOUBLE, Color::Yellow),
+        text("borderRounded") | borderStyled(ROUNDED, Color::Cyan),
+    });
+  };
+
+  auto document = hbox({
+                      make_boxed(),
+                      separator() | color(Color::Red),
+                      make_boxed(),
+                      separator() | color(Color::Red),
+                      make_boxed(),
+                  }) |
+                  borderStyled(ROUNDED, Color::Red);
+
+  auto screen =
+      Screen::Create(Dimension::Fit(document), Dimension::Fit(document));
+  Render(screen, document);
+  screen.Print();
+  std::cout << std::endl;
+}

ftxui/examples/dom/border_style.cpp

@@ -0,0 +1,28 @@
+// 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 <ftxui/dom/elements.hpp>  // for operator|, text, Element, Fit, borderDouble, borderHeavy, borderLight, borderRounded, vbox
+#include <ftxui/screen/screen.hpp>  // for Screen
+#include <iostream>                 // for endl, cout, ostream
+#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 = vbox({
+      text("borderLight") | borderLight,
+      text("borderDashed") | borderDashed,
+      text("borderHeavy") | borderHeavy,
+      text("borderDouble") | borderDouble,
+      text("borderRounded") | borderRounded,
+  });
+
+  auto screen =
+      Screen::Create(Dimension::Fit(document), Dimension::Fit(document));
+  Render(screen, document);
+  screen.Print();
+  std::cout << std::endl;
+}

ftxui/examples/dom/canvas.cpp

@@ -0,0 +1,50 @@
+// 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 <stdio.h>                 // for getchar
+#include <cmath>                   // for cos
+#include <ftxui/dom/elements.hpp>  // for Fit, canvas, operator|, border, Element
+#include <ftxui/screen/screen.hpp>  // for Pixel, Screen
+#include <vector>                   // for vector, allocator
+
+#include "ftxui/dom/canvas.hpp"  // for Canvas
+#include "ftxui/dom/node.hpp"    // for Render
+#include "ftxui/screen/color.hpp"  // for Color, Color::Red, Color::Blue, Color::Green, ftxui
+
+int main() {
+  using namespace ftxui;
+
+  auto c = Canvas(100, 100);
+
+  c.DrawText(0, 0, "This is a canvas", [](Pixel& p) {
+    p.foreground_color = Color::Red;
+    p.underlined = true;
+  });
+
+  // Triangle:
+  c.DrawPointLine(10, 10, 80, 10, Color::Red);
+  c.DrawPointLine(80, 10, 80, 40, Color::Blue);
+  c.DrawPointLine(80, 40, 10, 10, Color::Green);
+
+  // Circle, not filled and filled:
+  c.DrawPointCircle(30, 50, 20);
+  c.DrawPointCircleFilled(40, 40, 10);
+
+  // Plot a function:
+  std::vector<int> ys(100);
+  for (int x = 0; x < 100; x++) {
+    ys[x] = int(80 + 20 * cos(x * 0.2));
+  }
+  for (int x = 0; x < 99; x++) {
+    c.DrawPointLine(x, ys[x], x + 1, ys[x + 1], Color::Red);
+  }
+
+  auto document = canvas(&c) | border;
+
+  auto screen = Screen::Create(Dimension::Fit(document));
+  Render(screen, document);
+  screen.Print();
+  getchar();
+
+  return 0;
+}

ftxui/examples/dom/color_gallery.cpp

@@ -0,0 +1,141 @@
+// 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 <ftxui/screen/color_info.hpp>  // for ColorInfo
+#include <ftxui/screen/screen.hpp>      // for Full, Screen
+#include <ftxui/screen/terminal.hpp>  // for ColorSupport, Color, Palette16, Palette256, TrueColor
+#include <memory>                     // for allocator, shared_ptr
+#include <utility>                    // for move
+#include <vector>                     // for vector
+
+#include "ftxui/dom/elements.hpp"  // for text, bgcolor, color, vbox, hbox, separator, operator|, Elements, Element, Fit, border
+#include "ftxui/dom/node.hpp"      // for Render
+#include "ftxui/screen/color.hpp"  // for Color, Color::Black, Color::Blue, Color::BlueLight, Color::Cyan, Color::CyanLight, Color::Default, Color::GrayDark, Color::GrayLight, Color::Green, Color::GreenLight, Color::Magenta, Color::MagentaLight, Color::Red, Color::RedLight, Color::White, Color::Yellow, Color::YellowLight, Color::Palette256, ftxui
+
+using namespace ftxui;
+#include "./color_info_sorted_2d.ipp"  // for ColorInfoSorted2D
+
+int main() {
+  // clang-format off
+  auto basic_color_display =
+    vbox(
+      text("16 color palette:"),
+      separator(),
+      hbox(
+        vbox(
+          color(Color::Default, text("Default")),
+          color(Color::Black, text("Black")),
+          color(Color::GrayDark, text("GrayDark")),
+          color(Color::GrayLight, text("GrayLight")),
+          color(Color::White, text("White")),
+          color(Color::Blue, text("Blue")),
+          color(Color::BlueLight, text("BlueLight")),
+          color(Color::Cyan, text("Cyan")),
+          color(Color::CyanLight, text("CyanLight")),
+          color(Color::Green, text("Green")),
+          color(Color::GreenLight, text("GreenLight")),
+          color(Color::Magenta, text("Magenta")),
+          color(Color::MagentaLight, text("MagentaLight")),
+          color(Color::Red, text("Red")),
+          color(Color::RedLight, text("RedLight")),
+          color(Color::Yellow, text("Yellow")),
+          color(Color::YellowLight, text("YellowLight"))
+        ),
+        vbox(
+          bgcolor(Color::Default, text("Default")),
+          bgcolor(Color::Black, text("Black")),
+          bgcolor(Color::GrayDark, text("GrayDark")),
+          bgcolor(Color::GrayLight, text("GrayLight")),
+          bgcolor(Color::White, text("White")),
+          bgcolor(Color::Blue, text("Blue")),
+          bgcolor(Color::BlueLight, text("BlueLight")),
+          bgcolor(Color::Cyan, text("Cyan")),
+          bgcolor(Color::CyanLight, text("CyanLight")),
+          bgcolor(Color::Green, text("Green")),
+          bgcolor(Color::GreenLight, text("GreenLight")),
+          bgcolor(Color::Magenta, text("Magenta")),
+          bgcolor(Color::MagentaLight, text("MagentaLight")),
+          bgcolor(Color::Red, text("Red")),
+          bgcolor(Color::RedLight, text("RedLight")),
+          bgcolor(Color::Yellow, text("Yellow")),
+          bgcolor(Color::YellowLight, text("YellowLight"))
+        )
+      )
+    );
+
+  // clang-format on
+  auto palette_256_color_display = text("256 colors palette:");
+  {
+    std::vector<std::vector<ColorInfo>> info_columns = ColorInfoSorted2D();
+    Elements columns;
+    for (auto& column : info_columns) {
+      Elements column_elements;
+      for (auto& it : column) {
+        column_elements.push_back(
+            text("   ") | bgcolor(Color(Color::Palette256(it.index_256))));
+      }
+      columns.push_back(hbox(std::move(column_elements)));
+    }
+    palette_256_color_display = vbox({
+        palette_256_color_display,
+        separator(),
+        vbox(columns),
+    });
+  }
+
+  // True color display.
+  auto true_color_display = text("TrueColors: 24bits:");
+  {
+    const int max_value = 255;
+    const int value_increment = 8;
+    const int hue_increment = 6;
+    int saturation = max_value;
+    Elements array;
+    for (int value = 0; value < max_value; value += 2 * value_increment) {
+      Elements line;
+      for (int hue = 0; hue < max_value; hue += hue_increment) {
+        line.push_back(
+            text("▀")                                    //
+            | color(Color::HSV(hue, saturation, value))  //
+            | bgcolor(Color::HSV(hue, saturation, value + value_increment)));
+      }
+      array.push_back(hbox(std::move(line)));
+    }
+    true_color_display = vbox({
+        true_color_display,
+        separator(),
+        vbox(std::move(array)),
+    });
+  }
+
+  auto terminal_info =
+      vbox({
+          Terminal::ColorSupport() >= Terminal::Color::Palette16
+              ? text(" 16 color palette support : Yes")
+              : text(" 16 color palette support : No"),
+          Terminal::ColorSupport() >= Terminal::Color::Palette256
+              ? text("256 color palette support : Yes")
+              : text("256 color palette support : No"),
+          Terminal::ColorSupport() >= Terminal::Color::TrueColor
+              ? text("       True color support : Yes")
+              : text("       True color support : No"),
+      }) |
+      border;
+
+  auto document = vbox({hbox({
+                            basic_color_display,
+                            text(" "),
+                            palette_256_color_display,
+                            text(" "),
+                            true_color_display,
+                        }),
+                        terminal_info});
+  // clang-format on
+
+  auto screen = Screen::Create(Dimension::Full(), Dimension::Fit(document));
+  Render(screen, document);
+
+  screen.Print();
+
+  return 0;
+}

ftxui/examples/dom/color_info_palette256.cpp

@@ -0,0 +1,39 @@
+// 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 <ftxui/dom/elements.hpp>  // for text, bgcolor, hbox, operator|, Elements, Fit, vbox, Element
+#include <ftxui/screen/color_info.hpp>  // for ColorInfo
+#include <ftxui/screen/screen.hpp>      // for Full, Screen
+#include <utility>                      // for move
+#include <vector>                       // for vector, allocator
+
+#include "ftxui/dom/node.hpp"      // for Render
+#include "ftxui/screen/color.hpp"  // for Color, Color::Palette256, ftxui
+
+using namespace ftxui;
+#include "./color_info_sorted_2d.ipp"  // for ColorInfoSorted2D
+
+int main() {
+  std::vector<std::vector<ColorInfo>> info_columns = ColorInfoSorted2D();
+
+  // Draw every columns
+  Elements columns_elements;
+  for (auto& column : info_columns) {
+    Elements column_elements;
+    for (auto& it : column) {
+      column_elements.push_back(hbox({
+          text("     ") | bgcolor(Color(Color::Palette256(it.index_256))),
+          text(it.name),
+      }));
+    }
+    columns_elements.push_back(vbox(std::move(column_elements)));
+  }
+  auto document = hbox(std::move(columns_elements));
+
+  auto screen = Screen::Create(Dimension::Full(), Dimension::Fit(document));
+  Render(screen, document);
+
+  screen.Print();
+
+  return 0;
+}

ftxui/examples/dom/color_info_sorted_2d.ipp

@@ -0,0 +1,53 @@
+#include <algorithm>
+#include <cmath>
+#include <ftxui/screen/color_info.hpp>  // for ftxui::ColorInfo
+
+std::vector<std::vector<ftxui::ColorInfo>> ColorInfoSorted2D() {
+  // Acquire the color information for the palette256.
+  std::vector<ftxui::ColorInfo> info_gray;
+  std::vector<ftxui::ColorInfo> info_color;
+  for (int i = 16; i < 256; ++i) {
+    ftxui::ColorInfo info = GetColorInfo(ftxui::Color::Palette256(i));
+    if (info.saturation == 0)
+      info_gray.push_back(info);
+    else
+      info_color.push_back(info);
+  }
+
+  // Sort info_color by hue.
+  std::sort(
+      info_color.begin(), info_color.end(),
+      [](const ftxui::ColorInfo& A, const ftxui::ColorInfo& B) { return A.hue < B.hue; });
+
+  // Make 8 colums, one gray and seven colored.
+  std::vector<std::vector<ftxui::ColorInfo>> info_columns(8);
+  info_columns[0] = info_gray;
+  for (size_t i = 0; i < info_color.size(); ++i) {
+    info_columns[1 + 7 * i / info_color.size()].push_back(info_color[i]);
+  }
+
+  // Minimize discontinuities for every columns.
+  for (auto& column : info_columns) {
+    std::sort(column.begin(), column.end(),
+              [](const ftxui::ColorInfo& A, const ftxui::ColorInfo& B) {
+                return A.value < B.value;
+              });
+    for (int i = 0; i < int(column.size()) - 1; ++i) {
+      int best_index = i + 1;
+      int best_distance = 255 * 255 * 3;
+      for (int j = i + 1; j < column.size(); ++j) {
+        int dx = column[i].red - column[j].red;
+        int dy = column[i].green - column[j].green;
+        int dz = column[i].blue - column[j].blue;
+        int distance = dx * dx + dy * dy + dz * dz;
+        if (best_distance > distance) {
+          best_distance = distance;
+          best_index = j;
+        }
+      }
+      std::swap(column[i + 1], column[best_index]);
+    }
+  }
+
+  return std::move(info_columns);
+}

ftxui/examples/dom/color_truecolor_HSV.cpp

@@ -0,0 +1,35 @@
+// 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 <ftxui/dom/elements.hpp>  // for operator|, Elements, Fit, bgcolor, color, hbox, text, vbox, Element
+#include <ftxui/screen/screen.hpp>  // for Full, Screen
+#include <memory>                   // for allocator
+#include <utility>                  // for move
+
+#include "ftxui/dom/node.hpp"      // for Render
+#include "ftxui/screen/color.hpp"  // for Color, ftxui
+
+int main() {
+  using namespace ftxui;
+
+  int saturation = 255;
+  Elements array;
+  for (int value = 0; value < 255; value += 20) {
+    Elements line;
+    for (int hue = 0; hue < 255; hue += 2) {
+      line.push_back(text("▀")                                    //
+                     | color(Color::HSV(hue, saturation, value))  //
+                     | bgcolor(Color::HSV(hue, saturation, value + 10)));
+    }
+    array.push_back(hbox(std::move(line)));
+  }
+
+  auto document = vbox(std::move(array));
+
+  auto screen = Screen::Create(Dimension::Full(), Dimension::Fit(document));
+  Render(screen, document);
+
+  screen.Print();
+
+  return 0;
+}

ftxui/examples/dom/color_truecolor_RGB.cpp

@@ -0,0 +1,53 @@
+// 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 <ftxui/dom/elements.hpp>  // for hbox, text, bgcolor, operator|, vbox, Elements, window, Element, Fit
+#include <ftxui/screen/screen.hpp>  // for Full, Screen
+#include <memory>                   // for allocator
+#include <utility>                  // for move
+
+#include "ftxui/dom/node.hpp"      // for Render
+#include "ftxui/screen/color.hpp"  // for Color, ftxui
+
+int main() {
+  using namespace ftxui;
+
+  Elements red_line;
+  Elements green_line;
+  Elements blue_line;
+  Elements cyan_line;
+  Elements magenta_line;
+  Elements yellow_line;
+
+  for (int value = 0; value < 255; value += 3) {
+    int v = value * value / 255;
+    red_line.push_back(text(" ") | bgcolor(Color::RGB(v, 0, 0)));
+    green_line.push_back(text(" ") | bgcolor(Color::RGB(0, v, 0)));
+    blue_line.push_back(text(" ") | bgcolor(Color::RGB(0, 0, v)));
+    cyan_line.push_back(text(" ") | bgcolor(Color::RGB(0, v, v)));
+    magenta_line.push_back(text(" ") | bgcolor(Color::RGB(v, 0, v)));
+    yellow_line.push_back(text(" ") | bgcolor(Color::RGB(v, v, 0)));
+  }
+
+  auto document = vbox({
+      window(text("Primary colors"),
+             vbox({
+                 hbox({text("Red line    :"), hbox(std::move(red_line))}),
+                 hbox({text("Green line  :"), hbox(std::move(green_line))}),
+                 hbox({text("Blue line   :"), hbox(std::move(blue_line))}),
+             })),
+      window(text("Secondary colors"),
+             vbox({
+                 hbox({text("cyan line   :"), hbox(std::move(cyan_line))}),
+                 hbox({text("magenta line:"), hbox(std::move(magenta_line))}),
+                 hbox({text("Yellow line :"), hbox(std::move(yellow_line))}),
+             })),
+  });
+
+  auto screen = Screen::Create(Dimension::Full(), Dimension::Fit(document));
+  Render(screen, document);
+
+  screen.Print();
+
+  return 0;
+}

ftxui/examples/dom/dbox.cpp

@@ -0,0 +1,29 @@
+// 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 <ftxui/dom/elements.hpp>  // for text, operator|, border, Element, vbox, center, Fit, dbox
+#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 = dbox({
+      vbox({
+          text("line_1"),
+          text("line_2"),
+          text("line_3"),
+          text("line_4"),
+          text("line_5"),
+      }) | border,
+      text("overlay") | border | center,
+  });
+  auto screen = Screen::Create(Dimension::Full(), Dimension::Fit(document));
+  Render(screen, document);
+
+  screen.Print();
+
+  return 0;
+}

ftxui/examples/dom/gauge.cpp

@@ -0,0 +1,36 @@
+// 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 <chrono>                  // for operator""s, chrono_literals
+#include <ftxui/dom/elements.hpp>  // for text, gauge, operator|, flex, hbox, Element
+#include <ftxui/screen/screen.hpp>  // for Screen
+#include <iostream>                 // for cout, endl, ostream
+#include <string>  // for allocator, char_traits, operator+, operator<<, string, to_string, basic_string
+#include <thread>  // for sleep_for
+
+#include "ftxui/dom/node.hpp"      // for Render
+#include "ftxui/screen/color.hpp"  // for ftxui
+
+int main() {
+  using namespace ftxui;
+  using namespace std::chrono_literals;
+
+  std::string reset_position;
+  for (float percentage = 0.0f; percentage <= 1.0f; percentage += 0.002f) {
+    std::string data_downloaded =
+        std::to_string(int(percentage * 5000)) + "/5000";
+    auto document = hbox({
+        text("downloading:"),
+        gauge(percentage) | flex,
+        text(" " + data_downloaded),
+    });
+    auto screen = Screen(100, 1);
+    Render(screen, document);
+    std::cout << reset_position;
+    screen.Print();
+    reset_position = screen.ResetPosition();
+
+    std::this_thread::sleep_for(0.01s);
+  }
+  std::cout << std::endl;
+}

ftxui/examples/dom/gauge_direction.cpp

@@ -0,0 +1,78 @@
+// Copyright 2022 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 <chrono>                  // for operator""s, chrono_literals
+#include <ftxui/dom/elements.hpp>  // for filler, operator|, separator, text, border, Element, vbox, vtext, hbox, center, gaugeDown, gaugeLeft, gaugeRight, gaugeUp
+#include <ftxui/screen/screen.hpp>  // for Screen
+#include <iostream>                 // for cout, endl, ostream
+#include <string>  // for allocator, operator+, operator<<, string, to_string
+#include <thread>  // for sleep_for
+
+#include "ftxui/dom/node.hpp"      // for Render
+#include "ftxui/screen/color.hpp"  // for ftxui
+
+int main() {
+  using namespace ftxui;
+  using namespace std::chrono_literals;
+
+  std::string reset_position;
+  for (float percentage = 0.0f; percentage <= 1.0f; percentage += 0.002f) {
+    std::string data_downloaded =
+        std::to_string(int(percentage * 5000)) + "/5000";
+
+    auto gauge_up =  //
+        hbox({
+            vtext("gauge vertical"),
+            separator(),
+            gaugeUp(percentage),
+        }) |
+        border;
+
+    auto gauge_down =  //
+        hbox({
+            vtext("gauge vertical"),
+            separator(),
+            gaugeDown(percentage),
+        }) |
+        border;
+
+    auto gauge_right =  //
+        vbox({
+            text("gauge horizontal"),
+            separator(),
+            gaugeRight(percentage),
+        }) |
+        border;
+
+    auto gauge_left =  //
+        vbox({
+            text("gauge horizontal"),
+            separator(),
+            gaugeLeft(percentage),
+        }) |
+        border;
+
+    auto document = hbox({
+        gauge_up,
+        filler(),
+        vbox({
+            gauge_right,
+            filler(),
+            text(data_downloaded) | border | center,
+            filler(),
+            gauge_left,
+        }),
+        filler(),
+        gauge_down,
+    });
+
+    auto screen = Screen(32, 16);
+    Render(screen, document);
+    std::cout << reset_position;
+    screen.Print();
+    reset_position = screen.ResetPosition();
+
+    std::this_thread::sleep_for(0.01s);
+  }
+  std::cout << std::endl;
+}

ftxui/examples/dom/graph.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 <chrono>                  // for operator""s, chrono_literals
+#include <cmath>                   // for sin
+#include <ftxui/dom/elements.hpp>  // for graph, operator|, separator, color, Element, vbox, flex, inverted, operator|=, Fit, hbox, size, border, GREATER_THAN, HEIGHT
+#include <ftxui/screen/screen.hpp>  // for Full, Screen
+#include <functional>               // for ref, reference_wrapper
+#include <iostream>                 // for cout, ostream
+#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
+#include "ftxui/screen/color.hpp"  // for Color, Color::BlueLight, Color::RedLight, Color::YellowLight, ftxui
+
+class Graph {
+ public:
+  std::vector<int> operator()(int width, int height) const {
+    std::vector<int> output(width);
+    for (int i = 0; i < width; ++i) {
+      float v = 0;
+      v += 0.1f * sin((i + shift) * 0.1f);        // NOLINT
+      v += 0.2f * sin((i + shift + 10) * 0.15f);  // NOLINT
+      v += 0.1f * sin((i + shift) * 0.03f);       // NOLINT
+      v *= height;                                // NOLINT
+      v += 0.5f * height;                         // NOLINT
+      output[i] = static_cast<int>(v);
+    }
+    return output;
+  }
+  int shift = 0;
+};
+
+std::vector<int> triangle(int width, int height) {
+  std::vector<int> output(width);
+  for (int i = 0; i < width; ++i) {
+    output[i] = i % (height - 4) + 2;
+  }
+  return output;
+}
+
+int main() {
+  using namespace ftxui;
+  using namespace std::chrono_literals;
+
+  Graph my_graph;
+
+  std::string reset_position;
+  for (int i = 0;; ++i) {
+    std::ignore = i;
+    auto document = hbox({
+        vbox({
+            graph(std::ref(my_graph)),
+            separator(),
+            graph(triangle) | inverted,
+        }) | flex,
+        separator(),
+        vbox({
+            graph(std::ref(my_graph)) | color(Color::BlueLight),
+            separator(),
+            graph(std::ref(my_graph)) | color(Color::RedLight),
+            separator(),
+            graph(std::ref(my_graph)) | color(Color::YellowLight),
+        }) | flex,
+    });
+
+    document |= border;
+
+    const int min_width = 40;
+    document |= size(HEIGHT, GREATER_THAN, min_width);
+
+    auto screen = Screen::Create(Dimension::Full(), Dimension::Fit(document));
+    Render(screen, document);
+    std::cout << reset_position;
+    screen.Print();
+    reset_position = screen.ResetPosition();
+
+    const auto sleep_time = 0.03s;
+    std::this_thread::sleep_for(sleep_time);
+    my_graph.shift++;
+  }
+
+  return 0;
+}

ftxui/examples/dom/gridbox.cpp

@@ -0,0 +1,48 @@
+// 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 <stdio.h>  // for getchar
+#include <ftxui/dom/elements.hpp>  // for Elements, gridbox, Fit, operator|, text, border, Element
+#include <ftxui/screen/screen.hpp>  // for Screen
+#include <memory>                   // for allocator, shared_ptr
+
+#include "ftxui/dom/node.hpp"      // for Render
+#include "ftxui/screen/color.hpp"  // for ftxui
+
+int main() {
+  using namespace ftxui;
+  auto cell = [](const char* t) { return text(t) | border; };
+  auto document =  //
+      gridbox({
+          {
+              cell("north-west"),
+              cell("north"),
+              cell("north-east"),
+          },
+          {
+              cell("center-west"),
+              gridbox({
+                  {
+                      cell("center-north-west"),
+                      cell("center-north-east"),
+                  },
+                  {
+                      cell("center-south-west"),
+                      cell("center-south-east"),
+                  },
+              }),
+              cell("center-east"),
+          },
+          {
+              cell("south-west"),
+              cell("south"),
+              cell("south-east"),
+          },
+      });
+  auto screen = Screen::Create(Dimension::Fit(document));
+  Render(screen, document);
+  screen.Print();
+  getchar();
+
+  return 0;
+}

ftxui/examples/dom/hflow.cpp

@@ -0,0 +1,52 @@
+// 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 <stdio.h>                 // for getchar
+#include <ftxui/dom/elements.hpp>  // for operator|, size, Element, text, hcenter, Decorator, Fit, WIDTH, hflow, window, EQUAL, GREATER_THAN, HEIGHT, bold, border, dim, LESS_THAN
+#include <ftxui/screen/screen.hpp>  // for Full, Screen
+#include <string>  // for allocator, char_traits, operator+, to_string, string
+
+#include "ftxui/dom/node.hpp"      // for Render
+#include "ftxui/screen/color.hpp"  // for ftxui
+
+int main() {
+  using namespace ftxui;
+  auto make_box = [](int dimx, int dimy) {
+    std::string title = std::to_string(dimx) + "x" + std::to_string(dimy);
+    return window(text(title) | hcenter | bold,
+                  text("content") | hcenter | dim) |
+           size(WIDTH, EQUAL, dimx) | size(HEIGHT, EQUAL, dimy);
+  };
+
+  auto style = size(WIDTH, GREATER_THAN, 20) | border |
+               size(HEIGHT, GREATER_THAN, 30) | size(WIDTH, LESS_THAN, 50);
+
+  auto document = hflow({
+                      make_box(7, 7),
+                      make_box(7, 5),
+                      make_box(5, 7),
+                      make_box(10, 4),
+                      make_box(10, 4),
+                      make_box(10, 4),
+                      make_box(10, 4),
+                      make_box(11, 4),
+                      make_box(11, 4),
+                      make_box(11, 4),
+                      make_box(11, 4),
+                      make_box(12, 4),
+                      make_box(12, 5),
+                      make_box(12, 4),
+                      make_box(13, 4),
+                      make_box(13, 3),
+                      make_box(13, 3),
+                      make_box(10, 3),
+                  }) |
+                  style;
+
+  auto screen = Screen::Create(Dimension::Full(), Dimension::Fit(document));
+  Render(screen, document);
+  screen.Print();
+  getchar();
+
+  return 0;
+}

ftxui/examples/dom/html_like.cpp

@@ -0,0 +1,59 @@
+// 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 <chrono>                   // for operator""s, chrono_literals
+#include <ftxui/screen/screen.hpp>  // for Screen
+#include <iostream>                 // for cout, ostream
+#include <string>                   // for allocator, operator<<, string
+#include <thread>                   // for sleep_for
+
+#include "ftxui/dom/elements.hpp"  // for paragraph, text, operator|, Element, border, Fit, color, hflow, spinner, vbox, bold, dim, underlined
+#include "ftxui/dom/node.hpp"      // for Render
+#include "ftxui/screen/box.hpp"    // for ftxui
+#include "ftxui/screen/color.hpp"  // for Color, Color::Red
+
+int main() {
+  using namespace ftxui;
+  using namespace std::chrono_literals;
+
+  auto img1 = []() { return text("img") | border; };
+  auto img2 = []() { return vbox({text("big"), text("image")}) | border; };
+
+  std::string reset_position;
+  for (int i = 0;; ++i) {
+    auto document =  //
+        hflow(
+            paragraph("Hello world! Here is an image:"), img1(),
+            paragraph(" Here is a text "), text("underlined ") | underlined,
+            paragraph(" Here is a text "), text("bold ") | bold,
+            paragraph("Hello world! Here is an image:"), img2(),
+            paragraph(
+                "Le Lorem Ipsum est simplement du faux texte employé dans la "
+                "composition et la mise en page avant impression. Le Lorem "
+                "Ipsum est le faux texte standard de l'imprimerie depuis les "
+                "années 1500, quand un imprimeur anonyme assembla ensemble "
+                "des morceaux de texte pour réaliser un livre spécimen de "
+                "polices de texte. Il n'a pas fait que survivre cinq siècles, "
+                "mais s'est aussi adapté à la bureautique informatique, sans "
+                "que son contenu n'en soit modifié. Il a été popularisé dans "
+                "les années 1960 grâce à la vente de feuilles Letraset "
+                "contenant des passages du Lorem Ipsum, et, plus récemment, "
+                "par son inclusion dans des applications de mise en page de "
+                "texte, comme Aldus PageMaker."),
+            paragraph(" Here is a text "), text("dim ") | dim,
+            paragraph("Hello world! Here is an image:"), img1(),
+            paragraph(" Here is a text "), text("red ") | color(Color::Red),
+            paragraph(" A spinner "), spinner(6, i / 10)) |
+        border;
+
+    auto screen = Screen::Create(Dimension::Fit(document));
+    Render(screen, document);
+    std::cout << reset_position;
+    screen.Print();
+    reset_position = screen.ResetPosition();
+
+    std::this_thread::sleep_for(0.01s);
+  }
+
+  return 0;
+}

ftxui/examples/dom/linear_gradient.cpp

@@ -0,0 +1,25 @@
+// Copyright 2023 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 bgcolor, operator|, operator|=, text, center, Element
+#include <ftxui/dom/linear_gradient.hpp>  // for LinearGradient::Stop, LinearGradient
+#include <ftxui/screen/screen.hpp>        // for Full, Screen
+#include <memory>                         // for allocator, shared_ptr
+
+#include "ftxui/dom/node.hpp"  // for Render
+#include "ftxui/screen/color.hpp"  // for Color, Color::DeepPink1, Color::DeepSkyBlue1, Color::Yellow, ftxui
+
+int main() {
+  using namespace ftxui;
+  auto document = text("gradient") | center;
+
+  document |= bgcolor(LinearGradient()
+                          .Angle(45)
+                          .Stop(Color::DeepPink1)
+                          .Stop(Color::DeepSkyBlue1));
+  auto screen = Screen::Create(Dimension::Full(), Dimension::Full());
+  Render(screen, document);
+  screen.Print();
+
+  return 0;
+}

ftxui/examples/dom/package_manager.cpp

@@ -0,0 +1,150 @@
+// 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 <chrono>                  // for operator""s, chrono_literals
+#include <ftxui/dom/elements.hpp>  // for operator|, text, Element, hbox, bold, color, filler, separator, vbox, window, gauge, Fit, size, dim, EQUAL, WIDTH
+#include <ftxui/screen/screen.hpp>  // for Full, Screen
+#include <iostream>                 // for cout, endl, ostream
+#include <list>  // for list, operator==, _List_iterator, _List_iterator<>::_Self
+#include <memory>   // for allocator, shared_ptr, allocator_traits<>::value_type
+#include <string>   // for string, operator<<, to_string
+#include <thread>   // for sleep_for
+#include <utility>  // for move
+#include <vector>   // for vector
+
+#include "ftxui/dom/node.hpp"  // for Render
+#include "ftxui/screen/color.hpp"  // for Color, Color::Green, Color::Red, Color::RedLight, ftxui
+
+int main() {
+  using namespace ftxui;
+
+  struct Task {
+    std::string name;
+    int number_of_threads;
+    int downloaded;
+    int size;
+  };
+
+  std::list<Task> remaining_tasks = {
+      {"contact server       ", 10, 0, 6 * 25},
+      {"download index.html  ", 10, 0, 9 * 25},
+      {"download script.js   ", 1, 0, 3 * 25},
+      {"download style.js    ", 1, 0, 4 * 25},
+      {"download image.png   ", 1, 0, 5 * 25},
+      {"download big_1.png   ", 1, 0, 30 * 25},
+      {"download icon_1.png  ", 1, 0, 7 * 25},
+      {"download icon_2.png  ", 1, 0, 8 * 25},
+      {"download big_2.png   ", 1, 0, 30 * 25},
+      {"download small_1.png ", 1, 0, 10 * 25},
+      {"download small_2.png ", 1, 0, 11 * 25},
+      {"download small_3.png ", 1, 0, 12 * 25},
+  };
+
+  std::list<Task> displayed_task;
+
+  int remaining_threads = 12;
+
+  int nb_queued = (int)remaining_tasks.size();
+  int nb_active = 0;
+  int nb_done = 0;
+
+  auto to_text = [](int number) {
+    return text(std::to_string(number)) | size(WIDTH, EQUAL, 3);
+  };
+
+  auto renderTask = [&](const Task& task) {
+    auto style = (task.downloaded == task.size) ? dim : bold;
+    return hbox({
+        text(task.name) | style,
+        separator(),
+        to_text(task.downloaded),
+        text("/"),
+        to_text(task.size),
+        separator(),
+        gauge(task.downloaded / float(task.size)),
+    });
+  };
+
+  auto renderSummary = [&]() {
+    auto summary = vbox({
+        hbox({
+            text("- done:   "),
+            to_text(nb_done) | bold,
+        }) | color(Color::Green),
+        hbox({
+            text("- active: "),
+            to_text(nb_active) | bold,
+        }) | color(Color::RedLight),
+        hbox({
+            text("- queue:  "),
+            to_text(nb_queued) | bold,
+        }) | color(Color::Red),
+    });
+
+    return window(text(" Summary "), summary);
+  };
+
+  auto render = [&]() {
+    std::vector<Element> entries;
+    for (auto& task : displayed_task) {
+      entries.push_back(renderTask(task));
+    }
+
+    return vbox({
+        // List of tasks.
+        window(text(" Task "), vbox(std::move(entries))),
+
+        // Summary.
+        hbox({
+            renderSummary(),
+            filler(),
+        }),
+    });
+  };
+
+  auto updateModel = [&]() {
+    for (auto& task : displayed_task) {
+      if (task.downloaded != task.size) {
+        task.downloaded++;
+      } else if (task.number_of_threads) {
+        remaining_threads += task.number_of_threads;
+        task.number_of_threads = 0;
+        nb_active--;
+        nb_done++;
+      }
+    }
+
+    if (remaining_tasks.size() &&
+        remaining_tasks.front().number_of_threads <= remaining_threads) {
+      remaining_threads -= remaining_tasks.front().number_of_threads;
+      displayed_task.push_back(remaining_tasks.front());
+      remaining_tasks.pop_front();
+      nb_queued--;
+      nb_active++;
+    }
+  };
+
+  std::string reset_position;
+  for (;;) {
+    // Draw.
+    auto document = render();
+    auto screen = Screen::Create(Dimension::Full(), Dimension::Fit(document));
+    Render(screen, document);
+    std::cout << reset_position;
+    screen.Print();
+    reset_position = screen.ResetPosition();
+
+    // Simulate time.
+    using namespace std::chrono_literals;
+    std::this_thread::sleep_for(0.01s);
+
+    // Exit
+    if (nb_active + nb_queued == 0) {
+      break;
+    }
+
+    // Update the model for the next frame.
+    updateModel();
+  }
+  std::cout << std::endl;
+}

ftxui/examples/dom/paragraph.cpp

@@ -0,0 +1,53 @@
+// 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 <chrono>                   // for operator""s, chrono_literals
+#include <ftxui/screen/screen.hpp>  // for Full, Screen
+#include <iostream>                 // for cout, ostream
+#include <memory>                   // for allocator, shared_ptr
+#include <string>                   // for string, operator<<
+#include <thread>                   // for sleep_for
+
+#include "ftxui/dom/elements.hpp"  // for hflow, paragraph, separator, hbox, vbox, filler, operator|, border, Element
+#include "ftxui/dom/node.hpp"      // for Render
+#include "ftxui/screen/box.hpp"    // for ftxui
+
+using namespace std::chrono_literals;
+int main() {
+  using namespace ftxui;
+  std::string p =
+      R"(In probability theory and statistics, Bayes' theorem (alternatively Bayes' law or Bayes' rule) describes the probability of an event, based on prior knowledge of conditions that might be related to the event. For example, if cancer is related to age, then, using Bayes' theorem, a person's age can be used to more accurately assess the probability that they have cancer, compared to the assessment of the probability of cancer made without knowledge of the person's age. One of the many applications of Bayes' theorem is Bayesian inference, a particular approach to statistical inference. When applied, the probabilities involved in Bayes' theorem may have different probability interpretations. With the Bayesian probability interpretation the theorem expresses how a subjective degree of belief should rationally change to account for availability of related evidence. Bayesian inference is fundamental to Bayesian statistics.)";
+
+  std::string reset_position;
+  while (true) {
+    auto document = vbox({
+                        hflow(paragraph(p)),
+                        separator(),
+                        hflow(paragraph(p)),
+                        separator(),
+                        hbox({
+                            hflow(paragraph(p)),
+                            separator(),
+                            hflow(paragraph(p)),
+                        }),
+                    }) |
+                    border;
+
+    document = vbox(filler(), document);
+
+    // auto screen = Screen::Create(Dimension::Fit(document));
+    // Render(screen, document);
+    // screen.Print();
+    // getchar();
+
+    auto screen = Screen::Create(Dimension::Full());
+    Render(screen, document);
+    std::cout << reset_position;
+    screen.Print();
+    reset_position = screen.ResetPosition();
+
+    std::this_thread::sleep_for(0.01s);
+  }
+
+  return 0;
+}

ftxui/examples/dom/separator.cpp

@@ -0,0 +1,30 @@
+// 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 <ftxui/dom/elements.hpp>  // for text, center, separator, operator|, flex, Element, vbox, Fit, hbox, border
+#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("left-column"),
+                      separator(),
+                      vbox({
+                          center(text("top")) | flex,
+                          separator(),
+                          center(text("bottom")),
+                      }) | flex,
+                      separator(),
+                      text("right-column"),
+                  }) |
+                  border;
+  auto screen = Screen::Create(Dimension::Full(), Dimension::Fit(document));
+  Render(screen, document);
+  screen.Print();
+
+  return 0;
+}

ftxui/examples/dom/separator_style.cpp

@@ -0,0 +1,46 @@
+// 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 <ftxui/screen/screen.hpp>  // for Screen
+#include <iostream>                 // for endl, cout, ostream
+#include <memory>                   // for allocator
+
+#include "ftxui/dom/elements.hpp"  // for text, hbox, separatorDouble, separatorHeavy, separatorLight, vbox, operator|, Element, Fit, borderDouble, borderHeavy, borderLight
+#include "ftxui/dom/node.hpp"      // for Render
+#include "ftxui/screen/box.hpp"    // for ftxui
+
+int main() {
+  using namespace ftxui;
+
+  auto document = vbox({
+      vbox({
+          text("separatorLight"),
+          separatorLight(),
+          hbox(text("left"), separatorLight(), text("right")),
+      }) | borderLight,
+
+      vbox({
+          text("separatorDashed"),
+          separatorDashed(),
+          hbox(text("left"), separatorDashed(), text("right")),
+      }) | borderDashed,
+
+      vbox({
+          text("separatorHeavy"),
+          separatorHeavy(),
+          hbox(text("left"), separatorHeavy(), text("right")),
+      }) | borderHeavy,
+
+      vbox({
+          text("separatorDouble"),
+          separatorDouble(),
+          hbox(text("left"), separatorDouble(), text("right")),
+      }) | borderDouble,
+  });
+
+  auto screen =
+      Screen::Create(Dimension::Fit(document), Dimension::Fit(document));
+  Render(screen, document);
+  screen.Print();
+  std::cout << std::endl;
+}

ftxui/examples/dom/size.cpp

@@ -0,0 +1,31 @@
+// 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 <ftxui/dom/elements.hpp>  // for operator|, text, Element, hcenter, Fit, hbox, size, window, Elements, bold, dim, EQUAL, WIDTH
+#include <ftxui/screen/screen.hpp>  // for Screen
+#include <memory>                   // for allocator, shared_ptr
+#include <string>                   // for string, to_string
+#include <utility>                  // for move
+
+#include "ftxui/dom/node.hpp"      // for Render
+#include "ftxui/screen/color.hpp"  // for ftxui
+
+int main() {
+  using namespace ftxui;
+  auto make_box = [](const std::string& title) {
+    return window(text(title) | hcenter | bold,
+                  text("content") | hcenter | dim);
+  };
+
+  Elements content;
+  for (int x = 3; x < 30; ++x) {
+    content.push_back(make_box(std::to_string(x)) | size(WIDTH, EQUAL, x));
+  }
+
+  auto document = hbox(std::move(content));
+  auto screen = Screen::Create(Dimension::Fit(document));
+  Render(screen, document);
+  screen.Print();
+
+  return 0;
+}

ftxui/examples/dom/spinner.cpp

@@ -0,0 +1,47 @@
+// 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 <chrono>                  // for operator""s, chrono_literals
+#include <ftxui/dom/elements.hpp>  // for Element, operator|, separator, filler, hbox, size, spinner, text, vbox, bold, border, Fit, EQUAL, WIDTH
+#include <ftxui/screen/screen.hpp>  // for Full, Screen
+#include <iostream>                 // for cout, endl, ostream
+#include <string>                   // for to_string, operator<<, string
+#include <thread>                   // for sleep_for
+#include <utility>                  // for move
+#include <vector>                   // for vector
+
+#include "ftxui/dom/node.hpp"      // for Render
+#include "ftxui/screen/color.hpp"  // for ftxui
+
+int main() {
+  using namespace ftxui;
+  using namespace std::chrono_literals;
+
+  std::string reset_position;
+  for (int index = 0; index < 200; ++index) {
+    std::vector<Element> entries;
+    for (int i = 0; i < 23; ++i) {
+      if (i != 0) {
+        entries.push_back(separator());
+      }
+      entries.push_back(  //
+          hbox({
+              text(std::to_string(i)) | size(WIDTH, EQUAL, 2),
+              separator(),
+              spinner(i, index) | bold,
+          }));
+    }
+    auto document = hbox({
+        vbox(std::move(entries)) | border,
+        filler(),
+    });
+    auto screen = Screen::Create(Dimension::Full(), Dimension::Fit(document));
+    Render(screen, document);
+    std::cout << reset_position;
+    screen.Print();
+    reset_position = screen.ResetPosition();
+
+    std::this_thread::sleep_for(0.1s);
+  }
+  std::cout << std::endl;
+}

ftxui/examples/dom/style_blink.cpp

@@ -0,0 +1,24 @@
+// 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 <ftxui/dom/elements.hpp>  // for text, operator|, blink, 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("blink") | blink,
+          text(". Do you like it?"),
+      });
+  auto screen = Screen::Create(Dimension::Full(), Dimension::Fit(document));
+  Render(screen, document);
+  screen.Print();
+
+  return 0;
+}

ftxui/examples/dom/style_bold.cpp

@@ -0,0 +1,24 @@
+// 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 <ftxui/dom/elements.hpp>  // for text, operator|, bold, 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("bold") | bold,
+          text(". Do you like it?"),
+      });
+  auto screen = Screen::Create(Dimension::Full(), Dimension::Fit(document));
+  Render(screen, document);
+  screen.Print();
+
+  return 0;
+}

ftxui/examples/dom/style_color.cpp

@@ -0,0 +1,67 @@
+// 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 <ftxui/dom/linear_gradient.hpp>  // for LinearGradient
+#include <ftxui/screen/screen.hpp>        // for Full, Screen
+#include <memory>                         // for allocator
+
+#include "ftxui/dom/elements.hpp"  // for text, bgcolor, color, vbox, filler, Fit, hbox
+#include "ftxui/dom/node.hpp"      // for Render
+#include "ftxui/screen/color.hpp"  // for Color, operator""_rgb, Color::Black, Color::Blue, Color::BlueLight, Color::Cyan, Color::CyanLight, Color::DeepSkyBlue4, Color::Default, Color::GrayDark, Color::GrayLight, Color::Green, Color::GreenLight, Color::Magenta, Color::MagentaLight, Color::Red, Color::RedLight, Color::SkyBlue1, Color::White, Color::Yellow, Color::YellowLight, ftxui
+
+int main() {
+  using namespace ftxui;
+  auto document = hbox({
+      vbox({
+          color(Color::Default, text("Default")),
+          color(Color::Black, text("Black")),
+          color(Color::GrayDark, text("GrayDark")),
+          color(Color::GrayLight, text("GrayLight")),
+          color(Color::White, text("White")),
+          color(Color::Blue, text("Blue")),
+          color(Color::BlueLight, text("BlueLight")),
+          color(Color::Cyan, text("Cyan")),
+          color(Color::CyanLight, text("CyanLight")),
+          color(Color::Green, text("Green")),
+          color(Color::GreenLight, text("GreenLight")),
+          color(Color::Magenta, text("Magenta")),
+          color(Color::MagentaLight, text("MagentaLight")),
+          color(Color::Red, text("Red")),
+          color(Color::RedLight, text("RedLight")),
+          color(Color::Yellow, text("Yellow")),
+          color(Color::YellowLight, text("YellowLight")),
+          color(0x66ff66_rgb, text("Phosphor")),
+          color(LinearGradient(Color::SkyBlue1, Color::DeepSkyBlue4),
+                text("Skyblue to DeepSkyBlue")),
+      }),
+      vbox({
+          bgcolor(Color::Default, text("Default")),
+          bgcolor(Color::Black, text("Black")),
+          bgcolor(Color::GrayDark, text("GrayDark")),
+          bgcolor(Color::GrayLight, text("GrayLight")),
+          bgcolor(Color::White, text("White")),
+          bgcolor(Color::Blue, text("Blue")),
+          bgcolor(Color::BlueLight, text("BlueLight")),
+          bgcolor(Color::Cyan, text("Cyan")),
+          bgcolor(Color::CyanLight, text("CyanLight")),
+          bgcolor(Color::Green, text("Green")),
+          bgcolor(Color::GreenLight, text("GreenLight")),
+          bgcolor(Color::Magenta, text("Magenta")),
+          bgcolor(Color::MagentaLight, text("MagentaLight")),
+          bgcolor(Color::Red, text("Red")),
+          bgcolor(Color::RedLight, text("RedLight")),
+          bgcolor(Color::Yellow, text("Yellow")),
+          bgcolor(Color::YellowLight, text("YellowLight")),
+          bgcolor(0x66ff66_rgb, text("Phosphor")),
+          bgcolor(LinearGradient(Color::SkyBlue1, Color::DeepSkyBlue4),
+                  text("Skyblue to DeepSkyBlue")),
+      }),
+      filler(),
+  });
+
+  auto screen = Screen::Create(Dimension::Full(), Dimension::Fit(document));
+  Render(screen, document);
+  screen.Print();
+
+  return 0;
+}

ftxui/examples/dom/style_dim.cpp

@@ -0,0 +1,24 @@
+// 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 <ftxui/dom/elements.hpp>  // for text, operator|, dim, 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("dim") | dim,
+          text(". Do you like it?"),
+      });
+  auto screen = Screen::Create(Dimension::Full(), Dimension::Fit(document));
+  Render(screen, document);
+  screen.Print();
+
+  return 0;
+}

ftxui/examples/dom/style_gallery.cpp

@@ -0,0 +1,35 @@
+// 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 <ftxui/dom/elements.hpp>  // for text, operator|, Element, bgcolor, color, blink, bold, dim, inverted, underlined, Fit, hbox
+#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 Color, Color::Blue, ftxui
+
+int main() {
+  using namespace ftxui;
+  // clang-format off
+  auto document =
+    hbox({
+      text("normal")                                    , text(" ") ,
+      text("bold")               | bold                 , text(" ") ,
+      text("italic")             | italic               , text(" ") ,
+      text("dim")                | dim                  , text(" ") ,
+      text("inverted")           | inverted             , text(" ") ,
+      text("underlined")         | underlined           , text(" ") ,
+      text("underlinedDouble")   | underlinedDouble     , text(" ") ,
+      text("blink")              | blink                , text(" ") ,
+      text("strikethrough")      | strikethrough        , text(" ") ,
+      text("color")              | color(Color::Blue)   , text(" ") ,
+      text("bgcolor")            | bgcolor(Color::Blue) , text(" ") ,
+      text("hyperlink")          | hyperlink("https://github.com/ArthurSonzogni/FTXUI"),
+    });
+  // clang-format on
+  auto screen = Screen::Create(Dimension::Full(), Dimension::Fit(document));
+  Render(screen, document);
+  screen.Print();
+
+  return 0;
+}

ftxui/examples/dom/style_hyperlink.cpp

@@ -0,0 +1,24 @@
+// 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 <ftxui/dom/elements.hpp>  // for text, operator|, bold, 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 an "),
+          text("hyperlink") | hyperlink("https://www.google.com"),
+          text(". Do you like it?"),
+      });
+  auto screen = Screen::Create(Dimension::Full(), Dimension::Fit(document));
+  Render(screen, document);
+  screen.Print();
+
+  return 0;
+}

ftxui/examples/dom/style_inverted.cpp

@@ -0,0 +1,23 @@
+// 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 <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("inverted") | inverted,
+      text(". Do you like it?"),
+  });
+  auto screen = Screen::Create(Dimension::Full(), Dimension::Fit(document));
+  Render(screen, document);
+  screen.Print();
+
+  return 0;
+}

ftxui/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;
+}

ftxui/examples/dom/style_strikethrough.cpp

@@ -0,0 +1,24 @@
+// 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 <ftxui/dom/elements.hpp>  // for text, operator|, strikethrough, 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("strikethrough") | strikethrough,
+          text(". Do you like it?"),
+      });
+  auto screen = Screen::Create(Dimension::Full(), Dimension::Fit(document));
+  Render(screen, document);
+  screen.Print();
+
+  return 0;
+}

ftxui/examples/dom/style_underlined.cpp

@@ -0,0 +1,24 @@
+// 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 <ftxui/dom/elements.hpp>  // for text, operator|, underlined, 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("underlined") | underlined,
+          text(". Do you like it?"),
+      });
+  auto screen = Screen::Create(Dimension::Full(), Dimension::Fit(document));
+  Render(screen, document);
+  screen.Print();
+
+  return 0;
+}

ftxui/examples/dom/style_underlined_double.cpp

@@ -0,0 +1,24 @@
+// 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 <ftxui/dom/elements.hpp>  // for text, operator|, underlinedDouble, 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("underlinedDouble") | underlinedDouble,
+          text(". Do you like it?"),
+      });
+  auto screen = Screen::Create(Dimension::Full(), Dimension::Fit(document));
+  Render(screen, document);
+  screen.Print();
+
+  return 0;
+}

ftxui/examples/dom/table.cpp

@@ -0,0 +1,65 @@
+// 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 <ftxui/dom/elements.hpp>  // for color, Fit, LIGHT, align_right, bold, DOUBLE
+#include <ftxui/dom/table.hpp>      // for Table, TableSelection
+#include <ftxui/screen/screen.hpp>  // for Screen
+#include <iostream>                 // for endl, cout, ostream
+#include <string>                   // for basic_string, allocator, string
+#include <vector>                   // for vector
+
+#include "ftxui/dom/node.hpp"  // for Render
+#include "ftxui/screen/color.hpp"  // for Color, Color::Blue, Color::Cyan, Color::White, ftxui
+
+int main() {
+  using namespace ftxui;
+
+  auto table = Table({
+      {"Version", "Marketing name", "Release date", "API level", "Runtime"},
+      {"2.3", "Gingerbread", "February 9 2011", "10", "Dalvik 1.4.0"},
+      {"4.0", "Ice Cream Sandwich", "October 19 2011", "15", "Dalvik"},
+      {"4.1", "Jelly Bean", "July 9 2012", "16", "Dalvik"},
+      {"4.2", "Jelly Bean", "November 13 2012", "17", "Dalvik"},
+      {"4.3", "Jelly Bean", "July 24 2013", "18", "Dalvik"},
+      {"4.4", "KitKat", "October 31 2013", "19", "Dalvik and ART"},
+      {"5.0", "Lollipop", "November 3 2014", "21", "ART"},
+      {"5.1", "Lollipop", "March 9 2015", "22", "ART"},
+      {"6.0", "Marshmallow", "October 5 2015", "23", "ART"},
+      {"7.0", "Nougat", "August 22 2016", "24", "ART"},
+      {"7.1", "Nougat", "October 4 2016", "25", "ART"},
+      {"8.0", "Oreo", "August 21 2017", "26", "ART"},
+      {"8.1", "Oreo", "December 5 2017", "27", "ART"},
+      {"9", "Pie", "August 6 2018", "28", "ART"},
+      {"10", "10", "September 3 2019", "29", "ART"},
+      {"11", "11", "September 8 2020", "30", "ART"},
+  });
+
+  table.SelectAll().Border(LIGHT);
+
+  // Add border around the first column.
+  table.SelectColumn(0).Border(LIGHT);
+
+  // Make first row bold with a double border.
+  table.SelectRow(0).Decorate(bold);
+  table.SelectRow(0).SeparatorVertical(LIGHT);
+  table.SelectRow(0).Border(DOUBLE);
+
+  // Align right the "Release date" column.
+  table.SelectColumn(2).DecorateCells(align_right);
+
+  // Select row from the second to the last.
+  auto content = table.SelectRows(1, -1);
+  // Alternate in between 3 colors.
+  content.DecorateCellsAlternateRow(color(Color::Blue), 3, 0);
+  content.DecorateCellsAlternateRow(color(Color::Cyan), 3, 1);
+  content.DecorateCellsAlternateRow(color(Color::White), 3, 2);
+
+  auto document = table.Render();
+  auto screen =
+      Screen::Create(Dimension::Fit(document, /*extend_beyond_screen=*/true));
+  Render(screen, document);
+  screen.Print();
+  std::cout << std::endl;
+
+  return 0;
+}

ftxui/examples/dom/vbox_hbox.cpp

@@ -0,0 +1,40 @@
+// 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 <stdio.h>                  // for getchar
+#include <ftxui/dom/elements.hpp>   // for filler, text, hbox, vbox
+#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 =  //
+      vbox({
+          hbox({
+              text("north-west"),
+              filler(),
+              text("north-east"),
+          }),
+          filler(),
+          hbox({
+              filler(),
+              text("center"),
+              filler(),
+          }),
+          filler(),
+          hbox({
+              text("south-west"),
+              filler(),
+              text("south-east"),
+          }),
+      });
+  auto screen = Screen::Create(Dimension::Full());
+  Render(screen, document);
+  screen.Print();
+  getchar();
+
+  return 0;
+}

ftxui/examples/dom/vflow.cpp

@@ -0,0 +1,49 @@
+// 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 <stdio.h>                 // for getchar
+#include <ftxui/dom/elements.hpp>  // for operator|, Element, size, text, hcenter, Fit, vflow, window, EQUAL, bold, border, dim, HEIGHT, WIDTH
+#include <ftxui/screen/screen.hpp>  // for Full, Screen
+#include <string>  // for allocator, char_traits, operator+, to_string, string
+
+#include "ftxui/dom/node.hpp"      // for Render
+#include "ftxui/screen/color.hpp"  // for ftxui
+
+int main() {
+  using namespace ftxui;
+  auto make_box = [](int dimx, int dimy) {
+    std::string title = std::to_string(dimx) + "x" + std::to_string(dimy);
+    return window(text(title) | hcenter | bold,
+                  text("content") | hcenter | dim) |
+           size(WIDTH, EQUAL, dimx) | size(HEIGHT, EQUAL, dimy);
+  };
+
+  auto document = vflow({
+                      make_box(7, 7),
+                      make_box(7, 5),
+                      make_box(5, 7),
+                      make_box(10, 4),
+                      make_box(10, 4),
+                      make_box(10, 4),
+                      make_box(10, 4),
+                      make_box(11, 4),
+                      make_box(11, 4),
+                      make_box(11, 4),
+                      make_box(11, 4),
+                      make_box(12, 4),
+                      make_box(12, 5),
+                      make_box(12, 4),
+                      make_box(13, 4),
+                      make_box(13, 3),
+                      make_box(13, 3),
+                      make_box(10, 3),
+                  }) |
+                  border;
+
+  auto screen = Screen::Create(Dimension::Full(), Dimension::Fit(document));
+  Render(screen, document);
+  screen.Print();
+  getchar();
+
+  return 0;
+}