Merge 3427da0cc0 into 8ef18ab647

.clang-format

@@ -2,6 +2,3 @@
 # http://clang.llvm.org/docs/ClangFormatStyleOptions.html
 BasedOnStyle: Chromium
 Standard: Cpp11
-
-InsertBraces: true
-InsertNewlineAtEOF: true

.gitignore

@@ -44,7 +44,6 @@ out/
 !doc/**/*.html
 !doc/**/*.xml
 !doc/**/*.md
-!doc/*.md
 
 # examples directory:
 !examples/**/*.cpp

README.md

@@ -378,8 +378,6 @@ Several games using the FTXUI have been made during the Game Jam:
 - [smoothlife](https://github.com/cpp-best-practices/game_jam/blob/main/Jam1_April_2022/smoothlife.md)
 - [Consu](https://github.com/cpp-best-practices/game_jam/blob/main/Jam1_April_2022/consu.md)
 
-
-
 ## Build using CMake
 
 It is **highly** recommended to use CMake FetchContent to depend on FTXUI so you may specify which commit you would like to depend on.

doc/posix_pipe.md

@@ -1,58 +0,0 @@
-# POSIX Piped Input in FTXUI
-
-> [!WARNING]
-> This feature works only on Linux and macOS. It is not supported on
-> Windows and WebAssembly.
-
-## What is a POSIX Pipe?
-
-A POSIX pipe is a way for two separate programs to communicate. One program sends its output directly as input to another program. Think of it like a one-way tube for data.
-
-**Example:**
-
-Imagine you want to list files and then filter them interactively.
-
-- `ls`: Lists files.
-- `interactive_grep`: An FTXUI application that filters text and lets you type.
-
-You can connect them with a pipe (`|`):
-
-```bash
-ls -l | interactive_grep
-```
-
-Here's what happens:
-1. `ls -l` lists files with details.
-2. The `|` sends this list directly to `interactive_grep`.
-3. `interactive_grep` receives the list and displays it. Because it's an FTXUI app, you can then type to filter the list, even though it received initial data from `ls`.
-
-## How FTXUI Handles Piped Input
-
-Now that you understand what a POSIX pipe is, let's look at how FTXUI uses them.
-
-FTXUI lets your application read data from other programs (like from a pipe) while still allowing you to use your keyboard for interaction. This is useful for interactive command-line tools that process data.
-
-Normally, FTXUI applications receive all input from `stdin`. However, when FTXUI detects that `stdin` is connected to the output of a pipe (meaning data is being piped into your application), it automatically switches to reading interactive keyboard input from `/dev/tty`. This ensures that your application can still receive user input even while processing piped data.
-
-This feature is **turned on by default**.
-
-If your FTXUI application needs to read piped data and also respond to keyboard input, you typically don't need to do anything special:
-
-```cpp
-auto screen = ScreenInteractive::Fullscreen();
-// screen.HandlePipedInput(true); // This is enabled by default
-screen.Loop(component);
-```
-
-
-## Turning Off Piped Input
-
-If you don't need this feature, or if it conflicts with your custom input handling, you can turn it off.
-
-To disable it, call `HandlePipedInput(false)` before starting your application's main loop:
-
-```cpp
-auto screen = ScreenInteractive::Fullscreen();
-screen.HandlePipedInput(false); // Turn off piped input handling
-screen.Loop(component);
-```

examples/component/canvas_animated.cpp

@@ -133,9 +133,8 @@ int main() {
       float dy = 50.f;
       ys[x] = int(dy + 20 * cos(dx * 0.14) + 10 * sin(dx * 0.42));
     }
-    for (int x = 1; x < 99; x++) {
+    for (int x = 1; x < 99; x++)
       c.DrawPointLine(x, ys[x], x + 1, ys[x + 1]);
-    }
 
     return canvas(std::move(c));
   });

examples/component/flexbox_gallery.cpp

@@ -82,12 +82,10 @@ int main() {
                    size(WIDTH, EQUAL, dimx) | size(HEIGHT, EQUAL, dimy) |
                    bgcolor(Color::HSV(index * 25, 255, 255)) |
                    color(Color::Black);
-    if (element_xflex_grow) {
+    if (element_xflex_grow)
       element = element | xflex_grow;
-    }
+    if (element_yflex_grow)
-    if (element_yflex_grow) {
       element = element | yflex_grow;
-    }
     return element;
   };
 
