Merge baa5973128 into fcd050c017

To avoid burdening the user with explicit type construction when using
the library, we can use a constructor that accepts an initializer list
(std::initializer_list). This allows users to pass initializer lists
directly without having to wrap them in
std::vector<std::vector<std::string>>. This resolves the ambiguous case
when the inner list contains only two elements.

Bug:https://github.com/ArthurSonzogni/FTXUI/issues/912

cmake/ftxui_set_options.cmake

@@ -49,6 +49,12 @@ function(ftxui_set_options library)
     target_compile_options(${library} PUBLIC "/utf-8")
   endif()
 
+  # CMake does automatically add -fPIC when linking a shared library, but it
+  # does not add it when linking a static library. This is a problem when the 
+  # static library is later linked into a shared library. 
+  # Doing it helps some users.
+  set_property(TARGET ${library} PROPERTY POSITION_INDEPENDENT_CODE ON)
+
   # Add as many warning as possible:
   if (WIN32)
     if (MSVC)

include/ftxui/dom/table.hpp

@@ -38,6 +38,7 @@ class Table {
   Table();
   explicit Table(std::vector<std::vector<std::string>>);
   explicit Table(std::vector<std::vector<Element>>);
+  Table(std::initializer_list<std::vector<std::string>> init);
   TableSelection SelectAll();
   TableSelection SelectCell(int column, int row);
   TableSelection SelectRow(int row_index);

src/ftxui/dom/table.cpp

@@ -71,6 +71,22 @@ Table::Table(std::vector<std::vector<Element>> input) {
   Initialize(std::move(input));
 }
 
+// @brief Create a table from a list of list of string.
+// @param init The input data.
+// @ingroup dom
+Table::Table(std::initializer_list<std::vector<std::string>> init) {
+  std::vector<std::vector<Element>> input;
+  for (const auto& row : init) {
+    std::vector<Element> output_row;
+    output_row.reserve(row.size());
+    for (const auto& cell : row) {
+      output_row.push_back(text(cell));
+    }
+    input.push_back(std::move(output_row));
+  }
+  Initialize(std::move(input));
+}
+
 // private
 void Table::Initialize(std::vector<std::vector<Element>> input) {
   input_dim_y_ = static_cast<int>(input.size());

src/ftxui/dom/table_test.cpp

@@ -733,5 +733,17 @@ TEST(TableTest, Merge) {
       screen.ToString());
 }
 
+TEST(TableTest, Issue912) {
+  Table({
+      {"a"},
+  });
+  Table({
+      {"a", "b"},
+  });
+  Table({
+      {"a", "b", "c"},
+  });
+}
+
 }  // namespace ftxui
 // NOLINTEND

src/ftxui/screen/terminal.cpp

@@ -48,25 +48,38 @@ Dimensions& FallbackSize() {
   return g_fallback_size;
 }
 
-const char* Safe(const char* c) {
-  return (c != nullptr) ? c : "";
-}
-
 bool Contains(const std::string& s, const char* key) {
   return s.find(key) != std::string::npos;
 }
 
+// https://github.com/gabime/spdlog/blob/885b5473e291833b148eeac3b7ce227e582cd88b/include/spdlog/details/os-inl.h#L566
+std::string getenv_safe(const char *field) {
+#if defined(_MSC_VER)
+#if defined(__cplusplus_winrt)
+  return std::string{};  // not supported under uwp
+#else
+  size_t len = 0;
+  char buf[1024];
+  bool ok = ::getenv_s(&len, buf, sizeof(buf), field) == 0;
+  return ok ? buf : std::string{};
+#endif
+#else  // revert to getenv
+  char *buf = ::getenv(field); // NOLINT(*-mt-unsafe)
+  return buf ? buf : std::string{};
+#endif
+}
+
 Terminal::Color ComputeColorSupport() {
 #if defined(__EMSCRIPTEN__)
   return Terminal::Color::TrueColor;
 #endif
 
-  std::string COLORTERM = Safe(std::getenv("COLORTERM"));  // NOLINT
+  std::string COLORTERM = getenv_safe("COLORTERM");
   if (Contains(COLORTERM, "24bit") || Contains(COLORTERM, "truecolor")) {
     return Terminal::Color::TrueColor;
   }
 
-  std::string TERM = Safe(std::getenv("TERM"));  // NOLINT
+  std::string TERM = getenv_safe("TERM");
   if (Contains(COLORTERM, "256") || Contains(TERM, "256")) {
     return Terminal::Color::Palette256;
   }