Branch data Line data Source code
1 : : /* Support for tabular/grid-based content.
2 : : Copyright (C) 2023-2025 Free Software Foundation, Inc.
3 : : Contributed by David Malcolm <dmalcolm@redhat.com>.
4 : :
5 : : This file is part of GCC.
6 : :
7 : : GCC is free software; you can redistribute it and/or modify it under
8 : : the terms of the GNU General Public License as published by the Free
9 : : Software Foundation; either version 3, or (at your option) any later
10 : : version.
11 : :
12 : : GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 : : WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 : : FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15 : : for more details.
16 : :
17 : : You should have received a copy of the GNU General Public License
18 : : along with GCC; see the file COPYING3. If not see
19 : : <http://www.gnu.org/licenses/>. */
20 : :
21 : : #include "config.h"
22 : : #define INCLUDE_VECTOR
23 : : #include "system.h"
24 : : #include "coretypes.h"
25 : : #include "pretty-print.h"
26 : : #include "diagnostic.h"
27 : : #include "selftest.h"
28 : : #include "text-art/selftests.h"
29 : : #include "text-art/table.h"
30 : :
31 : : using namespace text_art;
32 : :
33 : : /* class text_art::table_cell_content. */
34 : :
35 : 2008 : table_cell_content::table_cell_content (styled_string &&s)
36 : 2008 : : m_str (std::move (s)),
37 : : /* We assume here that the content occupies a single canvas row. */
38 : 2008 : m_size (m_str.calc_canvas_width (), 1)
39 : : {
40 : 2008 : }
41 : :
42 : : void
43 : 2327 : table_cell_content::paint_to_canvas (canvas &canvas,
44 : : canvas::coord_t top_left) const
45 : : {
46 : 2327 : canvas.paint_text (top_left, m_str);
47 : 2327 : }
48 : :
49 : : /* struct text_art::table_dimension_sizes. */
50 : :
51 : 365 : table_dimension_sizes::table_dimension_sizes (unsigned num)
52 : 365 : : m_requirements (num, 0)
53 : : {
54 : 365 : }
55 : :
56 : : /* class text_art::table::cell_placement. */
57 : :
58 : : void
59 : 2327 : table::cell_placement::paint_cell_contents_to_canvas(canvas &canvas,
60 : : canvas::coord_t offset,
61 : : const table_geometry &tg) const
62 : : {
63 : 2327 : const canvas::size_t req_canvas_size = get_min_canvas_size ();
64 : 2327 : const canvas::size_t alloc_canvas_size = tg.get_canvas_size (m_rect);
65 : 2327 : gcc_assert (req_canvas_size.w <= alloc_canvas_size.w);
66 : 2327 : gcc_assert (req_canvas_size.h <= alloc_canvas_size.h);
67 : 2327 : const int x_padding = alloc_canvas_size.w - req_canvas_size.w;
68 : 2327 : const int y_padding = alloc_canvas_size.h - req_canvas_size.h;
69 : 2327 : const table::coord_t table_top_left = m_rect.m_top_left;
70 : 2327 : const canvas::coord_t canvas_top_left = tg.table_to_canvas (table_top_left);
71 : :
72 : 2327 : gcc_assert (x_padding >= 0);
73 : 2327 : int x_align_offset;
74 : 2327 : switch (m_x_align)
75 : : {
76 : 0 : default:
77 : 0 : gcc_unreachable ();
78 : : case x_align::LEFT:
79 : : x_align_offset = 0;
80 : : break;
81 : 2303 : case x_align::CENTER:
82 : 2303 : x_align_offset = x_padding / 2;
83 : 2303 : break;
84 : 12 : case x_align::RIGHT:
85 : 12 : x_align_offset = x_padding;
86 : 12 : break;
87 : : }
88 : :
89 : 2327 : gcc_assert (y_padding >= 0);
90 : 2327 : int y_align_offset;
91 : 2327 : switch (m_y_align)
92 : : {
93 : 0 : default:
94 : 0 : gcc_unreachable ();
95 : : case y_align::TOP:
96 : : y_align_offset = 0;
97 : : break;
98 : 2303 : case y_align::CENTER:
99 : 2303 : y_align_offset = y_padding / 2;
100 : 2303 : break;
101 : 12 : case y_align::BOTTOM:
102 : 12 : y_align_offset = y_padding;
103 : 12 : break;
104 : : }
105 : 2327 : const canvas::coord_t content_rel_coord
106 : 2327 : (canvas_top_left.x + 1 + x_align_offset,
107 : 2327 : canvas_top_left.y + 1 + y_align_offset);
108 : 2327 : m_content.paint_to_canvas (canvas, offset + content_rel_coord);
109 : 2327 : }
110 : :
111 : : /* class text_art::table. */
112 : :
113 : :
114 : 215 : table::table (size_t size)
115 : 215 : : m_size (size),
116 : 215 : m_placements (),
117 : 215 : m_occupancy (size)
118 : : {
119 : 215 : m_occupancy.fill (-1);
120 : 215 : }
121 : :
122 : : void
123 : 738 : table::set_cell (coord_t coord,
124 : : table_cell_content &&content,
125 : : enum x_align x_align,
126 : : enum y_align y_align)
127 : : {
128 : 738 : set_cell_span (rect_t (coord, table::size_t (1, 1)),
129 : : std::move (content), x_align, y_align);
130 : 738 : }
131 : :
132 : : void
133 : 2090 : table::set_cell_span (rect_t span,
134 : : table_cell_content &&content,
135 : : enum x_align x_align,
136 : : enum y_align y_align)
137 : : {
138 : 2090 : gcc_assert (span.m_size.w > 0);
139 : 2090 : gcc_assert (span.m_size.h > 0);
140 : 2090 : int placement_idx = m_placements.size ();
141 : 2090 : m_placements.emplace_back (cell_placement (span, std::move (content),
142 : 2090 : x_align, y_align));
143 : 4355 : for (int y = span.get_min_y (); y < span.get_next_y (); y++)
144 : 8249 : for (int x = span.get_min_x (); x < span.get_next_x (); x++)
145 : : {
146 : 5984 : gcc_assert (m_occupancy.get (coord_t (x, y)) == -1);
147 : 5984 : m_occupancy.set (coord_t (x, y), placement_idx);
148 : : }
149 : 2090 : }
150 : :
151 : : /* If SPAN is unoccuped, set it to CONTENT.
152 : : Otherwise, discard CONTENT. */
153 : :
154 : : void
155 : 108 : table::maybe_set_cell_span (rect_t span,
156 : : table_cell_content &&content,
157 : : enum x_align x_align,
158 : : enum y_align y_align)
159 : : {
160 : 108 : gcc_assert (span.m_size.w > 0);
161 : 108 : gcc_assert (span.m_size.h > 0);
162 : 194 : for (int y = span.get_min_y (); y < span.get_next_y (); y++)
163 : 194 : for (int x = span.get_min_x (); x < span.get_next_x (); x++)
164 : : {
165 : 108 : if (m_occupancy.get (coord_t (x, y)) != -1)
166 : : return;
167 : : }
168 : 86 : set_cell_span (span, std::move (content), x_align, y_align);
169 : : }
170 : :
171 : : canvas
172 : 76 : table::to_canvas (const theme &theme, const style_manager &sm) const
173 : : {
174 : 76 : table_dimension_sizes col_widths (m_size.w);
175 : 76 : table_dimension_sizes row_heights (m_size.h);
176 : 76 : table_cell_sizes cell_sizes (col_widths, row_heights);
177 : 76 : cell_sizes.pass_1 (*this);
178 : 76 : cell_sizes.pass_2 (*this);
179 : 76 : table_geometry tg (*this, cell_sizes);
180 : 76 : canvas canvas (tg.get_canvas_size (), sm);
181 : 76 : paint_to_canvas (canvas, canvas::coord_t (0, 0), tg, theme);
182 : 76 : return canvas;
183 : 76 : }
184 : :
185 : : void
186 : 221 : table::paint_to_canvas (canvas &canvas,
187 : : canvas::coord_t offset,
188 : : const table_geometry &tg,
189 : : const theme &theme) const
190 : : {
191 : 221 : canvas.fill (canvas::rect_t (offset, tg.get_canvas_size ()),
192 : 221 : styled_unichar (' '));
193 : 221 : paint_cell_borders_to_canvas (canvas, offset, tg, theme);
194 : 221 : paint_cell_contents_to_canvas (canvas, offset, tg);
195 : 221 : }
196 : :
197 : : /* Print this table to stderr. */
198 : :
199 : : DEBUG_FUNCTION void
200 : 0 : table::debug () const
201 : : {
202 : : /* Use a temporary style manager.
203 : : Styles in the table will be meaningless, so
204 : : print the canvas with styling disabled. */
205 : 0 : style_manager sm;
206 : 0 : canvas canvas (to_canvas (unicode_theme (), sm));
207 : 0 : canvas.debug (false);
208 : 0 : }
209 : :
210 : : /* Move OTHER's content this table, starting at OFFSET. */
211 : :
212 : : void
213 : 24 : table::add_other_table (table &&other,
214 : : table::coord_t offset)
215 : : {
216 : 252 : for (auto &&placement : other.m_placements)
217 : : {
218 : 228 : set_cell_span (placement.m_rect + offset,
219 : 228 : std::move (placement.m_content),
220 : : placement.m_x_align,
221 : : placement.m_y_align);
222 : : }
223 : 24 : }
224 : :
225 : : const table::cell_placement *
226 : 362 : table::get_placement_at (coord_t coord) const
227 : : {
228 : 362 : const int placement_idx = m_occupancy.get (coord);
229 : 362 : if (placement_idx == -1)
230 : : return nullptr;
231 : 142 : return &m_placements[placement_idx];
232 : : }
233 : :
234 : : int
235 : 42528 : table::get_occupancy_safe (coord_t coord) const
236 : : {
237 : 42528 : if (coord.x < 0)
238 : : return -1;
239 : 40882 : if (coord.x >= m_size.w)
240 : : return -1;
241 : 39236 : if (coord.y < 0)
242 : : return -1;
243 : 35530 : if (coord.y >= m_size.h)
244 : : return -1;
245 : 31824 : return m_occupancy.get (coord);
246 : : }
247 : :
248 : : /* Determine if the "?" edges need borders for table cell D
249 : : in the following, for the directions relative to "X", based
250 : : on whether each of table cell boundaries AB, CD, AC, and BD
251 : : are boundaries between cell spans:
252 : :
253 : : # up?
254 : : # +-----+-----+
255 : : # | |
256 : : # | ? |
257 : : # | A ? B |
258 : : # | ? |
259 : : # | |
260 : : # left?+ ??? X ??? + right?
261 : : # | |
262 : : # | ? |
263 : : # | C ? D |
264 : : # | ? |
265 : : # | |
266 : : # +-----+-----+
267 : : # down?
268 : : */
269 : :
270 : : directions
271 : 10632 : table::get_connections (int table_x, int table_y) const
272 : : {
273 : 10632 : int cell_a = get_occupancy_safe (coord_t (table_x - 1, table_y - 1));
274 : 10632 : int cell_b = get_occupancy_safe (coord_t (table_x, table_y - 1));
275 : 10632 : int cell_c = get_occupancy_safe (coord_t (table_x - 1, table_y));
276 : 10632 : int cell_d = get_occupancy_safe (coord_t (table_x, table_y));
277 : 10632 : const bool up = (cell_a != cell_b);
278 : 10632 : const bool down = (cell_c != cell_d);
279 : 10632 : const bool left = (cell_a != cell_c);
280 : 10632 : const bool right = (cell_b != cell_d);
281 : 10632 : return directions (up, down, left, right);
282 : : }
283 : :
284 : : /* Paint the grid lines.
285 : :
286 : : Consider painting
287 : : - a grid of cells,
288 : : - plus a right-hand border
289 : : - and a bottom border
290 : :
291 : : Then we need to paint to the canvas like this:
292 : :
293 : : # PER-TABLE-COLUMN R BORDER
294 : : # +-------------------+ +-----+
295 : : #
296 : : # TABLE CELL WIDTH (in canvas units)
297 : : # +-------------+
298 : : # . . . . . . .
299 : : # ...+-----+-----+.+-----+...+-----+ +
300 : : # | U | |.| | | U | |
301 : : # | U | |.| | | U | |
302 : : # |LL+RR|RRRRR|.|RRRRR| |LL+ | |
303 : : # | D | |.| | | D | |
304 : : # | D | |.| | | D | |
305 : : # ...+-----+-----+.+-----+...+-----+ |
306 : : # ..................... ...... +-- PER-TABLE-ROW
307 : : # ...+-----+-----+.+-----+...+-----+ | +
308 : : # | D | |.| | | D | | |
309 : : # | D | |.| | | D | | |
310 : : # | D | |.| | | D | | +---- TABLE CELL HEIGHT (in canvas units)
311 : : # | D | |.| | | D | | |
312 : : # | D | |.| | | D | | |
313 : : # ...+-----+-----+.+-----+...+-----+ + +
314 : : # . . . . . .
315 : : # ...+-----+-----+.+-----+...+-----+ +
316 : : # | D | |.| | | U | |
317 : : # | D | |.| | | U | |
318 : : # |LL+RR|RRRRR|.|RRRRR| |LL+ | | BOTTOM BORDER
319 : : # | | |.| | | | |
320 : : # | | |.| | | | |
321 : : # ...+-----+-----+.+-----+...+-----+ +
322 : :
323 : : where each:
324 : :
325 : : # +-----+
326 : : # | |
327 : : # | |
328 : : # | |
329 : : # | |
330 : : # | |
331 : : # +-----+
332 : :
333 : : is a canvas cell, and the U, L, R, D express the connections
334 : : that are present with neighboring table cells. These affect
335 : : the kinds of borders that we draw for a particular table cell. */
336 : :
337 : : void
338 : 221 : table::paint_cell_borders_to_canvas (canvas &canvas,
339 : : canvas::coord_t offset,
340 : : const table_geometry &tg,
341 : : const theme &theme) const
342 : : {
343 : : /* The per-table-cell left and top borders are either drawn or not,
344 : : but if they are, they aren't affected by per-table-cell connections. */
345 : 221 : const canvas::cell_t left_border
346 : 221 : = theme.get_line_art (directions (true, /* up */
347 : : true, /* down */
348 : : false, /* left */
349 : 221 : false /* right */));
350 : 221 : const canvas::cell_t top_border
351 : 221 : = theme.get_line_art (directions (false, /* up */
352 : : false, /* down */
353 : : true, /* left */
354 : 221 : true)); /* right */
355 : 823 : for (int table_y = 0; table_y < m_size.h; table_y++)
356 : : {
357 : 602 : const int canvas_y = tg.table_y_to_canvas_y (table_y);
358 : 8558 : for (int table_x = 0; table_x < m_size.w; table_x++)
359 : : {
360 : 7956 : canvas::coord_t canvas_top_left
361 : 7956 : = tg.table_to_canvas(table::coord_t (table_x, table_y));
362 : :
363 : 7956 : const directions c (get_connections (table_x, table_y));
364 : :
365 : : /* Paint top-left corner of border, if any. */
366 : 7956 : canvas.paint (offset + canvas_top_left,
367 : 7956 : theme.get_line_art (c));
368 : :
369 : : /* Paint remainder of left border of cell, if any.
370 : : We assume here that the content occupies a single canvas row. */
371 : 7956 : if (c.m_down)
372 : 5484 : canvas.paint (offset + canvas::coord_t (canvas_top_left.x,
373 : 2742 : canvas_y + 1),
374 : : left_border);
375 : :
376 : : /* Paint remainder of top border of cell, if any. */
377 : 7956 : if (c.m_right)
378 : : {
379 : 6002 : const int col_width = tg.get_col_width (table_x);
380 : 27147 : for (int x_offset = 0; x_offset < col_width; x_offset++)
381 : : {
382 : 21145 : const int canvas_x = canvas_top_left.x + 1 + x_offset;
383 : 21145 : canvas.paint (offset + canvas::coord_t (canvas_x, canvas_y),
384 : : top_border);
385 : : }
386 : : }
387 : : }
388 : :
389 : : /* Paint right-hand border of row. */
390 : 602 : const int table_x = m_size.w;
391 : 602 : const int canvas_x = tg.table_x_to_canvas_x (table_x);
392 : 602 : const directions c (get_connections (m_size.w, table_y));
393 : 602 : canvas.paint(offset + canvas::coord_t (canvas_x, canvas_y),
394 : 602 : theme.get_line_art (directions (c.m_up,
395 : 602 : c.m_down,
396 : 602 : c.m_left,
397 : 602 : false))); /* right */
398 : : /* We assume here that the content occupies a single canvas row. */
399 : 602 : canvas.paint(offset + canvas::coord_t (canvas_x, canvas_y + 1),
400 : 602 : theme.get_line_art (directions (c.m_down, /* up */
401 : : c.m_down, /* down */
402 : : false, /* left */
403 : 602 : false))); /* right */
404 : : }
405 : :
406 : : /* Draw bottom border of table. */
407 : 221 : {
408 : 221 : const int canvas_y = tg.get_canvas_size ().h - 1;
409 : 2074 : for (int table_x = 0; table_x < m_size.w; table_x++)
410 : : {
411 : 1853 : const directions c (get_connections (table_x, m_size.h));
412 : 1853 : const int left_canvas_x = tg.table_x_to_canvas_x (table_x);
413 : 1853 : canvas.paint (offset + canvas::coord_t (left_canvas_x, canvas_y),
414 : 1853 : theme.get_line_art (directions (c.m_up,
415 : : false, /* down */
416 : 1853 : c.m_left,
417 : 1853 : c.m_right)));
418 : 1853 : const int col_width = tg.get_col_width (table_x);
419 : 12917 : for (int x_offset = 0; x_offset < col_width; x_offset++)
420 : : {
421 : 11064 : const int canvas_x = left_canvas_x + 1 + x_offset;
422 : 11064 : canvas.paint(offset + canvas::coord_t (canvas_x, canvas_y),
423 : 22128 : theme.get_line_art (directions (false, // up
424 : : false, // down
425 : : c.m_right, // left
426 : 11064 : c.m_right))); // right
427 : : }
428 : : }
429 : :
430 : : /* Bottom-right corner of table. */
431 : 221 : const int table_x = m_size.w;
432 : 221 : const int canvas_x = tg.table_x_to_canvas_x (table_x);
433 : 221 : const directions c (get_connections (m_size.w, m_size.h));
434 : 221 : canvas.paint (offset + canvas::coord_t (canvas_x, canvas_y),
435 : 442 : theme.get_line_art (directions (c.m_up, // up
436 : : false, // down
437 : 221 : c.m_left, // left
438 : 221 : false))); // right
439 : : }
440 : 221 : }
441 : :
442 : : void
443 : 221 : table::paint_cell_contents_to_canvas(canvas &canvas,
444 : : canvas::coord_t offset,
445 : : const table_geometry &tg) const
446 : : {
447 : 2548 : for (auto &placement : m_placements)
448 : 2327 : placement.paint_cell_contents_to_canvas (canvas, offset, tg);
449 : 221 : }
450 : :
451 : : /* class table_cell_sizes. */
452 : :
453 : : /* Consider 1x1 cells. */
454 : :
455 : : void
456 : 217 : table_cell_sizes::pass_1 (const table &table)
457 : : {
458 : 2508 : for (auto &placement : table.m_placements)
459 : 4117 : if (placement.one_by_one_p ())
460 : : {
461 : 1783 : canvas::size_t canvas_size (placement.get_min_canvas_size ());
462 : 1783 : table::coord_t table_coord (placement.m_rect.m_top_left);
463 : 1783 : m_col_widths.require (table_coord.x, canvas_size.w);
464 : 2232 : m_row_heights.require (table_coord.y, canvas_size.h);
465 : : }
466 : 217 : }
467 : :
468 : : /* Consider cells that span more than one row or column. */
469 : :
470 : : void
471 : 217 : table_cell_sizes::pass_2 (const table &table)
472 : : {
473 : 2508 : for (auto &placement : table.m_placements)
474 : 4582 : if (!placement.one_by_one_p ())
475 : : {
476 : 508 : const canvas::size_t req_canvas_size (placement.get_min_canvas_size ());
477 : 508 : const canvas::size_t current_canvas_size
478 : 508 : = get_canvas_size (placement.m_rect);
479 : : /* Grow columns as necessary. */
480 : 508 : if (req_canvas_size.w > current_canvas_size.w)
481 : : {
482 : : /* Spread the deficit amongst the columns. */
483 : 88 : int deficit = req_canvas_size.w - current_canvas_size.w;
484 : 88 : const int per_col = deficit / placement.m_rect.m_size.w;
485 : 88 : for (int table_x = placement.m_rect.get_min_x ();
486 : 327 : table_x < placement.m_rect.get_next_x ();
487 : : table_x++)
488 : : {
489 : 239 : m_col_widths.m_requirements[table_x] += per_col;
490 : 239 : deficit -= per_col;
491 : : }
492 : : /* Make sure we allocate all of the deficit. */
493 : 88 : if (deficit > 0)
494 : : {
495 : 45 : const int table_x = placement.m_rect.get_max_x ();
496 : 45 : m_col_widths.m_requirements[table_x] += deficit;
497 : : }
498 : : }
499 : : /* Grow rows as necessary. */
500 : 508 : if (req_canvas_size.h > current_canvas_size.h)
501 : : {
502 : : /* Spread the deficit amongst the rows. */
503 : 105 : int deficit = req_canvas_size.h - current_canvas_size.h;
504 : 105 : const int per_row = deficit / placement.m_rect.m_size.h;
505 : 105 : for (int table_y = placement.m_rect.get_min_y ();
506 : 210 : table_y < placement.m_rect.get_next_y ();
507 : : table_y++)
508 : : {
509 : 105 : m_row_heights.m_requirements[table_y] += per_row;
510 : 105 : deficit -= per_row;
511 : : }
512 : : /* Make sure we allocate all of the deficit. */
513 : 105 : if (deficit > 0)
514 : : {
515 : 0 : const int table_y = placement.m_rect.get_max_y ();
516 : 0 : m_row_heights.m_requirements[table_y] += deficit;
517 : : }
518 : : }
519 : : }
520 : 217 : }
521 : :
522 : : canvas::size_t
523 : 2835 : table_cell_sizes::get_canvas_size (const table::rect_t &rect) const
524 : : {
525 : 2835 : canvas::size_t result (0, 0);
526 : 12836 : for (int table_x = rect.get_min_x ();
527 : 12836 : table_x < rect.get_next_x ();
528 : : table_x ++)
529 : 10001 : result.w += m_col_widths.m_requirements[table_x];
530 : 6072 : for (int table_y = rect.get_min_y ();
531 : 6072 : table_y < rect.get_next_y ();
532 : : table_y ++)
533 : 3237 : result.h += m_row_heights.m_requirements[table_y];
534 : : /* Allow space for the borders. */
535 : 2835 : result.w += rect.m_size.w - 1;
536 : 2835 : result.h += rect.m_size.h - 1;
537 : 2835 : return result;
538 : : }
539 : :
540 : : /* class text_art::table_geometry. */
541 : :
542 : 217 : table_geometry::table_geometry (const table &table, table_cell_sizes &cell_sizes)
543 : 217 : : m_cell_sizes (cell_sizes),
544 : 217 : m_canvas_size (canvas::size_t (0, 0)),
545 : 217 : m_col_start_x (table.get_size ().w),
546 : 217 : m_row_start_y (table.get_size ().h)
547 : : {
548 : 217 : recalc_coords ();
549 : 217 : }
550 : :
551 : : void
552 : 358 : table_geometry::recalc_coords ()
553 : : {
554 : : /* Start canvas column of table cell, including leading border. */
555 : 358 : m_col_start_x.clear ();
556 : 358 : int iter_canvas_x = 0;
557 : 3328 : for (auto w : m_cell_sizes.m_col_widths.m_requirements)
558 : : {
559 : 2970 : m_col_start_x.push_back (iter_canvas_x);
560 : 2970 : iter_canvas_x += w + 1;
561 : : }
562 : :
563 : : /* Start canvas row of table cell, including leading border. */
564 : 358 : m_row_start_y.clear ();
565 : 358 : int iter_canvas_y = 0;
566 : 1194 : for (auto h : m_cell_sizes.m_row_heights.m_requirements)
567 : : {
568 : 836 : m_row_start_y.push_back (iter_canvas_y);
569 : 836 : iter_canvas_y += h + 1;
570 : : }
571 : :
572 : 358 : m_canvas_size = canvas::size_t (iter_canvas_x + 1,
573 : 358 : iter_canvas_y + 1);
574 : 358 : }
575 : :
576 : : /* Get the TL corner of the table cell at TABLE_COORD
577 : : in canvas coords (including the border). */
578 : :
579 : : canvas::coord_t
580 : 10283 : table_geometry::table_to_canvas (table::coord_t table_coord) const
581 : : {
582 : 10283 : return canvas::coord_t (table_x_to_canvas_x (table_coord.x),
583 : 10283 : table_y_to_canvas_y (table_coord.y));
584 : : }
585 : :
586 : : /* Get the left border of the table cell at column TABLE_X
587 : : in canvas coords (including the border). */
588 : :
589 : : int
590 : 12959 : table_geometry::table_x_to_canvas_x (int table_x) const
591 : : {
592 : : /* Allow one beyond the end, for the right-hand border of the table. */
593 : 12959 : if (table_x == (int)m_col_start_x.size ())
594 : 823 : return m_canvas_size.w - 1;
595 : 12136 : return m_col_start_x[table_x];
596 : : }
597 : :
598 : : /* Get the top border of the table cell at column TABLE_Y
599 : : in canvas coords (including the border). */
600 : :
601 : : int
602 : 10885 : table_geometry::table_y_to_canvas_y (int table_y) const
603 : : {
604 : : /* Allow one beyond the end, for the right-hand border of the table. */
605 : 10885 : if (table_y == (int)m_row_start_y.size ())
606 : 0 : return m_canvas_size.h - 1;
607 : 10885 : return m_row_start_y[table_y];
608 : : }
609 : :
610 : : /* class text_art::simple_table_geometry. */
611 : :
612 : 4 : simple_table_geometry::simple_table_geometry (const table &table)
613 : 4 : : m_col_widths (table.get_size ().w),
614 : 4 : m_row_heights (table.get_size ().h),
615 : 4 : m_cell_sizes (m_col_widths, m_row_heights),
616 : 4 : m_tg (table, m_cell_sizes)
617 : : {
618 : 4 : m_cell_sizes.pass_1 (table);
619 : 4 : m_cell_sizes.pass_2 (table);
620 : 4 : m_tg.recalc_coords ();
621 : 4 : }
622 : :
623 : : #if CHECKING_P
624 : :
625 : : namespace selftest {
626 : :
627 : : static void
628 : 4 : test_tic_tac_toe ()
629 : : {
630 : 4 : style_manager sm;
631 : 4 : table t (table::size_t (3, 3));
632 : 4 : t.set_cell (table::coord_t (0, 0), styled_string (sm, "X"));
633 : 4 : t.set_cell (table::coord_t (1, 0), styled_string (sm, ""));
634 : 4 : t.set_cell (table::coord_t (2, 0), styled_string (sm, ""));
635 : 4 : t.set_cell (table::coord_t (0, 1), styled_string (sm, "O"));
636 : 4 : t.set_cell (table::coord_t (1, 1), styled_string (sm, "O"));
637 : 4 : t.set_cell (table::coord_t (2, 1), styled_string (sm, ""));
638 : 4 : t.set_cell (table::coord_t (0, 2), styled_string (sm, "X"));
639 : 4 : t.set_cell (table::coord_t (1, 2), styled_string (sm, ""));
640 : 4 : t.set_cell (table::coord_t (2, 2), styled_string (sm, "O"));
641 : :
642 : 4 : {
643 : 4 : canvas canvas (t.to_canvas (ascii_theme (), sm));
644 : 4 : ASSERT_CANVAS_STREQ
645 : : (canvas, false,
646 : : ("+-+-+-+\n"
647 : : "|X| | |\n"
648 : : "+-+-+-+\n"
649 : : "|O|O| |\n"
650 : : "+-+-+-+\n"
651 : : "|X| |O|\n"
652 : : "+-+-+-+\n"));
653 : 4 : }
654 : :
655 : 4 : {
656 : 4 : canvas canvas (t.to_canvas (unicode_theme (), sm));
657 : 4 : ASSERT_CANVAS_STREQ
658 : : (canvas, false,
659 : : // FIXME: are we allowed unicode chars in string literals in our source?
660 : : ("┌─┬─┬─┐\n"
661 : : "│X│ │ │\n"
662 : : "├─┼─┼─┤\n"
663 : : "│O│O│ │\n"
664 : : "├─┼─┼─┤\n"
665 : : "│X│ │O│\n"
666 : : "└─┴─┴─┘\n"));
667 : 4 : }
668 : 4 : }
669 : :
670 : : static table
671 : 8 : make_text_table ()
672 : : {
673 : 8 : style_manager sm;
674 : 8 : table t (table::size_t (3, 3));
675 : 8 : t.set_cell (table::coord_t (0, 0), styled_string (sm, "top left"));
676 : 8 : t.set_cell (table::coord_t (1, 0), styled_string (sm, "top middle"));
677 : 8 : t.set_cell (table::coord_t (2, 0), styled_string (sm, "top right"));
678 : 8 : t.set_cell (table::coord_t (0, 1), styled_string (sm, "middle left"));
679 : 8 : t.set_cell (table::coord_t (1, 1), styled_string (sm, "middle middle"));
680 : 8 : t.set_cell (table::coord_t (2, 1), styled_string (sm, "middle right"));
681 : 8 : t.set_cell (table::coord_t (0, 2), styled_string (sm, "bottom left"));
682 : 8 : t.set_cell (table::coord_t (1, 2), styled_string (sm, "bottom middle"));
683 : 8 : t.set_cell (table::coord_t (2, 2), styled_string (sm, "bottom right"));
684 : 8 : return t;
685 : 8 : }
686 : :
687 : : static void
688 : 4 : test_text_table ()
689 : : {
690 : 4 : style_manager sm;
691 : 4 : table table = make_text_table ();
692 : 4 : {
693 : 4 : canvas canvas (table.to_canvas (ascii_theme(), sm));
694 : 4 : ASSERT_CANVAS_STREQ
695 : : (canvas, false,
696 : : ("+-----------+-------------+------------+\n"
697 : : "| top left | top middle | top right |\n"
698 : : "+-----------+-------------+------------+\n"
699 : : "|middle left|middle middle|middle right|\n"
700 : : "+-----------+-------------+------------+\n"
701 : : "|bottom left|bottom middle|bottom right|\n"
702 : : "+-----------+-------------+------------+\n"));
703 : 4 : }
704 : 4 : {
705 : 4 : canvas canvas (table.to_canvas (unicode_theme(), sm));
706 : 4 : ASSERT_CANVAS_STREQ
707 : : (canvas, false,
708 : : // FIXME: are we allowed unicode chars in string literals in our source?
709 : : ("┌───────────┬─────────────┬────────────┐\n"
710 : : "│ top left │ top middle │ top right │\n"
711 : : "├───────────┼─────────────┼────────────┤\n"
712 : : "│middle left│middle middle│middle right│\n"
713 : : "├───────────┼─────────────┼────────────┤\n"
714 : : "│bottom left│bottom middle│bottom right│\n"
715 : : "└───────────┴─────────────┴────────────┘\n"));
716 : 4 : }
717 : 4 : }
718 : :
719 : : static void
720 : 4 : test_offset_table ()
721 : : {
722 : 4 : style_manager sm;
723 : 4 : table table = make_text_table ();
724 : 4 : simple_table_geometry stg (table);
725 : 4 : const canvas::size_t tcs = stg.m_tg.get_canvas_size();
726 : 4 : {
727 : 4 : canvas canvas (canvas::size_t (tcs.w + 5, tcs.h + 5), sm);
728 : 4 : canvas.debug_fill ();
729 : 4 : table.paint_to_canvas (canvas, canvas::coord_t (3, 3),
730 : : stg.m_tg,
731 : 4 : ascii_theme());
732 : 4 : ASSERT_CANVAS_STREQ
733 : : (canvas, false,
734 : : ("*********************************************\n"
735 : : "*********************************************\n"
736 : : "*********************************************\n"
737 : : "***+-----------+-------------+------------+**\n"
738 : : "***| top left | top middle | top right |**\n"
739 : : "***+-----------+-------------+------------+**\n"
740 : : "***|middle left|middle middle|middle right|**\n"
741 : : "***+-----------+-------------+------------+**\n"
742 : : "***|bottom left|bottom middle|bottom right|**\n"
743 : : "***+-----------+-------------+------------+**\n"
744 : : "*********************************************\n"
745 : : "*********************************************\n"));
746 : 4 : }
747 : 4 : {
748 : 4 : canvas canvas (canvas::size_t (tcs.w + 5, tcs.h + 5), sm);
749 : 4 : canvas.debug_fill ();
750 : 4 : table.paint_to_canvas (canvas, canvas::coord_t (3, 3),
751 : : stg.m_tg,
752 : 4 : unicode_theme());
753 : 4 : ASSERT_CANVAS_STREQ
754 : : (canvas, false,
755 : : // FIXME: are we allowed unicode chars in string literals in our source?
756 : : ("*********************************************\n"
757 : : "*********************************************\n"
758 : : "*********************************************\n"
759 : : "***┌───────────┬─────────────┬────────────┐**\n"
760 : : "***│ top left │ top middle │ top right │**\n"
761 : : "***├───────────┼─────────────┼────────────┤**\n"
762 : : "***│middle left│middle middle│middle right│**\n"
763 : : "***├───────────┼─────────────┼────────────┤**\n"
764 : : "***│bottom left│bottom middle│bottom right│**\n"
765 : : "***└───────────┴─────────────┴────────────┘**\n"
766 : : "*********************************************\n"
767 : : "*********************************************\n"));
768 : 4 : }
769 : 8 : }
770 : :
771 : : #define ASSERT_TABLE_CELL_STREQ(TABLE, TABLE_X, TABLE_Y, EXPECTED_STR) \
772 : : SELFTEST_BEGIN_STMT \
773 : : table::coord_t coord ((TABLE_X), (TABLE_Y)); \
774 : : const table::cell_placement *cp = (TABLE).get_placement_at (coord); \
775 : : ASSERT_NE (cp, nullptr); \
776 : : ASSERT_EQ (cp->get_content (), styled_string (sm, EXPECTED_STR)); \
777 : : SELFTEST_END_STMT
778 : :
779 : : #define ASSERT_TABLE_NULL_CELL(TABLE, TABLE_X, TABLE_Y) \
780 : : SELFTEST_BEGIN_STMT \
781 : : table::coord_t coord ((TABLE_X), (TABLE_Y)); \
782 : : const table::cell_placement *cp = (TABLE).get_placement_at (coord); \
783 : : ASSERT_EQ (cp, nullptr); \
784 : : SELFTEST_END_STMT
785 : :
786 : : static void
787 : 4 : test_spans ()
788 : : {
789 : 4 : style_manager sm;
790 : 4 : table table (table::size_t (3, 3));
791 : 4 : table.set_cell_span (table::rect_t (table::coord_t (0, 0),
792 : 4 : table::size_t (3, 1)),
793 : 8 : styled_string (sm, "ABC"));
794 : 4 : table.set_cell_span (table::rect_t (table::coord_t (0, 1),
795 : 4 : table::size_t (2, 1)),
796 : 8 : styled_string (sm, "DE"));
797 : 4 : table.set_cell_span (table::rect_t (table::coord_t (2, 1),
798 : 4 : table::size_t (1, 1)),
799 : 8 : styled_string (sm, "F"));
800 : 4 : table.set_cell (table::coord_t (0, 2), styled_string (sm, "G"));
801 : 4 : table.set_cell (table::coord_t (1, 2), styled_string (sm, "H"));
802 : 4 : table.set_cell (table::coord_t (2, 2), styled_string (sm, "I"));
803 : 4 : {
804 : 4 : canvas canvas (table.to_canvas (ascii_theme(), sm));
805 : 4 : ASSERT_CANVAS_STREQ
806 : : (canvas, false,
807 : : ("+-----+\n"
808 : : "| ABC |\n"
809 : : "+---+-+\n"
810 : : "|DE |F|\n"
811 : : "+-+-+-+\n"
812 : : "|G|H|I|\n"
813 : : "+-+-+-+\n"));
814 : 4 : }
815 : 4 : {
816 : 4 : canvas canvas (table.to_canvas (unicode_theme(), sm));
817 : 4 : ASSERT_CANVAS_STREQ
818 : : (canvas, false,
819 : : // FIXME: are we allowed unicode chars in string literals in our source?
820 : : ("┌─────┐\n"
821 : : "│ ABC │\n"
822 : : "├───┬─┤\n"
823 : : "│DE │F│\n"
824 : : "├─┬─┼─┤\n"
825 : : "│G│H│I│\n"
826 : : "└─┴─┴─┘\n"));
827 : 4 : }
828 : 4 : }
829 : :
830 : : /* Verify building this 5x5 table with spans:
831 : : |0|1|2|3|4|
832 : : +-+-+-+-+-+
833 : : 0|A A A|B|C|0
834 : : + +-+ +
835 : : 1|A A A|D|C|1
836 : : + +-+-+
837 : : 2|A A A|E|F|2
838 : : +-+-+-+-+-+
839 : : 3|G G|H|I I|3
840 : : | | +-+-+
841 : : 4|G G|H|J J|4
842 : : +-+-+-+-+-+
843 : : |0|1|2|3|4|
844 : : */
845 : :
846 : : static void
847 : 4 : test_spans_2 ()
848 : : {
849 : 4 : style_manager sm;
850 : 4 : table table (table::size_t (5, 5));
851 : 4 : table.set_cell_span (table::rect_t (table::coord_t (0, 0),
852 : 4 : table::size_t (3, 3)),
853 : 8 : styled_string (sm, "A"));
854 : 4 : table.set_cell_span (table::rect_t (table::coord_t (3, 0),
855 : 4 : table::size_t (1, 1)),
856 : 8 : styled_string (sm, "B"));
857 : 4 : table.set_cell_span (table::rect_t (table::coord_t (4, 0),
858 : 4 : table::size_t (1, 2)),
859 : 8 : styled_string (sm, "C"));
860 : 4 : table.set_cell_span (table::rect_t (table::coord_t (3, 1),
861 : 4 : table::size_t (1, 1)),
862 : 8 : styled_string (sm, "D"));
863 : 4 : table.set_cell_span (table::rect_t (table::coord_t (3, 2),
864 : 4 : table::size_t (1, 1)),
865 : 8 : styled_string (sm, "E"));
866 : 4 : table.set_cell_span (table::rect_t (table::coord_t (4, 2),
867 : 4 : table::size_t (1, 1)),
868 : 8 : styled_string (sm, "F"));
869 : 4 : table.set_cell_span (table::rect_t (table::coord_t (0, 3),
870 : 4 : table::size_t (2, 2)),
871 : 8 : styled_string (sm, "G"));
872 : 4 : table.set_cell_span (table::rect_t (table::coord_t (2, 3),
873 : 4 : table::size_t (1, 2)),
874 : 8 : styled_string (sm, "H"));
875 : 4 : table.set_cell_span (table::rect_t (table::coord_t (3, 3),
876 : 4 : table::size_t (2, 1)),
877 : 8 : styled_string (sm, "I"));
878 : 4 : table.set_cell_span (table::rect_t (table::coord_t (3, 4),
879 : 4 : table::size_t (2, 1)),
880 : 8 : styled_string (sm, "J"));
881 : :
882 : : /* Check occupancy at each table coordinate. */
883 : 4 : ASSERT_TABLE_CELL_STREQ (table, 0, 0, "A");
884 : 4 : ASSERT_TABLE_CELL_STREQ (table, 1, 0, "A");
885 : 4 : ASSERT_TABLE_CELL_STREQ (table, 2, 0, "A");
886 : 4 : ASSERT_TABLE_CELL_STREQ (table, 3, 0, "B");
887 : 4 : ASSERT_TABLE_CELL_STREQ (table, 4, 0, "C");
888 : :
889 : 4 : ASSERT_TABLE_CELL_STREQ (table, 0, 1, "A");
890 : 4 : ASSERT_TABLE_CELL_STREQ (table, 1, 1, "A");
891 : 4 : ASSERT_TABLE_CELL_STREQ (table, 2, 1, "A");
892 : 4 : ASSERT_TABLE_CELL_STREQ (table, 3, 1, "D");
893 : 4 : ASSERT_TABLE_CELL_STREQ (table, 4, 1, "C");
894 : :
895 : 4 : ASSERT_TABLE_CELL_STREQ (table, 0, 2, "A");
896 : 4 : ASSERT_TABLE_CELL_STREQ (table, 1, 2, "A");
897 : 4 : ASSERT_TABLE_CELL_STREQ (table, 2, 2, "A");
898 : 4 : ASSERT_TABLE_CELL_STREQ (table, 3, 2, "E");
899 : 4 : ASSERT_TABLE_CELL_STREQ (table, 4, 2, "F");
900 : :
901 : 4 : ASSERT_TABLE_CELL_STREQ (table, 0, 3, "G");
902 : 4 : ASSERT_TABLE_CELL_STREQ (table, 1, 3, "G");
903 : 4 : ASSERT_TABLE_CELL_STREQ (table, 2, 3, "H");
904 : 4 : ASSERT_TABLE_CELL_STREQ (table, 3, 3, "I");
905 : 4 : ASSERT_TABLE_CELL_STREQ (table, 4, 3, "I");
906 : :
907 : 4 : ASSERT_TABLE_CELL_STREQ (table, 0, 4, "G");
908 : 4 : ASSERT_TABLE_CELL_STREQ (table, 1, 4, "G");
909 : 4 : ASSERT_TABLE_CELL_STREQ (table, 2, 4, "H");
910 : 4 : ASSERT_TABLE_CELL_STREQ (table, 3, 4, "J");
911 : 4 : ASSERT_TABLE_CELL_STREQ (table, 4, 4, "J");
912 : :
913 : 4 : {
914 : 4 : canvas canvas (table.to_canvas (ascii_theme(), sm));
915 : 4 : ASSERT_CANVAS_STREQ
916 : : (canvas, false,
917 : : ("+---+-+-+\n"
918 : : "| |B| |\n"
919 : : "| +-+C|\n"
920 : : "| A |D| |\n"
921 : : "| +-+-+\n"
922 : : "| |E|F|\n"
923 : : "+-+-+-+-+\n"
924 : : "| | | I |\n"
925 : : "|G|H+---+\n"
926 : : "| | | J |\n"
927 : : "+-+-+---+\n"));
928 : 4 : }
929 : 4 : {
930 : 4 : canvas canvas (table.to_canvas (unicode_theme(), sm));
931 : 4 : ASSERT_CANVAS_STREQ
932 : : (canvas, false,
933 : : // FIXME: are we allowed unicode chars in string literals in our source?
934 : : ("┌───┬─┬─┐\n"
935 : : "│ │B│ │\n"
936 : : "│ ├─┤C│\n"
937 : : "│ A │D│ │\n"
938 : : "│ ├─┼─┤\n"
939 : : "│ │E│F│\n"
940 : : "├─┬─┼─┴─┤\n"
941 : : "│ │ │ I │\n"
942 : : "│G│H├───┤\n"
943 : : "│ │ │ J │\n"
944 : : "└─┴─┴───┘\n"));
945 : 4 : }
946 : 4 : }
947 : :
948 : : /* Experiment with adding a 1-table-column gap at the boundary between
949 : : valid vs invalid for visualizing a buffer overflow. */
950 : : static void
951 : 4 : test_spans_3 ()
952 : : {
953 : 4 : const char * const str = "hello world!";
954 : 4 : const size_t buf_size = 10;
955 : 4 : const size_t str_size = strlen (str) + 1;
956 : :
957 : 4 : style_manager sm;
958 : 4 : table table (table::size_t (str_size + 1, 3));
959 : :
960 : 4 : table.set_cell_span (table::rect_t (table::coord_t (0, 0),
961 : 4 : table::size_t (str_size + 1, 1)),
962 : 8 : styled_string (sm, "String literal"));
963 : :
964 : 56 : for (size_t i = 0; i < str_size; i++)
965 : : {
966 : 52 : table::coord_t c (i, 1);
967 : 52 : if (i >= buf_size)
968 : 12 : c.x++;
969 : 52 : if (str[i] == '\0')
970 : 4 : table.set_cell (c, styled_string (sm, "NUL"));
971 : : else
972 : 48 : table.set_cell (c, styled_string ((cppchar_t)str[i]));
973 : : }
974 : :
975 : 4 : table.set_cell_span (table::rect_t (table::coord_t (0, 2),
976 : 4 : table::size_t (buf_size, 1)),
977 : 8 : styled_string::from_fmt (sm,
978 : : nullptr,
979 : : "'buf' (char[%i])",
980 : : (int)buf_size));
981 : 4 : table.set_cell_span (table::rect_t (table::coord_t (buf_size + 1, 2),
982 : 4 : table::size_t (str_size - buf_size, 1)),
983 : 8 : styled_string (sm, "overflow"));
984 : :
985 : 4 : {
986 : 4 : canvas canvas (table.to_canvas (ascii_theme (), sm));
987 : 4 : ASSERT_CANVAS_STREQ
988 : : (canvas, false,
989 : : "+-----------------------------+\n"
990 : : "| String literal |\n"
991 : : "+-+-+-+-+-+-+-+-+-+-++-+-+----+\n"
992 : : "|h|e|l|l|o| |w|o|r|l||d|!|NUL |\n"
993 : : "+-+-+-+-+-+-+-+-+-+-++-+-+----+\n"
994 : : "| 'buf' (char[10]) ||overflow|\n"
995 : : "+-------------------++--------+\n");
996 : 4 : }
997 : 4 : {
998 : 4 : canvas canvas (table.to_canvas (unicode_theme (), sm));
999 : 4 : ASSERT_CANVAS_STREQ
1000 : : (canvas, false,
1001 : : // FIXME: are we allowed unicode chars in string literals in our source?
1002 : : ("┌─────────────────────────────┐\n"
1003 : : "│ String literal │\n"
1004 : : "├─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬┬─┬─┬────┤\n"
1005 : : "│h│e│l│l│o│ │w│o│r│l││d│!│NUL │\n"
1006 : : "├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤├─┴─┴────┤\n"
1007 : : "│ 'buf' (char[10]) ││overflow│\n"
1008 : : "└───────────────────┘└────────┘\n"));
1009 : 4 : }
1010 : 4 : }
1011 : :
1012 : : static void
1013 : 4 : test_double_width_chars ()
1014 : : {
1015 : 4 : table_cell_content tcc (styled_string ((cppchar_t)0x1f642));
1016 : 4 : ASSERT_EQ (tcc.get_canvas_size ().w, 2);
1017 : 4 : ASSERT_EQ (tcc.get_canvas_size ().h, 1);
1018 : :
1019 : 4 : style_manager sm;
1020 : 4 : table table (table::size_t (1, 1));
1021 : 4 : table.set_cell (table::coord_t (0,0),
1022 : 8 : styled_string ((cppchar_t)0x1f642));
1023 : :
1024 : 4 : canvas canvas (table.to_canvas (unicode_theme(), sm));
1025 : 4 : ASSERT_CANVAS_STREQ
1026 : : (canvas, false,
1027 : : // FIXME: are we allowed unicode chars in string literals in our source?
1028 : : ("┌──┐\n"
1029 : : "│🙂│\n"
1030 : : "└──┘\n"));
1031 : 8 : }
1032 : :
1033 : : static void
1034 : 4 : test_ipv4_header ()
1035 : : {
1036 : 4 : style_manager sm;
1037 : 4 : table table (table::size_t (34, 10));
1038 : 4 : table.set_cell (table::coord_t (0, 0), styled_string (sm, "Offsets"));
1039 : 4 : table.set_cell (table::coord_t (1, 0), styled_string (sm, "Octet"));
1040 : 4 : table.set_cell (table::coord_t (0, 1), styled_string (sm, "Octet"));
1041 : 20 : for (int octet = 0; octet < 4; octet++)
1042 : 16 : table.set_cell_span (table::rect_t (table::coord_t (2 + (octet * 8), 0),
1043 : 16 : table::size_t (8, 1)),
1044 : 32 : styled_string::from_fmt (sm, nullptr, "%i", octet));
1045 : 4 : table.set_cell (table::coord_t (1, 1), styled_string (sm, "Bit"));
1046 : 132 : for (int bit = 0; bit < 32; bit++)
1047 : 128 : table.set_cell (table::coord_t (bit + 2, 1),
1048 : 256 : styled_string::from_fmt (sm, nullptr, "%i", bit));
1049 : 28 : for (int word = 0; word < 6; word++)
1050 : : {
1051 : 24 : table.set_cell (table::coord_t (0, word + 2),
1052 : 48 : styled_string::from_fmt (sm, nullptr, "%i", word * 4));
1053 : 24 : table.set_cell (table::coord_t (1, word + 2),
1054 : 48 : styled_string::from_fmt (sm, nullptr, "%i", word * 32));
1055 : : }
1056 : :
1057 : 4 : table.set_cell (table::coord_t (0, 8), styled_string (sm, "..."));
1058 : 4 : table.set_cell (table::coord_t (1, 8), styled_string (sm, "..."));
1059 : 4 : table.set_cell (table::coord_t (0, 9), styled_string (sm, "56"));
1060 : 4 : table.set_cell (table::coord_t (1, 9), styled_string (sm, "448"));
1061 : :
1062 : : #define SET_BITS(FIRST, LAST, NAME) \
1063 : : do { \
1064 : : const int first = (FIRST); \
1065 : : const int last = (LAST); \
1066 : : const char *name = (NAME); \
1067 : : const int row = first / 32; \
1068 : : gcc_assert (last / 32 == row); \
1069 : : table::rect_t rect (table::coord_t ((first % 32) + 2, row + 2), \
1070 : : table::size_t (last + 1 - first , 1)); \
1071 : : table.set_cell_span (rect, styled_string (sm, name)); \
1072 : : } while (0)
1073 : :
1074 : 4 : SET_BITS (0, 3, "Version");
1075 : 4 : SET_BITS (4, 7, "IHL");
1076 : 4 : SET_BITS (8, 13, "DSCP");
1077 : 4 : SET_BITS (14, 15, "ECN");
1078 : 4 : SET_BITS (16, 31, "Total Length");
1079 : :
1080 : 4 : SET_BITS (32 + 0, 32 + 15, "Identification");
1081 : 4 : SET_BITS (32 + 16, 32 + 18, "Flags");
1082 : 4 : SET_BITS (32 + 19, 32 + 31, "Fragment Offset");
1083 : :
1084 : 4 : SET_BITS (64 + 0, 64 + 7, "Time To Live");
1085 : 4 : SET_BITS (64 + 8, 64 + 15, "Protocol");
1086 : 4 : SET_BITS (64 + 16, 64 + 31, "Header Checksum");
1087 : :
1088 : 4 : SET_BITS (96 + 0, 96 + 31, "Source IP Address");
1089 : 4 : SET_BITS (128 + 0, 128 + 31, "Destination IP Address");
1090 : :
1091 : 4 : table.set_cell_span(table::rect_t (table::coord_t (2, 7),
1092 : 4 : table::size_t (32, 3)),
1093 : 8 : styled_string (sm, "Options"));
1094 : 4 : {
1095 : 4 : canvas canvas (table.to_canvas (ascii_theme(), sm));
1096 : 4 : ASSERT_CANVAS_STREQ
1097 : : (canvas, false,
1098 : : ("+-------+-----+---------------+---------------------+-----------------------+-----------------------+\n"
1099 : : "|Offsets|Octet| 0 | 1 | 2 | 3 |\n"
1100 : : "+-------+-----+-+-+-+-+-+-+-+-+-+-+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+\n"
1101 : : "| Octet | Bit |0|1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|16|17|18|19|20|21|22|23|24|25|26|27|28|29|30|31|\n"
1102 : : "+-------+-----+-+-+-+-+-+-+-+-+-+-+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+\n"
1103 : : "| 0 | 0 |Version| IHL | DSCP | ECN | Total Length |\n"
1104 : : "+-------+-----+-------+-------+---------------+-----+--------+--------------------------------------+\n"
1105 : : "| 4 | 32 | Identification | Flags | Fragment Offset |\n"
1106 : : "+-------+-----+---------------+---------------------+--------+--------------------------------------+\n"
1107 : : "| 8 | 64 | Time To Live | Protocol | Header Checksum |\n"
1108 : : "+-------+-----+---------------+---------------------+-----------------------------------------------+\n"
1109 : : "| 12 | 96 | Source IP Address |\n"
1110 : : "+-------+-----+-------------------------------------------------------------------------------------+\n"
1111 : : "| 16 | 128 | Destination IP Address |\n"
1112 : : "+-------+-----+-------------------------------------------------------------------------------------+\n"
1113 : : "| 20 | 160 | |\n"
1114 : : "+-------+-----+ |\n"
1115 : : "| ... | ... | Options |\n"
1116 : : "+-------+-----+ |\n"
1117 : : "| 56 | 448 | |\n"
1118 : : "+-------+-----+-------------------------------------------------------------------------------------+\n"));
1119 : 4 : }
1120 : 4 : {
1121 : 4 : canvas canvas (table.to_canvas (unicode_theme(), sm));
1122 : 4 : ASSERT_CANVAS_STREQ
1123 : : (canvas, false,
1124 : : // FIXME: are we allowed unicode chars in string literals in our source?
1125 : : ("┌───────┬─────┬───────────────┬─────────────────────┬───────────────────────┬───────────────────────┐\n"
1126 : : "│Offsets│Octet│ 0 │ 1 │ 2 │ 3 │\n"
1127 : : "├───────┼─────┼─┬─┬─┬─┬─┬─┬─┬─┼─┬─┬──┬──┬──┬──┬──┬──┼──┬──┬──┬──┬──┬──┬──┬──┼──┬──┬──┬──┬──┬──┬──┬──┤\n"
1128 : : "│ Octet │ Bit │0│1│2│3│4│5│6│7│8│9│10│11│12│13│14│15│16│17│18│19│20│21│22│23│24│25│26│27│28│29│30│31│\n"
1129 : : "├───────┼─────┼─┴─┴─┴─┼─┴─┴─┴─┼─┴─┴──┴──┴──┴──┼──┴──┼──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┤\n"
1130 : : "│ 0 │ 0 │Version│ IHL │ DSCP │ ECN │ Total Length │\n"
1131 : : "├───────┼─────┼───────┴───────┴───────────────┴─────┼────────┬──────────────────────────────────────┤\n"
1132 : : "│ 4 │ 32 │ Identification │ Flags │ Fragment Offset │\n"
1133 : : "├───────┼─────┼───────────────┬─────────────────────┼────────┴──────────────────────────────────────┤\n"
1134 : : "│ 8 │ 64 │ Time To Live │ Protocol │ Header Checksum │\n"
1135 : : "├───────┼─────┼───────────────┴─────────────────────┴───────────────────────────────────────────────┤\n"
1136 : : "│ 12 │ 96 │ Source IP Address │\n"
1137 : : "├───────┼─────┼─────────────────────────────────────────────────────────────────────────────────────┤\n"
1138 : : "│ 16 │ 128 │ Destination IP Address │\n"
1139 : : "├───────┼─────┼─────────────────────────────────────────────────────────────────────────────────────┤\n"
1140 : : "│ 20 │ 160 │ │\n"
1141 : : "├───────┼─────┤ │\n"
1142 : : "│ ... │ ... │ Options │\n"
1143 : : "├───────┼─────┤ │\n"
1144 : : "│ 56 │ 448 │ │\n"
1145 : : "└───────┴─────┴─────────────────────────────────────────────────────────────────────────────────────┘\n"));
1146 : 4 : }
1147 : 4 : }
1148 : :
1149 : : static void
1150 : 4 : test_missing_cells ()
1151 : : {
1152 : 4 : style_manager sm;
1153 : 4 : table table (table::size_t (3, 3));
1154 : 4 : table.set_cell (table::coord_t (1, 0), styled_string (sm, "A"));
1155 : 4 : table.set_cell (table::coord_t (0, 1), styled_string (sm, "B"));
1156 : 4 : table.set_cell (table::coord_t (1, 1), styled_string (sm, "C"));
1157 : 4 : table.set_cell (table::coord_t (2, 1), styled_string (sm, "D"));
1158 : 4 : table.set_cell (table::coord_t (1, 2), styled_string (sm, "E"));
1159 : :
1160 : 4 : ASSERT_TABLE_NULL_CELL (table, 0, 0);
1161 : 4 : ASSERT_TABLE_CELL_STREQ (table, 1, 0, "A");
1162 : 4 : ASSERT_TABLE_NULL_CELL (table, 2, 0);
1163 : :
1164 : 4 : ASSERT_TABLE_CELL_STREQ (table, 0, 1, "B");
1165 : 4 : ASSERT_TABLE_CELL_STREQ (table, 1, 1, "C");
1166 : 4 : ASSERT_TABLE_CELL_STREQ (table, 2, 1, "D");
1167 : :
1168 : 4 : ASSERT_TABLE_NULL_CELL (table, 0, 2);
1169 : 4 : ASSERT_TABLE_CELL_STREQ (table, 1, 2, "E");
1170 : 4 : ASSERT_TABLE_NULL_CELL (table, 2, 2);
1171 : :
1172 : 4 : {
1173 : 4 : canvas canvas (table.to_canvas (ascii_theme(), sm));
1174 : 4 : ASSERT_CANVAS_STREQ
1175 : : (canvas, false,
1176 : : (" +-+\n"
1177 : : " |A|\n"
1178 : : "+-+-+-+\n"
1179 : : "|B|C|D|\n"
1180 : : "+-+-+-+\n"
1181 : : " |E|\n"
1182 : : " +-+\n"));
1183 : 4 : }
1184 : 4 : {
1185 : 4 : canvas canvas (table.to_canvas (unicode_theme(), sm));
1186 : 4 : ASSERT_CANVAS_STREQ
1187 : : (canvas, false,
1188 : : (" ┌─┐\n"
1189 : : " │A│\n"
1190 : : "┌─┼─┼─┐\n"
1191 : : "│B│C│D│\n"
1192 : : "└─┼─┼─┘\n"
1193 : : " │E│\n"
1194 : : " └─┘\n"));
1195 : 4 : }
1196 : 4 : }
1197 : :
1198 : : static void
1199 : 4 : test_add_row ()
1200 : : {
1201 : 4 : style_manager sm;
1202 : 4 : table table (table::size_t (3, 0));
1203 : 24 : for (int i = 0; i < 5; i++)
1204 : : {
1205 : 20 : const int y = table.add_row ();
1206 : 80 : for (int x = 0; x < 3; x++)
1207 : 60 : table.set_cell (table::coord_t (x, y),
1208 : 120 : styled_string::from_fmt (sm, nullptr,
1209 : : "%i, %i", x, y));
1210 : : }
1211 : 4 : canvas canvas (table.to_canvas (ascii_theme(), sm));
1212 : 4 : ASSERT_CANVAS_STREQ
1213 : : (canvas, false,
1214 : : ("+----+----+----+\n"
1215 : : "|0, 0|1, 0|2, 0|\n"
1216 : : "+----+----+----+\n"
1217 : : "|0, 1|1, 1|2, 1|\n"
1218 : : "+----+----+----+\n"
1219 : : "|0, 2|1, 2|2, 2|\n"
1220 : : "+----+----+----+\n"
1221 : : "|0, 3|1, 3|2, 3|\n"
1222 : : "+----+----+----+\n"
1223 : : "|0, 4|1, 4|2, 4|\n"
1224 : : "+----+----+----+\n"));
1225 : 8 : }
1226 : :
1227 : : static void
1228 : 4 : test_alignment ()
1229 : : {
1230 : 4 : style_manager sm;
1231 : 4 : table table (table::size_t (9, 9));
1232 : 4 : table.set_cell_span (table::rect_t (table::coord_t (0, 0),
1233 : 4 : table::size_t (3, 3)),
1234 : 8 : styled_string (sm, "left top"),
1235 : : x_align::LEFT, y_align::TOP);
1236 : 4 : table.set_cell_span (table::rect_t (table::coord_t (3, 0),
1237 : 4 : table::size_t (3, 3)),
1238 : 8 : styled_string (sm, "center top"),
1239 : : x_align::CENTER, y_align::TOP);
1240 : 4 : table.set_cell_span (table::rect_t (table::coord_t (6, 0),
1241 : 4 : table::size_t (3, 3)),
1242 : 8 : styled_string (sm, "right top"),
1243 : : x_align::RIGHT, y_align::TOP);
1244 : 4 : table.set_cell_span (table::rect_t (table::coord_t (0, 3),
1245 : 4 : table::size_t (3, 3)),
1246 : 8 : styled_string (sm, "left center"),
1247 : : x_align::LEFT, y_align::CENTER);
1248 : 4 : table.set_cell_span (table::rect_t (table::coord_t (3, 3),
1249 : 4 : table::size_t (3, 3)),
1250 : 8 : styled_string (sm, "center center"),
1251 : : x_align::CENTER, y_align::CENTER);
1252 : 4 : table.set_cell_span (table::rect_t (table::coord_t (6, 3),
1253 : 4 : table::size_t (3, 3)),
1254 : 8 : styled_string (sm, "right center"),
1255 : : x_align::RIGHT, y_align::CENTER);
1256 : 4 : table.set_cell_span (table::rect_t (table::coord_t (0, 6),
1257 : 4 : table::size_t (3, 3)),
1258 : 8 : styled_string (sm, "left bottom"),
1259 : : x_align::LEFT, y_align::BOTTOM);
1260 : 4 : table.set_cell_span (table::rect_t (table::coord_t (3, 6),
1261 : 4 : table::size_t (3, 3)),
1262 : 8 : styled_string (sm, "center bottom"),
1263 : : x_align::CENTER, y_align::BOTTOM);
1264 : 4 : table.set_cell_span (table::rect_t (table::coord_t (6, 6),
1265 : 4 : table::size_t (3, 3)),
1266 : 8 : styled_string (sm, "right bottom"),
1267 : : x_align::RIGHT, y_align::BOTTOM);
1268 : :
1269 : 4 : canvas canvas (table.to_canvas (ascii_theme(), sm));
1270 : 4 : ASSERT_CANVAS_STREQ
1271 : : (canvas, false,
1272 : : ("+-----------+-------------+------------+\n"
1273 : : "|left top | center top | right top|\n"
1274 : : "| | | |\n"
1275 : : "+-----------+-------------+------------+\n"
1276 : : "|left center|center center|right center|\n"
1277 : : "| | | |\n"
1278 : : "+-----------+-------------+------------+\n"
1279 : : "| | | |\n"
1280 : : "|left bottom|center bottom|right bottom|\n"
1281 : : "+-----------+-------------+------------+\n"));
1282 : 8 : }
1283 : :
1284 : : /* Run all selftests in this file. */
1285 : :
1286 : : void
1287 : 4 : text_art_table_cc_tests ()
1288 : : {
1289 : 4 : test_tic_tac_toe ();
1290 : 4 : test_text_table ();
1291 : 4 : test_offset_table ();
1292 : 4 : test_spans ();
1293 : 4 : test_spans_2 ();
1294 : 4 : test_spans_3 ();
1295 : 4 : test_double_width_chars ();
1296 : 4 : test_ipv4_header ();
1297 : 4 : test_missing_cells ();
1298 : 4 : test_add_row ();
1299 : 4 : test_alignment ();
1300 : 4 : }
1301 : :
1302 : : } // namespace selftest
1303 : :
1304 : :
1305 : : #endif /* #if CHECKING_P */
|
