src/ftxui/dom/table.cpp

Go to the documentation of this file.

// 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 "ftxui/dom/table.hpp"
 
#include <algorithm>         // for max
#include <initializer_list>  // for initializer_list
#include <memory>   // for allocator, shared_ptr, allocator_traits<>::value_type
#include <utility>  // for move, swap
#include <vector>   // for vector
 
#include "ftxui/dom/elements.hpp"  // for Element, operator|, text, separatorCharacter, Elements, BorderStyle, Decorator, emptyElement, size, gridbox, EQUAL, flex, flex_shrink, HEIGHT, WIDTH
 
namespace ftxui {
namespace {
 
bool IsCell(int x, int y) {
  return x % 2 == 1 && y % 2 == 1;
}
 
// NOLINTNEXTLINE
static std::string table_charset[6][6] = {
    {"┌", "┐", "└", "┘", "─", "│"},  // LIGHT
    {"┏", "┓", "┗", "┛", "╍", "╏"},  // DASHED
    {"┏", "┓", "┗", "┛", "━", "┃"},  // HEAVY
    {"╔", "╗", "╚", "╝", "═", "║"},  // DOUBLE
    {"╭", "╮", "╰", "╯", "─", "│"},  // ROUNDED
    {" ", " ", " ", " ", " ", " "},  // EMPTY
};
 
// 將負索引解析為從結尾開始計算。
int Wrap(int input, int modulo) {
  return input < 0 ? input + modulo : input;
}
 
bool InRange(int input, int modulo) {
  return input >= 0 && input < modulo;
}
 
void Order(int& a, int& b) {
  if (a >= b) {
    std::swap(a, b);
  }
}
 
}  // namespace
 
/// @brief 創建一個空表格。
Table::Table() {
  Initialize({});
}
 
/// @brief 從一個字串向量的向量創建一個表格。
/// @param input 輸入資料。
Table::Table(const std::vector<std::vector<std::string>>& input) {
  std::vector<std::vector<Element>> output;
  output.reserve(input.size());
  for (const auto& row : input) {
    output.emplace_back();
    auto& output_row = output.back();
    output_row.reserve(row.size());
    for (const auto& cell : row) {
      output_row.push_back(text(std::move(cell)));
    }
  }
  Initialize(std::move(output));
}
 
/// @brief 從一個 Element 向量的向量創建一個表格
/// @param input 輸入元素。
Table::Table(std::vector<std::vector<Element>> input) {
  Initialize(std::move(input));
}
 
/// @brief 從字串串列的串列建立表格。
/// @param init 輸入資料。
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());
  input_dim_x_ = 0;
  for (auto& row : input) {
    input_dim_x_ = std::max(input_dim_x_, int(row.size()));
  }
 
  dim_y_ = 2 * input_dim_y_ + 1;
  dim_x_ = 2 * input_dim_x_ + 1;
 
  // 保留空間。
  elements_.resize(dim_y_);
  for (int y = 0; y < dim_y_; ++y) {
    elements_[y].resize(dim_x_);
  }
 
  // 將 elements_ 從 |input| 移轉到 |elements_|。
  {
    int y = 1;
    for (auto& row : input) {
      int x = 1;
      for (auto& cell : row) {
        elements_[y][x] = std::move(cell);
        x += 2;
      }
      y += 2;
    }
  }
 
  // 為邊框加入空元素。
  for (int y = 0; y < dim_y_; ++y) {
    for (int x = 0; x < dim_x_; ++x) {
      auto& element = elements_[y][x];
 
      if (IsCell(x, y)) {
        if (!element) {
          element = emptyElement();
        }
        continue;
      }
 
      element = emptyElement();
    }
  }
}
 
/// @brief 選取表格的某一行。
/// @param index 要選取的行的索引。
/// @note 您可以使用負數索引從末尾選取。
TableSelection Table::SelectRow(int index) {
  return SelectRectangle(0, -1, index, index);
}
 
/// @brief 選取表格的行範圍。
/// @param row_min 要選取的第一行。
/// @param row_max 要選取的最後一行。
/// @note 您可以使用負數索引從末尾選取。
TableSelection Table::SelectRows(int row_min, int row_max) {
  return SelectRectangle(0, -1, row_min, row_max);
}
 
/// @brief 選取表格的某一列。
/// @param index 要選取的列的索引。
/// @note 您可以使用負數索引從末尾選取。
TableSelection Table::SelectColumn(int index) {
  return SelectRectangle(index, index, 0, -1);
}
 
