FTXUI 6.1.9 C++ functional terminal UI.

Loading...
Searching...
No Matches
src/ftxui/dom/table.cpp
Go to the documentation of this file.
1// Copyright 2021 Arthur Sonzogni. All rights reserved.
2// Use of this source code is governed by the MIT license that can be found in
3// the LICENSE file.
4#include "ftxui/dom/table.hpp"
5
6#include <algorithm> // for max
7#include <initializer_list> // for initializer_list
8#include <memory> // for allocator, shared_ptr, allocator_traits<>::value_type
9#include <utility> // for move, swap
10#include <vector> // for vector
11
12#include "ftxui/dom/elements.hpp" // for Element, operator|, text, separatorCharacter, Elements, BorderStyle, Decorator, emptyElement, size, gridbox, EQUAL, flex, flex_shrink, HEIGHT, WIDTH
13
14 namespace ftxui {
15 namespace {
16
17 bool IsCell(int x, int y) {
18 return x % 2 == 1 && y % 2 == 1;
19}
20
21// NOLINTNEXTLINE
22 static std::string charset[6][6] = {
23 {"┌", "┐", "└", "┘", "─", "│"}, // LIGHT
24 {"┏", "┓", "┗", "┛", "╍", "╏"}, // DASHED
25 {"┏", "┓", "┗", "┛", "━", "┃"}, // HEAVY
26 {"╔", "╗", "╚", "╝", "═", "║"}, // DOUBLE
27 {"╭", "╮", "╰", "╯", "─", "│"}, // ROUNDED
28 {" ", " ", " ", " ", " ", " "}, // EMPTY
29};
30
31 int Wrap(int input, int modulo) {
32 input %= modulo;
33 input += modulo;
34 input %= modulo;
35 return input;
36}
37
38 void Order(int& a, int& b) {
39 if (a >= b) {
40 std::swap(a, b);
41 }
42}
43
44} // namespace
45
46/// @brief Create an empty table.
47 Table::Table() {
48 Initialize({});
49}
50
51/// @brief Create a table from a vector of vector of string.
52/// @param input The input data.
53 Table::Table(std::vector<std::vector<std::string>> input) {
54 std::vector<std::vector<Element>> output;
55 output.reserve(input.size());
56 for (auto& row : input) {
57 output.emplace_back();
58 auto& output_row = output.back();
59 output_row.reserve(row.size());
60 for (auto& cell : row) {
61 output_row.push_back(text(std::move(cell)));
62 }
63 }
64 Initialize(std::move(output));
65}
66
67/// @brief Create a table from a vector of vector of Element
68/// @param input The input elements.
69 Table::Table(std::vector<std::vector<Element>> input) {
70 Initialize(std::move(input));
71}
72
73// @brief Create a table from a list of list of string.
74// @param init The input data.
75 Table::Table(std::initializer_list<std::vector<std::string>> init) {
76 std::vector<std::vector<Element>> input;
77 for (const auto& row : init) {
78 std::vector<Element> output_row;
79 output_row.reserve(row.size());
80 for (const auto& cell : row) {
81 output_row.push_back(text(cell));
82 }
83 input.push_back(std::move(output_row));
84 }
85 Initialize(std::move(input));
86}
87
88// private
89 void Table::Initialize(std::vector<std::vector<Element>> input) {
90 input_dim_y_ = static_cast<int>(input.size());
91 input_dim_x_ = 0;
92 for (auto& row : input) {
93 input_dim_x_ = std::max(input_dim_x_, int(row.size()));
94 }
95
96 dim_y_ = 2 * input_dim_y_ + 1;
97 dim_x_ = 2 * input_dim_x_ + 1;
98
99 // Reserve space.
100 elements_.resize(dim_y_);
101 for (int y = 0; y < dim_y_; ++y) {
102 elements_[y].resize(dim_x_);
103 }
104
105 // Transfert elements_ from |input| toward |elements_|.
106 {
107 int y = 1;
108 for (auto& row : input) {
109 int x = 1;
110 for (auto& cell : row) {
111 elements_[y][x] = std::move(cell);
112 x += 2;
113 }
114 y += 2;
115 }
116 }
117
118 // Add empty element for the border.
119 for (int y = 0; y < dim_y_; ++y) {
120 for (int x = 0; x < dim_x_; ++x) {
121 auto& element = elements_[y][x];
122
123 if (IsCell(x, y)) {
124 if (!element) {
125 element = emptyElement();
126 }
127 continue;
128 }
129
130 element = emptyElement();
131 }
132 }
133}
134
135/// @brief Select a row of the table.
136/// @param index The index of the row to select.
137/// @note You can use negative index to select from the end.
138 TableSelection Table::SelectRow(int index) {
139 return SelectRectangle(0, -1, index, index);
140}
141
142/// @brief Select a range of rows of the table.
143/// @param row_min The first row to select.
144/// @param row_max The last row to select.
145/// @note You can use negative index to select from the end.
146 TableSelection Table::SelectRows(int row_min, int row_max) {
147 return SelectRectangle(0, -1, row_min, row_max);
148}
149
150/// @brief Select a column of the table.
151/// @param index The index of the column to select.
152/// @note You can use negative index to select from the end.
153 TableSelection Table::SelectColumn(int index) {
154 return SelectRectangle(index, index, 0, -1);
155}
156
157/// @brief Select a range of columns of the table.
158/// @param column_min The first column to select.
159/// @param column_max The last column to select.
160/// @note You can use negative index to select from the end.
161 TableSelection Table::SelectColumns(int column_min, int column_max) {
162 return SelectRectangle(column_min, column_max, 0, -1);
163}
164
165/// @brief Select a cell of the table.
166/// @param column The column of the cell to select.
167/// @param row The row of the cell to select.
168/// @note You can use negative index to select from the end.
169 TableSelection Table::SelectCell(int column, int row) {
170 return SelectRectangle(column, column, row, row);
171}
172
173/// @brief Select a rectangle of the table.
174/// @param column_min The first column to select.
175/// @param column_max The last column to select.
176/// @param row_min The first row to select.
177/// @param row_max The last row to select.
178/// @note You can use negative index to select from the end.
179 TableSelection Table::SelectRectangle(int column_min,
180 int column_max,
181 int row_min,
182 int row_max) {
183 column_min = Wrap(column_min, input_dim_x_);
184 column_max = Wrap(column_max, input_dim_x_);
185 Order(column_min, column_max);
186 row_min = Wrap(row_min, input_dim_y_);
187 row_max = Wrap(row_max, input_dim_y_);
188 Order(row_min, row_max);
189
190 TableSelection output; // NOLINT
191 output.table_ = this;
192 output.x_min_ = 2 * column_min;
193 output.x_max_ = 2 * column_max + 2;
194 output.y_min_ = 2 * row_min;
195 output.y_max_ = 2 * row_max + 2;
196 return output;
197}
198
199/// @brief Select all the table.
200 TableSelection Table::SelectAll() {
201 TableSelection output; // NOLINT
202 output.table_ = this;
203 output.x_min_ = 0;
204 output.x_max_ = dim_x_ - 1;
205 output.y_min_ = 0;
206 output.y_max_ = dim_y_ - 1;
207 return output;
208}
209
210/// @brief Render the table.
211/// @return The rendered table. This is an element you can draw.
212 Element Table::Render() {
213 for (int y = 0; y < dim_y_; ++y) {
214 for (int x = 0; x < dim_x_; ++x) {
215 auto& it = elements_[y][x];
216
217 // Line
218 if ((x + y) % 2 == 1) {
219 it = std::move(it) | flex;
220 continue;
221 }
222
223 // Cells
224 if ((x % 2) == 1 && (y % 2) == 1) {
225 it = std::move(it) | flex_shrink;
226 continue;
227 }
228
229 // Corners
230 it = std::move(it) | size(WIDTH, EQUAL, 0) | size(HEIGHT, EQUAL, 0);
231 }
232 }
233 dim_x_ = 0;
234 dim_y_ = 0;
235 return gridbox(std::move(elements_));
236}
237
238/// @brief Apply the `decorator` to the selection.
239/// This decorate both the cells, the lines and the corners.
240/// @param decorator The decorator to apply.
241// NOLINTNEXTLINE
242 void TableSelection::Decorate(Decorator decorator) {
243 for (int y = y_min_; y <= y_max_; ++y) {
244 for (int x = x_min_; x <= x_max_; ++x) {
245 Element& e = table_->elements_[y][x];
246 e = std::move(e) | decorator;
247 }
248 }
249}
250
251/// @brief Apply the `decorator` to the selection.
252/// @param decorator The decorator to apply.
253/// This decorate only the cells.
254// NOLINTNEXTLINE
255 void TableSelection::DecorateCells(Decorator decorator) {
256 for (int y = y_min_; y <= y_max_; ++y) {
257 for (int x = x_min_; x <= x_max_; ++x) {
258 if (y % 2 == 1 && x % 2 == 1) {
259 Element& e = table_->elements_[y][x];
260 e = std::move(e) | decorator;
261 }
262 }
263 }
264}
265
266/// @brief Apply the `decorator` to the selection.
267/// This decorate only the lines modulo `modulo` with a shift of `shift`.
268/// @param decorator The decorator to apply.
269/// @param modulo The modulo of the lines to decorate.
270/// @param shift The shift of the lines to decorate.
271// NOLINTNEXTLINE
272 void TableSelection::DecorateAlternateColumn(Decorator decorator,
273 int modulo,
274 int shift) {
275 for (int y = y_min_; y <= y_max_; ++y) {
276 for (int x = x_min_; x <= x_max_; ++x) {
277 if (y % 2 == 1 && (x / 2) % modulo == shift) {
278 Element& e = table_->elements_[y][x];
279 e = std::move(e) | decorator;
280 }
281 }
282 }
283}
284
285/// @brief Apply the `decorator` to the selection.
286/// This decorate only the lines modulo `modulo` with a shift of `shift`.
287/// @param decorator The decorator to apply.
288/// @param modulo The modulo of the lines to decorate.
289/// @param shift The shift of the lines to decorate.
290// NOLINTNEXTLINE
291 void TableSelection::DecorateAlternateRow(Decorator decorator,
292 int modulo,
293 int shift) {
294 for (int y = y_min_ + 1; y <= y_max_ - 1; ++y) {
295 for (int x = x_min_; x <= x_max_; ++x) {
296 if (y % 2 == 1 && (y / 2) % modulo == shift) {
297 Element& e = table_->elements_[y][x];
298 e = std::move(e) | decorator;
299 }
300 }
301 }
302}
303
304/// @brief Apply the `decorator` to the selection.
305/// This decorate only the corners modulo `modulo` with a shift of `shift`.
306/// @param decorator The decorator to apply.
307/// @param modulo The modulo of the corners to decorate.
308/// @param shift The shift of the corners to decorate.
309// NOLINTNEXTLINE
310 void TableSelection::DecorateCellsAlternateColumn(Decorator decorator,
311 int modulo,
312 int shift) {
313 for (int y = y_min_; y <= y_max_; ++y) {
314 for (int x = x_min_; x <= x_max_; ++x) {
315 if (y % 2 == 1 && x % 2 == 1 && ((x / 2) % modulo == shift)) {
316 Element& e = table_->elements_[y][x];
317 e = std::move(e) | decorator;
318 }
319 }
320 }
321}
322
323/// @brief Apply the `decorator` to the selection.
324/// This decorate only the corners modulo `modulo` with a shift of `shift`.
325/// @param decorator The decorator to apply.
326/// @param modulo The modulo of the corners to decorate.
327/// @param shift The shift of the corners to decorate.
328// NOLINTNEXTLINE
329 void TableSelection::DecorateCellsAlternateRow(Decorator decorator,
330 int modulo,
331 int shift) {
332 for (int y = y_min_; y <= y_max_; ++y) {
333 for (int x = x_min_; x <= x_max_; ++x) {
334 if (y % 2 == 1 && x % 2 == 1 && ((y / 2) % modulo == shift)) {
335 Element& e = table_->elements_[y][x];
336 e = std::move(e) | decorator;
337 }
338 }
339 }
340}
341
342/// @brief Apply a `border` around the selection.
343/// @param border The border style to apply.
344 void TableSelection::Border(BorderStyle border) {
345 BorderLeft(border);
346 BorderRight(border);
347 BorderTop(border);
348 BorderBottom(border);
349
350 // NOLINTNEXTLINE
351 table_->elements_[y_min_][x_min_] = text(charset[border][0]) | automerge;
352 // NOLINTNEXTLINE
353 table_->elements_[y_min_][x_max_] = text(charset[border][1]) | automerge;
354 // NOLINTNEXTLINE
355 table_->elements_[y_max_][x_min_] = text(charset[border][2]) | automerge;
356 // NOLINTNEXTLINE
357 table_->elements_[y_max_][x_max_] = text(charset[border][3]) | automerge;
358}
359
360/// @brief Draw some separator lines in the selection.
361/// @param border The border style to apply.
362 void TableSelection::Separator(BorderStyle border) {
363 for (int y = y_min_ + 1; y <= y_max_ - 1; ++y) {
364 for (int x = x_min_ + 1; x <= x_max_ - 1; ++x) {
365 if (y % 2 == 0 || x % 2 == 0) {
366 Element& e = table_->elements_[y][x];
367 e = (y % 2 == 1)
368 ? separatorCharacter(charset[border][5]) | automerge // NOLINT
369 : separatorCharacter(charset[border][4]) | automerge; // NOLINT
370 }
371 }
372 }
373}
374
375/// @brief Draw some vertical separator lines in the selection.
376/// @param border The border style to apply.
377 void TableSelection::SeparatorVertical(BorderStyle border) {
378 for (int y = y_min_ + 1; y <= y_max_ - 1; ++y) {
379 for (int x = x_min_ + 1; x <= x_max_ - 1; ++x) {
380 if (x % 2 == 0) {
381 table_->elements_[y][x] =
382 separatorCharacter(charset[border][5]) | automerge; // NOLINT
383 }
384 }
385 }
386}
387
388/// @brief Draw some horizontal separator lines in the selection.
389/// @param border The border style to apply.
390 void TableSelection::SeparatorHorizontal(BorderStyle border) {
391 for (int y = y_min_ + 1; y <= y_max_ - 1; ++y) {
392 for (int x = x_min_ + 1; x <= x_max_ - 1; ++x) {
393 if (y % 2 == 0) {
394 table_->elements_[y][x] =
395 separatorCharacter(charset[border][4]) | automerge; // NOLINT
396 }
397 }
398 }
399}
400
401/// @brief Draw some separator lines to the left side of the selection.
402/// @param border The border style to apply.
403 void TableSelection::BorderLeft(BorderStyle border) {
404 for (int y = y_min_; y <= y_max_; y++) {
405 table_->elements_[y][x_min_] =
406 separatorCharacter(charset[border][5]) | automerge; // NOLINT
407 }
408}
409
410/// @brief Draw some separator lines to the right side of the selection.
411/// @param border The border style to apply.
412 void TableSelection::BorderRight(BorderStyle border) {
413 for (int y = y_min_; y <= y_max_; y++) {
414 table_->elements_[y][x_max_] =
415 separatorCharacter(charset[border][5]) | automerge; // NOLINT
416 }
417}
418
419/// @brief Draw some separator lines to the top side of the selection.
420/// @param border The border style to apply.
421 void TableSelection::BorderTop(BorderStyle border) {
422 for (int x = x_min_; x <= x_max_; x++) {
423 table_->elements_[y_min_][x] =
424 separatorCharacter(charset[border][4]) | automerge; // NOLINT
425 }
426}
427
428/// @brief Draw some separator lines to the bottom side of the selection.
429/// @param border The border style to apply.
430 void TableSelection::BorderBottom(BorderStyle border) {
431 for (int x = x_min_; x <= x_max_; x++) {
432 table_->elements_[y_max_][x] =
433 separatorCharacter(charset[border][4]) | automerge; // NOLINT
434 }
435}
436
437} // namespace ftxui
ftxui::TableSelection
Definition table.hpp:64
ftxui::TableSelection::DecorateAlternateColumn
void DecorateAlternateColumn(Decorator, int modulo=2, int shift=0)
Apply the decorator to the selection. This decorate only the lines modulo modulo with a shift of shif...
Definition src/ftxui/dom/table.cpp:272
ftxui::TableSelection::SeparatorVertical
void SeparatorVertical(BorderStyle border=LIGHT)
Draw some vertical separator lines in the selection.
Definition src/ftxui/dom/table.cpp:377
ftxui::TableSelection::DecorateCells
void DecorateCells(Decorator)
Apply the decorator to the selection.
Definition src/ftxui/dom/table.cpp:255
ftxui::TableSelection::BorderLeft
void BorderLeft(BorderStyle border=LIGHT)
Draw some separator lines to the left side of the selection.
Definition src/ftxui/dom/table.cpp:403
ftxui::TableSelection::DecorateCellsAlternateColumn
void DecorateCellsAlternateColumn(Decorator, int modulo=2, int shift=0)
Apply the decorator to the selection. This decorate only the corners modulo modulo with a shift of sh...
Definition src/ftxui/dom/table.cpp:310
ftxui::TableSelection::Decorate
void Decorate(Decorator)
Apply the decorator to the selection. This decorate both the cells, the lines and the corners.
Definition src/ftxui/dom/table.cpp:242
ftxui::TableSelection::DecorateAlternateRow
void DecorateAlternateRow(Decorator, int modulo=2, int shift=0)
Apply the decorator to the selection. This decorate only the lines modulo modulo with a shift of shif...
Definition src/ftxui/dom/table.cpp:291
ftxui::TableSelection::BorderTop
void BorderTop(BorderStyle border=LIGHT)
Draw some separator lines to the top side of the selection.
Definition src/ftxui/dom/table.cpp:421
ftxui::TableSelection::Separator
void Separator(BorderStyle border=LIGHT)
Draw some separator lines in the selection.
Definition src/ftxui/dom/table.cpp:362
ftxui::TableSelection::BorderBottom
void BorderBottom(BorderStyle border=LIGHT)
Draw some separator lines to the bottom side of the selection.
Definition src/ftxui/dom/table.cpp:430
ftxui::TableSelection::DecorateCellsAlternateRow
void DecorateCellsAlternateRow(Decorator, int modulo=2, int shift=0)
Apply the decorator to the selection. This decorate only the corners modulo modulo with a shift of sh...
Definition src/ftxui/dom/table.cpp:329
ftxui::TableSelection::BorderRight
void BorderRight(BorderStyle border=LIGHT)
Draw some separator lines to the right side of the selection.
Definition src/ftxui/dom/table.cpp:412
ftxui::TableSelection::Border
void Border(BorderStyle border=LIGHT)
Apply a border around the selection.
Definition src/ftxui/dom/table.cpp:344
ftxui::TableSelection::SeparatorHorizontal
void SeparatorHorizontal(BorderStyle border=LIGHT)
Draw some horizontal separator lines in the selection.
Definition src/ftxui/dom/table.cpp:390
elements.hpp
Wrap
Component Wrap(std::string name, Component component)
Definition gallery.cpp:18
ftxui::Table::Render
Element Render()
Render the table.
Definition src/ftxui/dom/table.cpp:212
ftxui::Table::Table
Table()
Create an empty table.
Definition src/ftxui/dom/table.cpp:47
ftxui::Table::SelectCell
TableSelection SelectCell(int column, int row)
Select a cell of the table.
Definition src/ftxui/dom/table.cpp:169
ftxui::Table::SelectColumn
TableSelection SelectColumn(int column_index)
Select a column of the table.
Definition src/ftxui/dom/table.cpp:153
ftxui::Table::SelectRow
TableSelection SelectRow(int row_index)
Select a row of the table.
Definition src/ftxui/dom/table.cpp:138
ftxui::Table::SelectColumns
TableSelection SelectColumns(int column_min, int column_max)
Select a range of columns of the table.
Definition src/ftxui/dom/table.cpp:161
ftxui::Table::SelectRows
TableSelection SelectRows(int row_min, int row_max)
Select a range of rows of the table.
Definition src/ftxui/dom/table.cpp:146
ftxui::Table::SelectAll
TableSelection SelectAll()
Select all the table.
Definition src/ftxui/dom/table.cpp:200
ftxui::Table::SelectRectangle
TableSelection SelectRectangle(int column_min, int column_max, int row_min, int row_max)
Select a rectangle of the table.
Definition src/ftxui/dom/table.cpp:179
ftxui::size
Decorator size(WidthOrHeight, Constraint, int value)
Apply a constraint on the size of an element.
Definition src/ftxui/dom/size.cpp:89
ftxui::flex
Element flex(Element)
Make a child element to expand proportionally to the space left in a container.
Definition flex.cpp:123
ftxui::emptyElement
Element emptyElement()
Definition dom/util.cpp:140
ftxui::flex_shrink
Element flex_shrink(Element)
Minimize if needed.
Definition flex.cpp:159
ftxui::text
Element text(std::wstring text)
Display a piece of unicode text.
Definition text.cpp:160
ftxui::separatorCharacter
Element separatorCharacter(std::string)
Draw a vertical or horizontal separation in between two other elements.
Definition src/ftxui/dom/separator.cpp:395
ftxui::automerge
Element automerge(Element child)
Enable character to be automatically merged with others nearby.
Definition automerge.cpp:17
ftxui::BorderStyle
BorderStyle
BorderStyle is an enumeration that represents the different styles of borders that can be applied to ...
Definition elements.hpp:35
ftxui
The FTXUI ftxui:: namespace.
Definition animation.hpp:10
ftxui::HEIGHT
@ HEIGHT
Definition elements.hpp:161
ftxui::WIDTH
@ WIDTH
Definition elements.hpp:161
ftxui::Decorator
std::function< Element(Element)> Decorator
Definition elements.hpp:24
ftxui::Element
std::shared_ptr< Node > Element
Definition elements.hpp:22
ftxui::gridbox
Element gridbox(std::vector< Elements > lines)
A container displaying a grid of elements.
Definition src/ftxui/dom/gridbox.cpp:173
ftxui::EQUAL
@ EQUAL
Definition elements.hpp:162
table.hpp