@@ -121,12 +119,10 @@ int main() {
 
     group = group | notflex;
 
-    if (!group_xflex_grow) {
+    if (!group_xflex_grow)
       group = hbox(group, filler());
-    }
+    if (!group_yflex_grow)
-    if (!group_yflex_grow) {
       group = vbox(group, filler());
-    }
 
     group = group | flex;
     return group;

examples/component/homescreen.cpp

@@ -514,7 +514,7 @@ int main() {
   });
 
   Loop loop(&screen, main_renderer);
-  while (!loop.HasQuitted()) {
+  while(!loop.HasQuitted()) {
     // Update the state of the application.
     shift++;
 
@@ -525,7 +525,7 @@ int main() {
     loop.RunOnce();
 
     // Sleep for a short duration to control the frame rate (60 FPS).
-    std::this_thread::sleep_for(std::chrono::milliseconds(1000 / 60));
+    std::this_thread::sleep_for(std::chrono::milliseconds(1000/60));
   }
 
   return 0;

examples/component/menu_entries.cpp

@@ -22,12 +22,10 @@ MenuEntryOption Colored(ftxui::Color c) {
   option.transform = [c](EntryState state) {
     state.label = (state.active ? "> " : "  ") + state.label;
     Element e = text(state.label) | color(c);
-    if (state.focused) {
+    if (state.focused)
       e = e | inverted;
-    }
+    if (state.active)
-    if (state.active) {
       e = e | bold;
-    }
     return e;
   };
   return option;

examples/component/menu_in_frame.cpp

@@ -17,9 +17,8 @@ int main() {
   std::vector<std::string> entries;
   int selected = 0;
 
-  for (int i = 0; i < 30; ++i) {
+  for (int i = 0; i < 30; ++i)
     entries.push_back("Entry " + std::to_string(i));
-  }
   auto radiobox = Menu(&entries, &selected);
   auto renderer = Renderer(radiobox, [&] {
     return radiobox->Render() | vscroll_indicator | frame |

examples/component/menu_in_frame_horizontal.cpp

@@ -17,9 +17,8 @@ int main() {
   std::vector<std::string> entries;
   int selected = 0;
 
-  for (int i = 0; i < 100; ++i) {
+  for (int i = 0; i < 100; ++i)
     entries.push_back(std::to_string(i));
-  }
   auto radiobox = Menu(&entries, &selected, MenuOption::Horizontal());
   auto renderer = Renderer(
       radiobox, [&] { return radiobox->Render() | hscroll_indicator | frame; });

examples/component/menu_style.cpp

@@ -116,12 +116,10 @@ Component VMenu1(std::vector<std::string>* entries, int* selected) {
   option.entries_option.transform = [](EntryState state) {
     state.label = (state.active ? "> " : "  ") + state.label;
     Element e = text(state.label);
-    if (state.focused) {
+    if (state.focused)
       e = e | bgcolor(Color::Blue);
-    }
+    if (state.active)
-    if (state.active) {
       e = e | bold;
-    }
     return e;
   };
   return Menu(entries, selected, option);
@@ -132,12 +130,10 @@ Component VMenu2(std::vector<std::string>* entries, int* selected) {
   option.entries_option.transform = [](EntryState state) {
     state.label += (state.active ? " <" : "  ");
     Element e = hbox(filler(), text(state.label));
-    if (state.focused) {
+    if (state.focused)
       e = e | bgcolor(Color::Red);
-    }
+    if (state.active)
-    if (state.active) {
       e = e | bold;
-    }
     return e;
   };
   return Menu(entries, selected, option);
@@ -148,16 +144,13 @@ Component VMenu3(std::vector<std::string>* entries, int* selected) {
   option.entries_option.transform = [](EntryState state) {
     Element e = state.active ? text("[" + state.label + "]")
                              : text(" " + state.label + " ");
-    if (state.focused) {
+    if (state.focused)
       e = e | bold;
-    }
 
-    if (state.focused) {
+    if (state.focused)
       e = e | color(Color::Blue);
-    }
+    if (state.active)
-    if (state.active) {
       e = e | bold;
-    }
     return e;
   };
   return Menu(entries, selected, option);
@@ -252,12 +245,10 @@ Component HMenu5(std::vector<std::string>* entries, int* selected) {
                                 animation::easing::ElasticOut);
   option.entries_option.transform = [](EntryState state) {
     Element e = text(state.label) | hcenter | flex;
-    if (state.active && state.focused) {
+    if (state.active && state.focused)
       e = e | bold;
-    }
+    if (!state.focused && !state.active)
-    if (!state.focused && !state.active) {
       e = e | dim;
-    }
     return e;
   };
   option.underline.color_inactive = Color::Default;

examples/component/menu_underline_animated_gallery.cpp

@@ -20,9 +20,8 @@ using namespace ftxui;
 Component DummyComponent(int id) {
   return Renderer([id](bool focused) {
     auto t = text("component " + std::to_string(id));
-    if (focused) {
+    if (focused)
       t = t | inverted;
-    }
     return t;
   });
 }

examples/component/radiobox_in_frame.cpp

@@ -17,9 +17,8 @@ int main() {
   std::vector<std::string> entries;
   int selected = 0;
 
-  for (int i = 0; i < 30; ++i) {
+  for (int i = 0; i < 30; ++i)
     entries.push_back("RadioBox " + std::to_string(i));
-  }
   auto radiobox = Radiobox(&entries, &selected);
   auto renderer = Renderer(radiobox, [&] {
     return radiobox->Render() | vscroll_indicator | frame |

examples/component/renderer.cpp

@@ -19,11 +19,10 @@ int main() {
 
   // 1. Example of focusable renderer:
   auto renderer_focusable = Renderer([](bool focused) {
-    if (focused) {
+    if (focused)
       return text("FOCUSABLE RENDERER()") | center | bold | border;
-    } else {
+    else
       return text(" Focusable renderer() ") | center | border;
-    }
   });
 
   // 2. Examples of a non focusable renderer.
@@ -34,11 +33,10 @@ int main() {
   // 3. Renderer can wrap other components to redefine their Render() function.
   auto button = Button("Wrapped quit button", screen.ExitLoopClosure());
   auto renderer_wrap = Renderer(button, [&] {
-    if (button->Focused()) {
+    if (button->Focused())
       return button->Render() | bold | color(Color::Red);
-    } else {
+    else
       return button->Render();
-    }
   });
 
   // Let's renderer everyone:

examples/dom/canvas.cpp

@@ -32,12 +32,10 @@ int main() {
 
   // Plot a function:
   std::vector<int> ys(100);
-  for (int x = 0; x < 100; x++) {
+  for (int x = 0; x < 100; x++)
     ys[x] = int(80 + 20 * cos(x * 0.2));
-  }
+  for (int x = 0; x < 99; x++)
-  for (int x = 0; x < 99; x++) {
     c.DrawPointLine(x, ys[x], x + 1, ys[x + 1], Color::Red);
-  }
 
   auto document = canvas(&c) | border;
 

examples/dom/package_manager.cpp

@@ -86,9 +86,8 @@ int main() {
 
   auto render = [&]() {
     std::vector<Element> entries;
-    for (auto& task : displayed_task) {
+    for (auto& task : displayed_task)
       entries.push_back(renderTask(task));
-    }
 
     return vbox({
         // List of tasks.
@@ -139,9 +138,8 @@ int main() {
     std::this_thread::sleep_for(0.01s);
 
     // Exit
-    if (nb_active + nb_queued == 0) {
+    if (nb_active + nb_queued == 0)
       break;
-    }
 
     // Update the model for the next frame.
     updateModel();

examples/dom/spinner.cpp

@@ -21,9 +21,8 @@ int main() {
   for (int index = 0; index < 200; ++index) {
     std::vector<Element> entries;
     for (int i = 0; i < 23; ++i) {
-      if (i != 0) {
+      if (i != 0)
         entries.push_back(separator());
-      }
       entries.push_back(  //
           hbox({
               text(std::to_string(i)) | size(WIDTH, EQUAL, 2),

include/ftxui/component/component.hpp

@@ -8,7 +8,6 @@
 #include <memory>      // for make_shared, shared_ptr
 #include <utility>     // for forward
 
-#include <ftxui/util/warn_windows_macro.hpp>
 #include "ftxui/component/component_base.hpp"  // for Component, Components
 #include "ftxui/component/component_options.hpp"  // for ButtonOption, CheckboxOption, MenuOption
 #include "ftxui/dom/elements.hpp"  // for Element

include/ftxui/component/component_options.hpp

@@ -9,13 +9,20 @@
 #include <ftxui/dom/direction.hpp>  // for Direction, Direction::Left, Direction::Right, Direction::Down
 #include <ftxui/dom/elements.hpp>  // for Element, separator
 #include <ftxui/util/ref.hpp>      // for Ref, ConstRef, StringRef
-#include <ftxui/util/warn_windows_macro.hpp>
 #include <functional>              // for function
 #include <string>                  // for string
 
 #include "ftxui/component/component_base.hpp"  // for Component
 #include "ftxui/screen/color.hpp"  // for Color, Color::GrayDark, Color::White
 
+#if defined(max)
+#undef max
+#endif
+
+#if defined(min)
+#undef min
+#endif
+
 namespace ftxui {
 
 /// @brief arguments for transform from |ButtonOption|, |CheckboxOption|,

include/ftxui/component/receiver.hpp

@@ -4,7 +4,6 @@
 #ifndef FTXUI_COMPONENT_RECEIVER_HPP_
 #define FTXUI_COMPONENT_RECEIVER_HPP_
 
-#include <ftxui/util/warn_windows_macro.h>
 #include <algorithm>           // for copy, max
 #include <atomic>              // for atomic, __atomic_base
 #include <condition_variable>  // for condition_variable

include/ftxui/component/screen_interactive.hpp

@@ -25,7 +25,7 @@ using Component = std::shared_ptr<ComponentBase>;
 class ScreenInteractivePrivate;
 
 namespace task {
-class TaskRunner;
+  class TaskRunner;
 }
 
 /// @brief ScreenInteractive is a `Screen` that can handle events, run a main
@@ -43,11 +43,10 @@ class ScreenInteractive : public Screen {
   static ScreenInteractive TerminalOutput();
 
   // Destructor.
-  ~ScreenInteractive() override;
+  ~ScreenInteractive();
 
   // Options. Must be called before Loop().
   void TrackMouse(bool enable = true);
-  void HandlePipedInput(bool enable = true);
 
   // Return the currently active screen, nullptr if none.
   static ScreenInteractive* Active();
@@ -101,8 +100,6 @@ class ScreenInteractive : public Screen {
   void Draw(Component component);
   void ResetCursorPosition();
 
-  void InstallPipedInputHandling();
-
   void Signal(int signal);
 
   void FetchTerminalEvents();
@@ -120,7 +117,6 @@ class ScreenInteractive : public Screen {
                     int dimx,
                     int dimy,
                     bool use_alternative_screen);
-
   const Dimension dimension_;
   const bool use_alternative_screen_;
 
@@ -145,9 +141,6 @@ class ScreenInteractive : public Screen {
   bool force_handle_ctrl_c_ = true;
   bool force_handle_ctrl_z_ = true;
 
-  // Piped input handling state (POSIX only)
-  bool handle_piped_input_ = true;
-
   // The style of the cursor to restore on exit.
   int cursor_reset_shape_ = 1;
 
@@ -175,6 +168,7 @@ class ScreenInteractive : public Screen {
 
   Component component_;
 
+
  public:
   class Private {
    public:

include/ftxui/util/warn_windows_macro.hpp

@@ -1,18 +0,0 @@
-// 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.
-
-#ifndef FTXUI_UTIL_WARN_WINDOWS_MACRO_H_
-#define FTXUI_UTIL_WARN_WINDOWS_MACRO_H_
-
-#ifdef min
-#error \
-    "The macro 'min' is defined, which conflicts with the standard C++ library and FTXUI. This is often caused by including <windows.h>. To fix this, add '#define NOMINMAX' before including <windows.h>, or pass '/DNOMINMAX' as a compiler flag."
-#endif
-
-#ifdef max
-#error \
-    "The macro 'max' is defined, which conflicts with the standard C++ library and FTXUI. This is often caused by including <windows.h>. To fix this, add '#define NOMINMAX' before including <windows.h>, or pass '/DNOMINMAX' as a compiler flag."
-#endif
-
-#endif  // FTXUI_UTIL_WARN_WINDOWS_MACRO_H_

src/ftxui/component/component_fuzzer.cpp

@@ -23,9 +23,8 @@ bool GeneratorBool(const char*& data, size_t& size) {
 
 std::string GeneratorString(const char*& data, size_t& size) {
   int index = 0;
-  while (index < size && data[index]) {
+  while (index < size && data[index])
     ++index;
-  }
 
   auto out = std::string(data, data + index);
   data += index;
@@ -41,9 +40,8 @@ std::string GeneratorString(const char*& data, size_t& size) {
 }
 
 int GeneratorInt(const char* data, size_t size) {
-  if (size == 0) {
+  if (size == 0)
     return 0;
-  }
   auto out = int(data[0]);
   data++;
   size--;
@@ -115,9 +113,8 @@ Components GeneratorComponents(const char*& data, size_t& size, int depth);
 Component GeneratorComponent(const char*& data, size_t& size, int depth) {
   depth--;
   int value = GeneratorInt(data, size);
-  if (depth <= 0) {
+  if (depth <= 0)
     return Button(GeneratorString(data, size), [] {});
-  }
 
   constexpr int value_max = 19;
   value = (value % value_max + value_max) % value_max;

src/ftxui/component/screen_interactive.cpp

@@ -372,18 +372,6 @@ void ScreenInteractive::TrackMouse(bool enable) {
   track_mouse_ = enable;
 }
 
-/// @brief Enable or disable automatic piped input handling.
-/// When enabled, FTXUI will detect piped input and redirect stdin from /dev/tty
-/// for keyboard input, allowing applications to read piped data while still
-/// receiving interactive keyboard events.
-/// @param enable Whether to enable piped input handling. Default is true.
-/// @note This must be called before Loop().
-/// @note This feature is enabled by default.
-/// @note This feature is only available on POSIX systems (Linux/macOS).
-void ScreenInteractive::HandlePipedInput(bool enable) {
-  handle_piped_input_ = enable;
-}
-
 /// @brief Add a task to the main loop.
 /// It will be executed later, after every other scheduled tasks.
 void ScreenInteractive::Post(Task task) {
@@ -670,55 +658,11 @@ void ScreenInteractive::Install() {
   // ensure it is fully applied:
   Flush();
 
-  // Redirect the true terminal to stdin, so that we can read keyboard input
-  // directly from stdin, even if the input is piped from a file or another
-  // process.
-  //
-  // TODO: Instead of redirecting stdin, we could define the file descriptor to
-  // read from, and use it in the TerminalInputParser.
-  InstallPipedInputHandling();
-
   quit_ = false;
 
   PostAnimationTask();
 }
 
-void ScreenInteractive::InstallPipedInputHandling() {
-#if !defined(_WIN32) && !defined(__EMSCRIPTEN__)
-  // Handle piped input redirection if explicitly enabled by the application.
-  // This allows applications to read data from stdin while still receiving
-  // keyboard input from the terminal for interactive use.
-  if (!handle_piped_input_) {
-    return;
-  }
-
-  // If stdin is a terminal, we don't need to redirect it.
-  if (isatty(STDIN_FILENO)) {
-    return;
-  }
-
-  // Save the current stdin so we can restore it later.
-  int original_fd = dup(STDIN_FILENO);
-  if (original_fd < 0) {
-    return;
-  }
-
-  // Redirect stdin to the controlling terminal for keyboard input.
-  if (std::freopen("/dev/tty", "r", stdin) == nullptr) {
-    // Failed to open /dev/tty (containers, headless systems, etc.)
-    // Clean up and continue without redirection
-    close(original_fd);
-    return;
-  }
-
-  // Restore the original stdin file descriptor on exit.
-  on_exit_functions.emplace([=] {
-    dup2(original_fd, STDIN_FILENO);
-    close(original_fd);
-  });
-#endif
-}
-
 // private
 void ScreenInteractive::Uninstall() {
   ExitNow();
@@ -1113,9 +1057,8 @@ void ScreenInteractive::FetchTerminalEvents() {
       case KEY_EVENT: {
         auto key_event = r.Event.KeyEvent;
         // ignore UP key events
-        if (key_event.bKeyDown == FALSE) {
+        if (key_event.bKeyDown == FALSE)
           continue;
-        }
         std::wstring wstring;
         wstring += key_event.uChar.UnicodeChar;
         for (auto it : to_string(wstring)) {

src/ftxui/component/screen_interactive_piped_input_test.cpp

@@ -1,220 +0,0 @@
-// 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 <gtest/gtest.h>
-#include <unistd.h>
-#include <fcntl.h>
-#include <cstdio>
-#include <sys/stat.h>
-
-#include "ftxui/component/component.hpp"
-#include "ftxui/component/screen_interactive.hpp"
-#include "ftxui/dom/elements.hpp"
-
-#if !defined(_WIN32) && !defined(__EMSCRIPTEN__)
-
-namespace ftxui {
-
-namespace {
-
-// Test fixture for piped input functionality
-class PipedInputTest : public ::testing::Test {
- protected:
-  void SetUp() override {
-    // Save original stdin for restoration
-    original_stdin_ = dup(STDIN_FILENO);
-  }
-
-  void TearDown() override {
-    // Restore original stdin
-    if (original_stdin_ >= 0) {
-      dup2(original_stdin_, STDIN_FILENO);
-      close(original_stdin_);
-    }
-  }
-
-  // Create a pipe and redirect stdin to read from it
-  void SetupPipedStdin() {
-    if (pipe(pipe_fds_) == 0) {
-      dup2(pipe_fds_[0], STDIN_FILENO);
-      close(pipe_fds_[0]);
-      // Keep write end open for writing test data
-      piped_stdin_setup_ = true;
-    }
-  }
-
-  // Write test data to the piped stdin
-  void WriteToPipedStdin(const std::string& data) {
-    if (piped_stdin_setup_) {
-      write(pipe_fds_[1], data.c_str(), data.length());
-      close(pipe_fds_[1]); // Close write end to signal EOF
-    }
-  }
-
-  // Check if /dev/tty is available (not available in some CI environments)
-  bool IsTtyAvailable() {
-    struct stat st;
-    return stat("/dev/tty", &st) == 0;
-  }
-
- private:
-  int original_stdin_ = -1;
-  int pipe_fds_[2] = {-1, -1};
-  bool piped_stdin_setup_ = false;
-};
-
-TEST_F(PipedInputTest, DefaultBehaviorEnabled) {
-  // Test that HandlePipedInput is enabled by default
-  if (!IsTtyAvailable()) {
-    GTEST_SKIP() << "/dev/tty not available in this environment";
-  }
-
-  auto screen = ScreenInteractive::TerminalOutput();
-  auto component = Renderer([] { return text("test"); });
-
-  SetupPipedStdin();
-  WriteToPipedStdin("test data\n");
-
-  // Install should redirect stdin since HandlePipedInput is on by default
-  screen.Install();
-
-  // Stdin should be the tty
-  EXPECT_TRUE(isatty(STDIN_FILENO));
-
-  screen.Uninstall();
-}
-
-TEST_F(PipedInputTest, ExplicitlyDisabled) {
-  // Test that explicitly disabling works
-  auto screen = ScreenInteractive::TerminalOutput();
-  screen.HandlePipedInput(false);
-  auto component = Renderer([] { return text("test"); });
-
-  SetupPipedStdin();
-  WriteToPipedStdin("test data\n");
-
-  screen.Install();
-  
-  // Stdin should still be the pipe since feature is disabled
-  EXPECT_FALSE(isatty(STDIN_FILENO));
-  
-  screen.Uninstall();
-}
-
-TEST_F(PipedInputTest, ExplicitlyEnabled) {
-  if (!IsTtyAvailable()) {
-    GTEST_SKIP() << "/dev/tty not available in this environment";
-  }
-
-  auto screen = ScreenInteractive::TerminalOutput();
-  screen.HandlePipedInput(true); // Explicitly enable
-  auto component = Renderer([] { return text("test"); });
-
-  SetupPipedStdin();
-  WriteToPipedStdin("test data\n");
-
-  // Before install: stdin should be piped
-  EXPECT_FALSE(isatty(STDIN_FILENO));
-
-  screen.Install();
-  
-  // After install with piped input handling: stdin should be redirected to tty
-  EXPECT_TRUE(isatty(STDIN_FILENO));
-  
-  screen.Uninstall();
-  
-  // After uninstall: stdin should be restored to original state
-  // Note: This will be the pipe we set up, so it should be non-tty
-  EXPECT_FALSE(isatty(STDIN_FILENO));
-}
-
-TEST_F(PipedInputTest, NormalStdinUnchanged) {
-  // Test that normal stdin (not piped) is not affected
-  auto screen = ScreenInteractive::TerminalOutput();
-  auto component = Renderer([] { return text("test"); });
-
-  // Don't setup piped stdin - use normal stdin
-  bool original_isatty = isatty(STDIN_FILENO);
-
-  screen.Install();
-  
-  // Stdin should remain unchanged
-  EXPECT_EQ(original_isatty, isatty(STDIN_FILENO));
-  
-  screen.Uninstall();
-  
-  // Stdin should still be unchanged
-  EXPECT_EQ(original_isatty, isatty(STDIN_FILENO));
-}
-
-TEST_F(PipedInputTest, MultipleInstallUninstallCycles) {
-  if (!IsTtyAvailable()) {
-    GTEST_SKIP() << "/dev/tty not available in this environment";
-  }
-
-  auto screen = ScreenInteractive::TerminalOutput();
-  auto component = Renderer([] { return text("test"); });
-
-  SetupPipedStdin();
-  WriteToPipedStdin("test data\n");
-
-  // First cycle
-  screen.Install();
-  EXPECT_TRUE(isatty(STDIN_FILENO));
-  screen.Uninstall();
-  EXPECT_FALSE(isatty(STDIN_FILENO));
-
-  // Second cycle should work the same
-  screen.Install();
-  EXPECT_TRUE(isatty(STDIN_FILENO));
-  screen.Uninstall();
-  EXPECT_FALSE(isatty(STDIN_FILENO));
-}
-
-TEST_F(PipedInputTest, HandlePipedInputMethodBehavior) {
-  auto screen = ScreenInteractive::TerminalOutput();
-  
-  // Test method can be called multiple times
-  screen.HandlePipedInput(true);
-  screen.HandlePipedInput(false);
-  screen.HandlePipedInput(true);
-  
-  // Should be enabled after last call
-  SetupPipedStdin();
-  WriteToPipedStdin("test data\n");
-
-  if (IsTtyAvailable()) {
-    screen.Install();
-    EXPECT_TRUE(isatty(STDIN_FILENO));
-    screen.Uninstall();
-  }
-}
-
-// Test the graceful fallback when /dev/tty is not available
-// This test simulates environments like containers where /dev/tty might not exist
-TEST_F(PipedInputTest, GracefulFallbackWhenTtyUnavailable) {
-  auto screen = ScreenInteractive::TerminalOutput();
-  auto component = Renderer([] { return text("test"); });
-
-  SetupPipedStdin();
-  WriteToPipedStdin("test data\n");
-
-  // This test doesn't directly mock /dev/tty unavailability since that's hard to do
-  // in a unit test environment, but the code path handles freopen() failure gracefully
-  screen.Install();
-  
-  // The behavior depends on whether /dev/tty is available
-  // If available, stdin gets redirected; if not, it remains piped
-  // Both behaviors are correct
-  
-  screen.Uninstall();
-  
-  // After uninstall, stdin should be restored
-  EXPECT_FALSE(isatty(STDIN_FILENO)); // Should still be our test pipe
-}
-
-}  // namespace
-
-}  // namespace ftxui
-
-#endif  // !defined(_WIN32) && !defined(__EMSCRIPTEN__)

src/ftxui/component/screen_interactive_test.cpp

@@ -28,9 +28,8 @@ namespace {
 class StdCapture {
  public:
   explicit StdCapture(std::string* captured) : captured_(captured) {
-    if (pipe(pipefd_) != 0) {
+    if (pipe(pipefd_) != 0)
       return;
-    }
     old_stdout_ = dup(fileno(stdout));
     fflush(stdout);
     dup2(pipefd_[1], fileno(stdout));

src/ftxui/component/task.cpp

@@ -17,3 +17,4 @@ bool PendingTask::operator<(const PendingTask& other) const {
   return time.value() > other.time.value();
 }
 } // namespace ftxui::task
+

src/ftxui/component/task_internal.hpp

@@ -21,7 +21,8 @@ struct PendingTask {
 
   // Delayed task with a duration
   PendingTask(Task t, std::chrono::steady_clock::duration duration)
-      : task(std::move(t)), time(std::chrono::steady_clock::now() + duration) {}
+      : task(std::move(t)),
+        time(std::chrono::steady_clock::now() + duration) {}
 
   /// The task to be executed.
   Task task;
@@ -37,4 +38,5 @@ struct PendingTask {
 
 } // namespace ftxui::task
 
+
 #endif  // TASK_HPP_

src/ftxui/component/task_queue.cpp

@@ -51,3 +51,4 @@ auto TaskQueue::Get() -> MaybeTask {
 }
 
 } // namespace ftxui::task
+

src/ftxui/component/task_queue.hpp

@@ -25,7 +25,9 @@ struct TaskQueue {
       std::variant<Task, std::chrono::steady_clock::duration, std::monostate>;
   auto Get() -> MaybeTask;
 
-  bool HasImmediateTasks() const { return !immediate_tasks_.empty(); }
+  bool HasImmediateTasks() const {
+    return !immediate_tasks_.empty();
+  }
 
  private:
   std::queue<PendingTask> immediate_tasks_;
@@ -34,4 +36,5 @@ struct TaskQueue {
 
 } // namespace ftxui::task
 
+
 #endif

src/ftxui/component/task_runner.cpp

@@ -20,6 +20,7 @@ TaskRunner::~TaskRunner() {
   current_task_runner = previous_task_runner_;
 }
 
+
 // static
 auto TaskRunner::Current() -> TaskRunner* {
   assert(current_task_runner);
@@ -73,3 +74,4 @@ auto TaskRunner::Run() -> void {
 }
 
 } // namespace ftxui::task
+

src/ftxui/component/task_runner.hpp

@@ -21,8 +21,8 @@ class TaskRunner {
   auto PostTask(Task task) -> void;
 
   /// Schedules a task to be executed after a certain duration.
-  auto PostDelayedTask(Task task, std::chrono::steady_clock::duration duration)
+  auto PostDelayedTask(Task task,
-      -> void;
+                       std::chrono::steady_clock::duration duration) -> void;
 
   /// Runs the tasks in the queue, return the delay until the next delayed task
   /// can be executed.
@@ -31,7 +31,9 @@ class TaskRunner {
   // Runs the tasks in the queue, blocking until all tasks are executed.
   auto Run() -> void;
 
-  bool HasImmediateTasks() const { return queue_.HasImmediateTasks(); }
+  bool HasImmediateTasks() const {
+    return queue_.HasImmediateTasks();
+  }
 
   size_t ExecutedTasks() const { return executed_tasks_; }
 
@@ -43,4 +45,5 @@ class TaskRunner {
 
 } // namespace ftxui::task
 
+
 #endif  // TASK_RUNNER_HPP

src/ftxui/component/terminal_input_parser_test.cpp

@@ -17,19 +17,16 @@ namespace ftxui {
 // Test char |c| to are trivially converted into |Event::Character(c)|.
 TEST(Event, Character) {
   std::vector<char> basic_char;
-  for (char c = 'a'; c <= 'z'; ++c) {
+  for (char c = 'a'; c <= 'z'; ++c)
     basic_char.push_back(c);
-  }
+  for (char c = 'A'; c <= 'Z'; ++c)
-  for (char c = 'A'; c <= 'Z'; ++c) {
     basic_char.push_back(c);
-  }
 
   std::vector<Event> received_events;
   auto parser = TerminalInputParser(
       [&](Event event) { received_events.push_back(std::move(event)); });
-  for (char c : basic_char) {
+  for (char c : basic_char)
     parser.Add(c);
-  }
 
   for (size_t i = 0; i < basic_char.size(); ++i) {
     EXPECT_TRUE(received_events[i].is_character());
@@ -288,9 +285,8 @@ TEST(Event, UTF8) {
     std::vector<Event> received_events;
     auto parser = TerminalInputParser(
         [&](Event event) { received_events.push_back(std::move(event)); });
-    for (auto input : test.input) {
+    for (auto input : test.input)
       parser.Add(input);
-    }
 
     if (test.valid) {
       EXPECT_EQ(1, received_events.size());
@@ -319,9 +315,8 @@ TEST(Event, Control) {
   };
   std::vector<TestCase> cases;
   for (int i = 0; i < 32; ++i) {
-    if (i == 8 || i == 13 || i == 24 || i == 26 || i == 27) {
+    if (i == 8 || i == 13 || i == 24 || i == 26 || i == 27)
       continue;
-    }
     cases.push_back({char(i), false});
   }
   cases.push_back({char(24), false});
@@ -346,9 +341,8 @@ TEST(Event, Control) {
 TEST(Event, Special) {
   auto str = [](std::string input) {
     std::vector<unsigned char> output;
-    for (auto it : input) {
+    for (auto it : input)
       output.push_back(it);
-    }
     return output;
   };
 
@@ -357,12 +351,9 @@ TEST(Event, Special) {
     Event expected;
   } kTestCase[] = {
       // Arrow (default cursor mode)
-      {str(""), Event::ArrowUp},
+      {str(""), Event::ArrowUp},    {str(""), Event::ArrowDown},
-      {str(""), Event::ArrowDown},
+      {str(""), Event::ArrowRight}, {str(""), Event::ArrowLeft},
-      {str(""), Event::ArrowRight},
+      {str(""), Event::Home},       {str(""), Event::End},
-      {str(""), Event::ArrowLeft},
-      {str(""), Event::Home},
-      {str(""), Event::End},
 
       // Arrow (application cursor mode)
       {str("\x1BOA"), Event::ArrowUp},

src/ftxui/screen/screen.cpp

@@ -47,9 +47,8 @@ namespace {
 #if defined(_WIN32)
 void WindowsEmulateVT100Terminal() {
   static bool done = false;
-  if (done) {
+  if (done)
     return;
-  }
   done = true;
 
   // Enable VT processing on stdout and stdin

src/ftxui/screen/string.cpp

@@ -1284,9 +1284,8 @@ bool IsCombining(uint32_t ucs) {
 }
 
 bool IsFullWidth(uint32_t ucs) {
-  if (ucs < 0x0300) {  // Quick path: // NOLINT
+  if (ucs < 0x0300)  // Quick path: // NOLINT
     return false;
-  }
 
   return Bisearch(ucs, g_full_width_characters);
 }

tools/license_headers.cpp

@@ -1,4 +1,4 @@
-// Copyright 2025 Arthur Sonzogni. All rights reserved.
+// 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.