/// @brief 選取表格的列範圍。
/// @param column_min 要選取的第一列。
/// @param column_max 要選取的最後一列。
/// @note 您可以使用負數索引從末尾選取。
TableSelection Table::SelectColumns(int column_min, int column_max) {
  return SelectRectangle(column_min, column_max, 0, -1);
}
 
/// @brief 選取表格的一個單元格。
/// @param column 要選取的單元格的列。
/// @param row 要選取的單元格的行。
/// @note 您可以使用負數索引從末尾選取。
TableSelection Table::SelectCell(int column, int row) {
  return SelectRectangle(column, column, row, row);
}
 
/// @brief 選取表格的一個矩形區域。
/// @param column_min 要選取的第一列。
/// @param column_max 要選取的最後一列。
/// @param row_min 要選取的第一行。
/// @param row_max 要選取的最後一行。
/// @note 您可以使用負數索引從末尾選取。
TableSelection Table::SelectRectangle(int column_min,
                                      int column_max,
                                      int row_min,
                                      int row_max) {
  TableSelection output;  // NOLINT
  output.table_ = this;
 
  column_min = Wrap(column_min, input_dim_x_);
  column_max = Wrap(column_max, input_dim_x_);
  row_min = Wrap(row_min, input_dim_y_);
  row_max = Wrap(row_max, input_dim_y_);
 
  // 超出範圍的索引不選取任何內容。
  if (!InRange(column_min, input_dim_x_) ||
      !InRange(column_max, input_dim_x_) || !InRange(row_min, input_dim_y_) ||
      !InRange(row_max, input_dim_y_)) {
    output.x_min_ = 0;
    output.x_max_ = -1;
    output.y_min_ = 0;
    output.y_max_ = -1;
    return output;
  }
 
  Order(column_min, column_max);
  Order(row_min, row_max);
 
  output.x_min_ = 2 * column_min;
  output.x_max_ = 2 * column_max + 2;
  output.y_min_ = 2 * row_min;
  output.y_max_ = 2 * row_max + 2;
  return output;
}
 
/// @brief 選取整個表格。
TableSelection Table::SelectAll() {
  TableSelection output;  // NOLINT
  output.table_ = this;
  output.x_min_ = 0;
  output.x_max_ = dim_x_ - 1;
  output.y_min_ = 0;
  output.y_max_ = dim_y_ - 1;
  return output;
}
 
/// @brief 渲染表格。
/// @return 渲染後的表格。這是一個你可以繪製的元素。
Element Table::Render() {
  for (int y = 0; y < dim_y_; ++y) {
    for (int x = 0; x < dim_x_; ++x) {
      auto& it = elements_[y][x];
 
      // Line
      if ((x + y) % 2 == 1) {
        it = std::move(it) | flex;
        continue;
      }
 
      // Cells
      if ((x % 2) == 1 && (y % 2) == 1) {
        it = std::move(it) | flex_shrink;
        continue;
      }
 
      // Corners
      it = std::move(it) | size(WIDTH, EQUAL, 0) | size(HEIGHT, EQUAL, 0);
    }
  }
  dim_x_ = 0;
  dim_y_ = 0;
  return gridbox(std::move(elements_));
}
 
/// @brief 將 `decorator` 應用於選取範圍。
/// 這會裝飾單元格、線條和角落。
/// @param decorator 要應用的裝飾器。
// NOLINTNEXTLINE
void TableSelection::Decorate(const Decorator& decorator) {
  for (int y = y_min_; y <= y_max_; ++y) {
    for (int x = x_min_; x <= x_max_; ++x) {
      Element& e = table_->elements_[y][x];
      e = std::move(e) | decorator;
    }
  }
}
 
/// @brief 將 `decorator` 應用於選取範圍。
/// 這只會裝飾單元格。
/// @param decorator 要應用的裝飾器。
// NOLINTNEXTLINE
void TableSelection::DecorateCells(const Decorator& decorator) {
  for (int y = y_min_; y <= y_max_; ++y) {
    for (int x = x_min_; x <= x_max_; ++x) {
      if (y % 2 == 1 && x % 2 == 1) {
        Element& e = table_->elements_[y][x];
        e = std::move(e) | decorator;
      }
    }
  }
}
 
