1/* Types for drawing 2d "text art".
2 Copyright (C) 2023-2024 Free Software Foundation, Inc.
3 Contributed by David Malcolm <dmalcolm@redhat.com>.
4
5This file is part of GCC.
6
7GCC is free software; you can redistribute it and/or modify it
8under the terms of the GNU General Public License as published by
9the Free Software Foundation; either version 3, or (at your option)
10any later version.
11
12GCC is distributed in the hope that it will be useful, but
13WITHOUT ANY WARRANTY; without even the implied warranty of
14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15General Public License for more details.
16
17You should have received a copy of the GNU General Public License
18along with GCC; see the file COPYING3. If not see
19<http://www.gnu.org/licenses/>. */
20
21#ifndef GCC_TEXT_ART_TYPES_H
22#define GCC_TEXT_ART_TYPES_H
23
24/* This header uses std::vector, but <vector> can't be directly
25 included due to issues with macros. Hence it must be included from
26 system.h by defining INCLUDE_MEMORY in any source file using it. */
27
28#ifndef INCLUDE_VECTOR
29# error "You must define INCLUDE_VECTOR before including system.h to use text-art/types.h"
30#endif
31
32#include "cpplib.h"
33#include "pretty-print.h"
34
35namespace text_art {
36
37/* Forward decls. */
38
39class canvas;
40class table;
41class theme;
42
43/* Classes for geometry.
44 We use templates to avoid mixing up e.g. canvas coordinates
45 with table coordinates. */
46
47template <typename CoordinateSystem>
48struct size
49{
50 size (int w_, int h_) : w (w_), h (h_) {}
51 int w;
52 int h;
53};
54
55template <typename CoordinateSystem>
56struct coord
57{
58 coord (int x_, int y_) : x (x_), y (y_) {}
59 int x;
60 int y;
61};
62
63template <typename CoordinateSystem>
64coord<CoordinateSystem> operator+ (coord<CoordinateSystem> a,
65 coord<CoordinateSystem> b)
66{
67 return coord<CoordinateSystem> (a.x + b.x, a.y + b.y);
68}
69
70/* A half-open range [start, next) of int. */
71
72template <typename CoordinateSystem>
73struct range
74{
75 range (int start_, int next_)
76 : start (start_), next (next_)
77 {}
78
79 int get_min () const { return start; }
80 int get_max () const { return next - 1; }
81 int get_next () const { return next; }
82 int get_size () const { return next - start; }
83
84 int get_midpoint () const { return get_min () + get_size () / 2; }
85
86 int start;
87 int next;
88};
89
90/* A rectangle area within CoordinateSystem. */
91
92template <typename CoordinateSystem>
93struct rect
94{
95 rect (coord<CoordinateSystem> top_left,
96 size<CoordinateSystem> size)
97 : m_top_left (top_left),
98 m_size (size)
99 {
100 }
101
102 rect (range<CoordinateSystem> x_range,
103 range<CoordinateSystem> y_range)
104 : m_top_left (x_range.get_min (), y_range.get_min ()),
105 m_size (x_range.get_size (), y_range.get_size ())
106 {
107 }
108
109 int get_min_x () const { return m_top_left.x; }
110 int get_min_y () const { return m_top_left.y; }
111 int get_max_x () const { return m_top_left.x + m_size.w - 1; }
112 int get_max_y () const { return m_top_left.y + m_size.h - 1; }
113 int get_next_x () const { return m_top_left.x + m_size.w; }
114 int get_next_y () const { return m_top_left.y + m_size.h; }
115
116 range<CoordinateSystem> get_x_range () const
117 {
118 return range<CoordinateSystem> (get_min_x (), get_next_x ());
119 }
120 range<CoordinateSystem> get_y_range () const
121 {
122 return range<CoordinateSystem> (get_min_y (), get_next_y ());
123 }
124
125 int get_width () const { return m_size.w; }
126 int get_height () const { return m_size.h; }
127
128 coord<CoordinateSystem> m_top_left;
129 size<CoordinateSystem> m_size;
130};
131
132template <typename CoordinateSystem>
133rect<CoordinateSystem> operator+ (rect<CoordinateSystem> r,
134 coord<CoordinateSystem> offset)
135{
136 return rect<CoordinateSystem> (r.m_top_left + offset, r.m_size);
137}
138
139template <typename ElementType, typename SizeType, typename CoordType>
140class array2
141{
142 public:
143 typedef ElementType element_t;
144 typedef SizeType size_t;
145 typedef CoordType coord_t;
146
147 array2 (size_t sz)
148 : m_size (sz),
149 m_elements (sz.w * sz.h)
150 {
151 }
152 array2 (array2 &&other)
153 : m_size (other.m_size),
154 m_elements (std::move (other.m_elements))
155 {
156 }
157
158 /* Move assignment not implemented or used. */
159 array2 &operator== (array2 &&other) = delete;
160
161 /* No copy ctor or assignment op. */
162 array2 (const array2 &other) = delete;
163 array2 &operator= (const array2 &other) = delete;
164
165
166 const size_t &get_size () const { return m_size; }
167
168 void add_row (const element_t &element)
169 {
170 m_size.h++;
171 m_elements.insert (m_elements.end (), m_size.w, element);
172 }
173
174 const element_t &get (const coord_t &coord) const
175 {
176 ::size_t idx = get_idx (coord);
177 return m_elements[idx];
178 }
179
180 void set (const coord_t &coord, const element_t &element)
181 {
182 ::size_t idx = get_idx (coord);
183 m_elements[idx] = element;
184 }
185
186 void fill (element_t element)
187 {
188 for (int y = 0; y < m_size.h; y++)
189 for (int x = 0; x < m_size.w; x++)
190 set (coord: coord_t (x, y), element);
191 }
192
193 private:
194 ::size_t get_idx (const coord_t &coord) const
195 {
196 gcc_assert (coord.x >= 0);
197 gcc_assert (coord.x < m_size.w);
198 gcc_assert (coord.y >= 0);
199 gcc_assert (coord.y < m_size.h);
200 return (coord.y * m_size.w) + coord.x;
201 }
202
203 size_t m_size;
204 std::vector<element_t> m_elements;
205};
206
207/* A combination of attributes describing how to style a text cell.
208 We only support those attributes mentioned in invoke.texi:
209 - bold,
210 - underscore,
211 - blink,
212 - inverse,
213 - colors for foreground and background:
214 - default color
215 - named colors
216 - 16-color mode colors (the "bright" variants)
217 - 88-color mode
218 - 256-color mode
219 plus URLs. */
220
221struct style
222{
223 typedef unsigned char id_t;
224 static const id_t id_plain = 0;
225
226 /* Colors. */
227 enum class named_color
228 {
229 DEFAULT,
230 // ANSI order
231 BLACK,
232 RED,
233 GREEN,
234 YELLOW,
235 BLUE,
236 MAGENTA,
237 CYAN,
238 WHITE
239 };
240
241
242 struct color
243 {
244 enum class kind
245 {
246 NAMED,
247 BITS_8,
248 BITS_24,
249 } m_kind;
250
251 union
252 {
253 struct {
254 enum named_color m_name;
255 bool m_bright;
256 } m_named;
257 uint8_t m_8bit;
258 struct {
259 uint8_t r;
260 uint8_t g;
261 uint8_t b;
262 } m_24bit;
263 } u;
264
265 /* Constructor for named colors. */
266 color (enum named_color name = named_color::DEFAULT,
267 bool bright = false)
268 : m_kind (kind::NAMED)
269 {
270 u.m_named.m_name = name;
271 u.m_named.m_bright = bright;
272 }
273
274 /* Constructor for 8-bit colors. */
275 color (uint8_t col_val)
276 : m_kind (kind::BITS_8)
277 {
278 u.m_8bit = col_val;
279 }
280
281 /* Constructor for 24-bit colors. */
282 color (uint8_t r, uint8_t g, uint8_t b)
283 : m_kind (kind::BITS_24)
284 {
285 u.m_24bit.r = r;
286 u.m_24bit.g = g;
287 u.m_24bit.b = b;
288 }
289
290 bool operator== (const color &other) const;
291 bool operator!= (const color &other) const
292 {
293 return !(*this == other);
294 }
295
296 void print_sgr (pretty_printer *pp, bool fg, bool &need_separator) const;
297 };
298
299 style ()
300 : m_bold (false),
301 m_underscore (false),
302 m_blink (false),
303 m_reverse (false),
304 m_fg_color (named_color::DEFAULT),
305 m_bg_color (named_color::DEFAULT),
306 m_url ()
307 {}
308
309 bool operator== (const style &other) const
310 {
311 return (m_bold == other.m_bold
312 && m_underscore == other.m_underscore
313 && m_blink == other.m_blink
314 && m_reverse == other.m_reverse
315 && m_fg_color == other.m_fg_color
316 && m_bg_color == other.m_bg_color
317 && m_url == other.m_url);
318 }
319
320 style &set_style_url (const char *url);
321
322 static void print_changes (pretty_printer *pp,
323 const style &old_style,
324 const style &new_style);
325
326 bool m_bold;
327 bool m_underscore;
328 bool m_blink;
329 bool m_reverse;
330 color m_fg_color;
331 color m_bg_color;
332 std::vector<cppchar_t> m_url; // empty = no URL
333};
334
335extern style get_style_from_color_cap_name (const char *name);
336
337/* A class to keep track of all the styles in use in a drawing, so that
338 we can refer to them via the compact style::id_t type, rather than
339 via e.g. pointers. */
340
341class style_manager
342{
343 public:
344 style_manager ();
345 style::id_t get_or_create_id (const style &style);
346 const style &get_style (style::id_t id) const
347 {
348 return m_styles[id];
349 }
350 void print_any_style_changes (pretty_printer *pp,
351 style::id_t old_id,
352 style::id_t new_id) const;
353 unsigned get_num_styles () const { return m_styles.size (); }
354
355private:
356 std::vector<style> m_styles;
357};
358
359class styled_unichar
360{
361 public:
362 friend class styled_string;
363
364 explicit styled_unichar ()
365 : m_code (0),
366 m_style_id (style::id_plain)
367 {}
368 explicit styled_unichar (cppchar_t ch)
369 : m_code (ch),
370 m_emoji_variant_p (false),
371 m_style_id (style::id_plain)
372 {}
373 explicit styled_unichar (cppchar_t ch, bool emoji, style::id_t style_id)
374 : m_code (ch),
375 m_emoji_variant_p (emoji),
376 m_style_id (style_id)
377 {
378 gcc_assert (style_id <= 0x7f);
379 }
380
381 cppchar_t get_code () const { return m_code; }
382 bool emoji_variant_p () const { return m_emoji_variant_p; }
383 style::id_t get_style_id () const { return m_style_id; }
384
385 bool double_width_p () const
386 {
387 int width = cpp_wcwidth (c: get_code ());
388 gcc_assert (width == 1 || width == 2);
389 return width == 2;
390 }
391
392 bool operator== (const styled_unichar &other) const
393 {
394 return (m_code == other.m_code
395 && m_emoji_variant_p == other.m_emoji_variant_p
396 && m_style_id == other.m_style_id);
397 }
398
399 void set_emoji_variant () { m_emoji_variant_p = true; }
400
401 int get_canvas_width () const
402 {
403 return cpp_wcwidth (c: m_code);
404 }
405
406 void add_combining_char (cppchar_t ch)
407 {
408 m_combining_chars.push_back (x: ch);
409 }
410
411 const std::vector<cppchar_t> get_combining_chars () const
412 {
413 return m_combining_chars;
414 }
415
416private:
417 cppchar_t m_code : 24;
418 bool m_emoji_variant_p : 1;
419 style::id_t m_style_id : 7;
420 std::vector<cppchar_t> m_combining_chars;
421};
422
423class styled_string
424{
425 public:
426 explicit styled_string () = default;
427 explicit styled_string (style_manager &sm, const char *str);
428 explicit styled_string (cppchar_t cppchar, bool emoji = false);
429
430 styled_string (styled_string &&) = default;
431 styled_string &operator= (styled_string &&) = default;
432
433 /* No copy ctor or assignment op. */
434 styled_string (const styled_string &) = delete;
435 styled_string &operator= (const styled_string &) = delete;
436
437 /* For the few cases where copying is required, spell it out explicitly. */
438 styled_string copy () const
439 {
440 styled_string result;
441 result.m_chars = m_chars;
442 return result;
443 }
444
445 bool operator== (const styled_string &other) const
446 {
447 return m_chars == other.m_chars;
448 }
449
450 static styled_string from_fmt (style_manager &sm,
451 printer_fn format_decoder,
452 const char *fmt, ...)
453 ATTRIBUTE_GCC_PPDIAG(3, 4);
454 static styled_string from_fmt_va (style_manager &sm,
455 printer_fn format_decoder,
456 const char *fmt,
457 va_list *args)
458 ATTRIBUTE_GCC_PPDIAG(3, 0);
459
460 size_t size () const { return m_chars.size (); }
461 styled_unichar operator[] (size_t idx) const { return m_chars[idx]; }
462
463 std::vector<styled_unichar>::const_iterator begin () const
464 {
465 return m_chars.begin ();
466 }
467 std::vector<styled_unichar>::const_iterator end () const
468 {
469 return m_chars.end ();
470 }
471
472 int calc_canvas_width () const;
473
474 void append (const styled_string &suffix);
475
476 void set_url (style_manager &sm, const char *url);
477
478private:
479 std::vector<styled_unichar> m_chars;
480};
481
482enum class x_align
483{
484 LEFT,
485 CENTER,
486 RIGHT
487};
488
489enum class y_align
490{
491 TOP,
492 CENTER,
493 BOTTOM
494};
495
496/* A set of cardinal directions within a canvas or table. */
497
498struct directions
499{
500public:
501 directions (bool up, bool down, bool left, bool right)
502 : m_up (up), m_down (down), m_left (left), m_right (right)
503 {
504 }
505
506 size_t as_index () const
507 {
508 return (m_up << 3) | (m_down << 2) | (m_left << 1) | m_right;
509 }
510
511 bool m_up: 1;
512 bool m_down: 1;
513 bool m_left: 1;
514 bool m_right: 1;
515};
516
517} // namespace text_art
518
519#endif /* GCC_TEXT_ART_TYPES_H */
520

source code of gcc/text-art/types.h