gcc/text-art/types.h

   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
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it
   8 under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 3, or (at your option)
  10 any later version.
  11
  12 GCC is distributed in the hope that it will be useful, but
  13 WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15 General Public License 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 #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
  35 namespace text_art {
  36
  37 /* Forward decls.  */
  38
  39 class canvas;
  40 class table;
  41 class theme;
  42
  43 /* Classes for geometry.
  44    We use templates to avoid mixing up e.g. canvas coordinates
  45    with table coordinates.  */
  46
  47 template <typename CoordinateSystem>
  48 struct size
  49 {
  50   size (int w_, int h_) : w (w_), h (h_) {}
  51   int w;
  52   int h;
  53 };
  54
  55 template <typename CoordinateSystem>
  56 struct coord
  57 {
  58   coord (int x_, int y_) : x (x_), y (y_) {}
  59   int x;
  60   int y;
  61 };
  62
  63 template <typename CoordinateSystem>
  64 coord<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
  72 template <typename CoordinateSystem>
  73 struct 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
  92 template <typename CoordinateSystem>
  93 struct 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
 132 template <typename CoordinateSystem>
 133 rect<CoordinateSystem> operator+ (rect<CoordinateSystem> r,
 134                                   coord<CoordinateSystem> offset)
 135 {
 136   return rect<CoordinateSystem> (r.m_top_left + offset, r.m_size);
 137 }
 138
 139 template <typename ElementType, typename SizeType, typename CoordType>
 140 class 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_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
 221 struct 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
 335 extern 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
 341 class 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
 355 private:
 356   std::vector<style> m_styles;
 357 };
 358
 359 class 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 (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 (m_code);
 404   }
 405
 406   void add_combining_char (cppchar_t ch)
 407   {
 408     m_combining_chars.push_back (ch);
 409   }
 410
 411   const std::vector<cppchar_t> get_combining_chars () const
 412   {
 413     return m_combining_chars;
 414   }
 415
 416 private:
 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
 423 class 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
 478 private:
 479   std::vector<styled_unichar> m_chars;
 480 };
 481
 482 enum class x_align
 483 {
 484   LEFT,
 485   CENTER,
 486   RIGHT
 487 };
 488
 489 enum class y_align
 490 {
 491   TOP,
 492   CENTER,
 493   BOTTOM
 494 };
 495
 496 /* A set of cardinal directions within a canvas or table.  */
 497
 498 struct directions
 499 {
 500 public:
 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 */