/// @brief 將 `decorator` 應用於選取範圍。
/// 這只會裝飾模數為 `modulo`，偏移量為 `shift` 的線條。
/// @param decorator 要應用的裝飾器。
/// @param modulo 要裝飾線條的模數。
/// @param shift 要裝飾線條的偏移量。
// NOLINTNEXTLINE
void TableSelection::DecorateAlternateColumn(const Decorator& decorator,
                                             int modulo,
                                             int shift) {
  for (int y = y_min_; y <= y_max_; ++y) {
    for (int x = x_min_; x <= x_max_; ++x) {
      if (y % 2 == 1 && (x / 2) % modulo == shift) {
        Element& e = table_->elements_[y][x];
        e = std::move(e) | decorator;
      }
    }
  }
}
 
/// @brief 將 `decorator` 應用於選取範圍。
/// 這只會裝飾模數為 `modulo`，偏移量為 `shift` 的線條。
/// @param decorator 要應用的裝飾器。
/// @param modulo 要裝飾線條的模數。
/// @param shift 要裝飾線條的偏移量。
// NOLINTNEXTLINE
void TableSelection::DecorateAlternateRow(const Decorator& decorator,
                                          int modulo,
                                          int shift) {
  for (int y = y_min_ + 1; y <= y_max_ - 1; ++y) {
    for (int x = x_min_; x <= x_max_; ++x) {
      if (y % 2 == 1 && (y / 2) % modulo == shift) {
        Element& e = table_->elements_[y][x];
        e = std::move(e) | decorator;
      }
    }
  }
}
 
/// @brief 將 `decorator` 應用於選取範圍。
/// 這只會裝飾模數為 `modulo`，偏移量為 `shift` 的角落。
/// @param decorator 要應用的裝飾器。
/// @param modulo 要裝飾角落的模數。
/// @param shift 要裝飾角落的偏移量。
// NOLINTNEXTLINE
void TableSelection::DecorateCellsAlternateColumn(const Decorator& decorator,
                                                  int modulo,
                                                  int shift) {
  for (int y = y_min_; y <= y_max_; ++y) {
    for (int x = x_min_; x <= x_max_; ++x) {
      if (y % 2 == 1 && x % 2 == 1 && ((x / 2) % modulo == shift)) {
        Element& e = table_->elements_[y][x];
        e = std::move(e) | decorator;
      }
    }
  }
}
 
/// @brief 將 `decorator` 應用於選取範圍。
/// 這只會裝飾模數為 `modulo`，偏移量為 `shift` 的角落。
/// @param decorator 要應用的裝飾器。
/// @param modulo 要裝飾角落的模數。
/// @param shift 要裝飾角落的偏移量。
// NOLINTNEXTLINE
void TableSelection::DecorateCellsAlternateRow(const Decorator& decorator,
                                               int modulo,
                                               int shift) {
  for (int y = y_min_; y <= y_max_; ++y) {
    for (int x = x_min_; x <= x_max_; ++x) {
      if (y % 2 == 1 && x % 2 == 1 && ((y / 2) % modulo == shift)) {
        Element& e = table_->elements_[y][x];
        e = std::move(e) | decorator;
      }
    }
  }
}
 
/// @brief 將 `decorator` 套用到選取範圍的邊框上。
/// @param decorator 要套用的裝飾器。
void TableSelection::DecorateBorder(const Decorator& decorator) {
  for (int x = x_min_; x <= x_max_; ++x) {
    table_->elements_[y_min_][x] =
        std::move(table_->elements_[y_min_][x]) | decorator;
    table_->elements_[y_max_][x] =
        std::move(table_->elements_[y_max_][x]) | decorator;
  }
  for (int y = y_min_ + 1; y <= y_max_ - 1; ++y) {
    table_->elements_[y][x_min_] =
        std::move(table_->elements_[y][x_min_]) | decorator;
    table_->elements_[y][x_max_] =
        std::move(table_->elements_[y][x_max_]) | decorator;
  }
}
 
/// @brief 將 `decorator` 套用到選取範圍的左邊框上。
/// @param decorator 要套用的裝飾器。
void TableSelection::DecorateBorderLeft(const Decorator& decorator) {
  for (int y = y_min_; y <= y_max_; y++) {
    table_->elements_[y][x_min_] =
        std::move(table_->elements_[y][x_min_]) | decorator;
  }
}
 
/// @brief 將 `decorator` 套用到選取範圍的右邊框上。
/// @param decorator 要套用的裝飾器。
void TableSelection::DecorateBorderRight(const Decorator& decorator) {
  for (int y = y_min_; y <= y_max_; y++) {
    table_->elements_[y][x_max_] =
        std::move(table_->elements_[y][x_max_]) | decorator;
  }
}
 
/// @brief 將 `decorator` 套用到選取範圍的上邊框上。
/// @param decorator 要套用的裝飾器。
void TableSelection::DecorateBorderTop(const Decorator& decorator) {
  for (int x = x_min_; x <= x_max_; x++) {
    table_->elements_[y_min_][x] =
        std::move(table_->elements_[y_min_][x]) | decorator;
  }
}
 
/// @brief 將 `decorator` 套用到選取範圍的下邊框上。
/// @param decorator 要套用的裝飾器。
void TableSelection::DecorateBorderBottom(const Decorator& decorator) {
  for (int x = x_min_; x <= x_max_; x++) {
    table_->elements_[y_max_][x] =
        std::move(table_->elements_[y_max_][x]) | decorator;
  }
}
 
/// @brief 將 `decorator` 套用到選取範圍的分隔線上。
/// @param decorator 要套用的裝飾器。
void TableSelection::DecorateSeparator(const Decorator& decorator) {
  for (int y = y_min_ + 1; y <= y_max_ - 1; ++y) {
    for (int x = x_min_ + 1; x <= x_max_ - 1; ++x) {
      if (y % 2 == 0 || x % 2 == 0) {
        table_->elements_[y][x] =
            std::move(table_->elements_[y][x]) | decorator;
      }
    }
  }
}
 
/// @brief 將 `decorator` 套用到選取範圍的垂直分隔線上。
/// @param decorator 要套用的裝飾器。
void TableSelection::DecorateSeparatorVertical(const Decorator& decorator) {
  for (int y = y_min_ + 1; y <= y_max_ - 1; ++y) {
    for (int x = x_min_ + 1; x <= x_max_ - 1; ++x) {
      if (x % 2 == 0) {
        table_->elements_[y][x] =
            std::move(table_->elements_[y][x]) | decorator;
      }
    }
  }
}
 
/// @brief 將 `decorator` 套用到選取範圍的水平分隔線上。
/// @param decorator 要套用的裝飾器。
void TableSelection::DecorateSeparatorHorizontal(const Decorator& decorator) {
  for (int y = y_min_ + 1; y <= y_max_ - 1; ++y) {
    for (int x = x_min_ + 1; x <= x_max_ - 1; ++x) {
      if (y % 2 == 0) {
        table_->elements_[y][x] =
            std::move(table_->elements_[y][x]) | decorator;
      }
    }
  }
}
 
/// @brief 在選取範圍周圍應用 `border`。
/// @param border 要應用的邊框樣式。
void TableSelection::Border(BorderStyle border) {
  if (x_min_ > x_max_ || y_min_ > y_max_) {
    return;
  }
 
  BorderLeft(border);
  BorderRight(border);
  BorderTop(border);
  BorderBottom(border);
 
  // NOLINTNEXTLINE
  table_->elements_[y_min_][x_min_] =
      text(table_charset[border][0]) | automerge;
  // NOLINTNEXTLINE
  table_->elements_[y_min_][x_max_] =
      text(table_charset[border][1]) | automerge;
  // NOLINTNEXTLINE
  table_->elements_[y_max_][x_min_] =
      text(table_charset[border][2]) | automerge;
  // NOLINTNEXTLINE
  table_->elements_[y_max_][x_max_] =
      text(table_charset[border][3]) | automerge;
}
 
/// @brief 在選取範圍周圍套用 `border`。
/// @param border 要套用的邊框樣式。
/// @param decorator 要套用的裝飾器。
void TableSelection::Border(BorderStyle border, const Decorator& decorator) {
  Border(border);
  DecorateBorder(decorator);
}
 
/// @brief 在選取範圍內繪製一些分隔線。
/// @param border 要應用的邊框樣式。
void TableSelection::Separator(BorderStyle border) {
  for (int y = y_min_ + 1; y <= y_max_ - 1; ++y) {
    for (int x = x_min_ + 1; x <= x_max_ - 1; ++x) {
      if (y % 2 == 0 || x % 2 == 0) {
        Element& e = table_->elements_[y][x];
        e = (y % 2 == 1) ? separatorCharacter(table_charset[border][5]) |
                               automerge  // NOLINT
                         : separatorCharacter(table_charset[border][4]) |
                               automerge;  // NOLINT
      }
    }
  }
}
 
/// @brief 在選取範圍中繪製一些分隔線。
/// @param border 要套用的邊框樣式。
/// @param decorator 要套用的裝飾器。
void TableSelection::Separator(BorderStyle border, const Decorator& decorator) {
  Separator(border);
  DecorateSeparator(decorator);
}
 
/// @brief 在選取範圍內繪製一些垂直分隔線。
/// @param border 要應用的邊框樣式。
void TableSelection::SeparatorVertical(BorderStyle border) {
  for (int y = y_min_ + 1; y <= y_max_ - 1; ++y) {
    for (int x = x_min_ + 1; x <= x_max_ - 1; ++x) {
      if (x % 2 == 0) {
        table_->elements_[y][x] =
            separatorCharacter(table_charset[border][5]) | automerge;  // NOLINT
      }
    }
  }
}
 
/// @brief 在選取範圍中繪製一些垂直分隔線。
/// @param border 要套用的邊框樣式。
/// @param decorator 要套用的裝飾器。
void TableSelection::SeparatorVertical(BorderStyle border,
                                       const Decorator& decorator) {
  SeparatorVertical(border);
  DecorateSeparatorVertical(decorator);
}
 
/// @brief 在選取範圍內繪製一些水平分隔線。
/// @param border 要應用的邊框樣式。
void TableSelection::SeparatorHorizontal(BorderStyle border) {
  for (int y = y_min_ + 1; y <= y_max_ - 1; ++y) {
    for (int x = x_min_ + 1; x <= x_max_ - 1; ++x) {
      if (y % 2 == 0) {
        table_->elements_[y][x] =
            separatorCharacter(table_charset[border][4]) | automerge;  // NOLINT
      }
    }
  }
}
 
/// @brief 在選取範圍中繪製一些水平分隔線。
/// @param border 要套用的邊框樣式。
/// @param decorator 要套用的裝飾器。
void TableSelection::SeparatorHorizontal(BorderStyle border,
                                         const Decorator& decorator) {
  SeparatorHorizontal(border);
  DecorateSeparatorHorizontal(decorator);
}
 
/// @brief 在選取範圍的左側繪製一些分隔線。
/// @param border 要應用的邊框樣式。
void TableSelection::BorderLeft(BorderStyle border) {
  for (int y = y_min_; y <= y_max_; y++) {
    table_->elements_[y][x_min_] =
        separatorCharacter(table_charset[border][5]) | automerge;  // NOLINT
  }
}
 
/// @brief 在選取範圍的左側繪製一些分隔線。
/// @param border 要套用的邊框樣式。
/// @param decorator 要套用的裝飾器。
void TableSelection::BorderLeft(BorderStyle border,
                                const Decorator& decorator) {
  BorderLeft(border);
  DecorateBorderLeft(decorator);
}
 
/// @brief 在選取範圍的右側繪製一些分隔線。
/// @param border 要應用的邊框樣式。
void TableSelection::BorderRight(BorderStyle border) {
  for (int y = y_min_; y <= y_max_; y++) {
    table_->elements_[y][x_max_] =
        separatorCharacter(table_charset[border][5]) | automerge;  // NOLINT
  }
}
 
/// @brief 在選取範圍的右側繪製一些分隔線。
/// @param border 要套用的邊框樣式。
/// @param decorator 要套用的裝飾器。
void TableSelection::BorderRight(BorderStyle border,
                                 const Decorator& decorator) {
  BorderRight(border);
  DecorateBorderRight(decorator);
}
 
/// @brief 在選取範圍的頂部繪製一些分隔線。
/// @param border 要應用的邊框樣式。
void TableSelection::BorderTop(BorderStyle border) {
  for (int x = x_min_; x <= x_max_; x++) {
    table_->elements_[y_min_][x] =
        separatorCharacter(table_charset[border][4]) | automerge;  // NOLINT
  }
}
 
/// @brief 在選取範圍的上側繪製一些分隔線。
/// @param border 要套用的邊框樣式。
/// @param decorator 要套用的裝飾器。
void TableSelection::BorderTop(BorderStyle border, const Decorator& decorator) {
  BorderTop(border);
  DecorateBorderTop(decorator);
}
 
/// @brief 在選取範圍的底部繪製一些分隔線。
/// @param border 要應用的邊框樣式。
void TableSelection::BorderBottom(BorderStyle border) {
  for (int x = x_min_; x <= x_max_; x++) {
    table_->elements_[y_max_][x] =
        separatorCharacter(table_charset[border][4]) | automerge;  // NOLINT
  }
}
 
/// @brief 在選取範圍的下側繪製一些分隔線。
/// @param border 要套用的邊框樣式。
/// @param decorator 要套用的裝飾器。
void TableSelection::BorderBottom(BorderStyle border,
                                  const Decorator& decorator) {
  BorderBottom(border);
  DecorateBorderBottom(decorator);
}
 
}  // namespace ftxui