Line data Source code
1 : /* Hierarchical diagram elements.
2 : Copyright (C) 2023-2026 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 "selftest.h"
27 : #include "text-art/selftests.h"
28 : #include "text-art/widget.h"
29 :
30 : using namespace text_art;
31 :
32 : /* class text_art::widget. */
33 :
34 : canvas
35 2845 : widget::to_canvas (const style_manager &style_mgr)
36 : {
37 2845 : const canvas::size_t req_size = get_req_size ();
38 :
39 : /* For now we don't constrain the allocation; we give
40 : the widget the full size it requested, and widgets
41 : assume they got their full size request. */
42 2845 : const canvas::size_t alloc_size = req_size;
43 :
44 2845 : set_alloc_rect (canvas::rect_t (canvas::coord_t (0, 0), alloc_size));
45 2845 : canvas c (alloc_size, style_mgr);
46 2845 : paint_to_canvas (c);
47 2845 : return c;
48 : }
49 :
50 : /* class text_art::vbox_widget : public text_art::container_widget. */
51 :
52 : const char *
53 0 : vbox_widget::get_desc () const
54 : {
55 0 : return "vbox_widget";
56 : }
57 :
58 : canvas::size_t
59 76 : vbox_widget::calc_req_size ()
60 : {
61 76 : canvas::size_t result (0, 0);
62 381 : for (auto &child : m_children)
63 : {
64 305 : canvas::size_t child_req_size = child->get_req_size();
65 305 : result.h += child_req_size.h;
66 305 : result.w = std::max (result.w, child_req_size.w);
67 : }
68 76 : return result;
69 : }
70 :
71 : void
72 76 : vbox_widget::update_child_alloc_rects ()
73 : {
74 76 : const int x = get_min_x ();
75 76 : int y = get_min_y ();
76 381 : for (auto &child : m_children)
77 : {
78 305 : child->set_alloc_rect
79 610 : (canvas::rect_t (canvas::coord_t (x, y),
80 : canvas::size_t (get_alloc_w (),
81 305 : child->get_req_h ())));
82 305 : y += child->get_req_h ();
83 : }
84 76 : }
85 :
86 : /* class text_art::text_widget : public text_art::leaf_widget. */
87 :
88 39277 : text_widget::text_widget (styled_string str)
89 39277 : : m_max_line_width (0)
90 : {
91 : // Split STR into multiple styled strings, one per line.
92 39277 : std::vector<styled_unichar> current_line;
93 39277 : int current_line_width = 0;
94 1347883 : for (auto ch : str)
95 : {
96 1308606 : if (ch.get_code () == '\n')
97 : {
98 12 : m_max_line_width = std::max (m_max_line_width, current_line_width);
99 12 : m_lines.push_back (styled_string (std::move (current_line)));
100 12 : current_line.clear ();
101 12 : current_line_width = 0;
102 : }
103 : else
104 : {
105 1308594 : current_line.push_back (ch);
106 1308594 : current_line_width += ch.get_canvas_width ();
107 : }
108 1308606 : }
109 39277 : if (!current_line.empty ())
110 : {
111 39273 : m_max_line_width = std::max (m_max_line_width, current_line_width);
112 39273 : m_lines.push_back (styled_string (std::move (current_line)));
113 : }
114 39277 : }
115 :
116 : const char *
117 0 : text_widget::get_desc () const
118 : {
119 0 : return "text_widget";
120 : }
121 :
122 : canvas::size_t
123 39050 : text_widget::calc_req_size ()
124 : {
125 39050 : return canvas::size_t (m_max_line_width, m_lines.size ());
126 : }
127 :
128 : void
129 39034 : text_widget::paint_to_canvas (canvas &canvas)
130 : {
131 39034 : canvas::coord_t line_xy = get_top_left ();
132 78076 : for (auto &line : m_lines)
133 : {
134 39042 : canvas.paint_text (line_xy, line);
135 39042 : ++line_xy.y;
136 : }
137 39034 : }
138 :
139 : /* class text_art::canvas_widget : public text_art::leaf_widget. */
140 :
141 : const char *
142 0 : canvas_widget::get_desc () const
143 : {
144 0 : return "canvas_widget";
145 : }
146 :
147 : canvas::size_t
148 4 : canvas_widget::calc_req_size ()
149 : {
150 4 : return m_canvas.get_size ();
151 : }
152 :
153 : void
154 4 : canvas_widget::paint_to_canvas (canvas &canvas)
155 : {
156 16 : for (int y = 0; y < m_canvas.get_size ().h; y++)
157 72 : for (int x = 0; x < m_canvas.get_size ().w; x++)
158 : {
159 60 : canvas::coord_t rel_xy (x, y);
160 60 : canvas.paint (get_top_left () + rel_xy,
161 60 : m_canvas.get (rel_xy));
162 : }
163 4 : }
164 :
165 : #if CHECKING_P
166 :
167 : namespace selftest {
168 :
169 : /* Concrete widget subclass for writing selftests.
170 : Requests a hard-coded size, and fills its allocated rectangle
171 : with a specific character. */
172 :
173 4 : class test_widget : public leaf_widget
174 : {
175 : public:
176 20 : test_widget (canvas::size_t size, char ch)
177 4 : : m_test_size (size), m_ch (ch)
178 : {}
179 :
180 0 : const char *get_desc () const final override
181 : {
182 0 : return "test_widget";
183 : }
184 20 : canvas::size_t calc_req_size () final override
185 : {
186 20 : return m_test_size;
187 : }
188 20 : void paint_to_canvas (canvas &canvas) final override
189 : {
190 20 : canvas.fill (get_alloc_rect (), canvas::cell_t (m_ch));
191 20 : }
192 :
193 : private:
194 : canvas::size_t m_test_size;
195 : char m_ch;
196 : };
197 :
198 : static void
199 4 : test_test_widget ()
200 : {
201 4 : style_manager sm;
202 4 : test_widget w (canvas::size_t (3, 3), 'A');
203 4 : canvas c (w.to_canvas (sm));
204 4 : ASSERT_CANVAS_STREQ
205 : (c, false,
206 : ("AAA\n"
207 : "AAA\n"
208 : "AAA\n"));
209 4 : }
210 :
211 : static void
212 4 : test_text_widget ()
213 : {
214 4 : style_manager sm;
215 4 : text_widget w (styled_string (sm, "hello world"));
216 4 : canvas c (w.to_canvas (sm));
217 4 : ASSERT_CANVAS_STREQ
218 : (c, false,
219 : ("hello world\n"));
220 4 : }
221 :
222 : static void
223 4 : test_multiline_text_widget ()
224 : {
225 4 : style_manager sm;
226 :
227 : // Without trailing newline:
228 4 : {
229 4 : text_widget w (styled_string (sm, "hello\n world"));
230 4 : ASSERT_EQ (w.get_req_size ().w, 6);
231 4 : ASSERT_EQ (w.get_req_size ().h, 2);
232 4 : canvas c (w.to_canvas (sm));
233 4 : ASSERT_CANVAS_STREQ
234 : (c, false,
235 : ("hello\n world\n"));
236 4 : }
237 :
238 : // With trailing newline:
239 4 : {
240 4 : text_widget w (styled_string (sm, "hello\n world\n"));
241 4 : ASSERT_EQ (w.get_req_size ().w, 6);
242 4 : ASSERT_EQ (w.get_req_size ().h, 2);
243 4 : canvas c (w.to_canvas (sm));
244 4 : ASSERT_CANVAS_STREQ
245 : (c, false,
246 : ("hello\n world\n"));
247 4 : }
248 4 : }
249 :
250 : static void
251 4 : test_wrapper_widget ()
252 : {
253 4 : style_manager sm;
254 4 : wrapper_widget w (std::make_unique<test_widget> (canvas::size_t (3, 3), 'B'));
255 4 : canvas c (w.to_canvas (sm));
256 4 : ASSERT_CANVAS_STREQ
257 : (c, false,
258 : ("BBB\n"
259 : "BBB\n"
260 : "BBB\n"));
261 4 : }
262 :
263 : static void
264 4 : test_empty_wrapper_widget ()
265 : {
266 4 : style_manager sm;
267 4 : wrapper_widget w (nullptr);
268 4 : canvas c (w.to_canvas (sm));
269 4 : ASSERT_CANVAS_STREQ (c, false, "");
270 4 : }
271 :
272 : static void
273 4 : test_vbox_1 ()
274 : {
275 4 : style_manager sm;
276 4 : vbox_widget w;
277 24 : for (int i = 0; i < 5; i++)
278 20 : w.add_child
279 20 : (std::make_unique <text_widget>
280 20 : (styled_string::from_fmt (sm, nullptr,
281 : "this is line %i", i)));
282 4 : canvas c (w.to_canvas (sm));
283 4 : ASSERT_CANVAS_STREQ
284 : (c, false,
285 : ("this is line 0\n"
286 : "this is line 1\n"
287 : "this is line 2\n"
288 : "this is line 3\n"
289 : "this is line 4\n"));
290 4 : }
291 :
292 : static void
293 4 : test_vbox_2 ()
294 : {
295 4 : style_manager sm;
296 4 : vbox_widget w;
297 4 : w.add_child (std::make_unique<test_widget> (canvas::size_t (1, 3), 'A'));
298 4 : w.add_child (std::make_unique<test_widget> (canvas::size_t (4, 1), 'B'));
299 4 : w.add_child (std::make_unique<test_widget> (canvas::size_t (1, 2), 'C'));
300 4 : canvas c (w.to_canvas (sm));
301 4 : ASSERT_CANVAS_STREQ
302 : (c, false,
303 : ("AAAA\n"
304 : "AAAA\n"
305 : "AAAA\n"
306 : "BBBB\n"
307 : "CCCC\n"
308 : "CCCC\n"));
309 4 : }
310 :
311 : static void
312 4 : test_canvas_widget ()
313 : {
314 4 : style_manager sm;
315 4 : canvas inner_canvas (canvas::size_t (5, 3), sm);
316 4 : inner_canvas.fill (canvas::rect_t (canvas::coord_t (0, 0),
317 4 : canvas::size_t (5, 3)),
318 4 : canvas::cell_t ('a'));
319 4 : canvas_widget cw (std::move (inner_canvas));
320 4 : canvas c (cw.to_canvas (sm));
321 4 : ASSERT_CANVAS_STREQ
322 : (c, false,
323 : ("aaaaa\n"
324 : "aaaaa\n"
325 : "aaaaa\n"));
326 4 : }
327 :
328 : /* Run all selftests in this file. */
329 :
330 : void
331 4 : text_art_widget_cc_tests ()
332 : {
333 4 : test_test_widget ();
334 4 : test_text_widget ();
335 4 : test_multiline_text_widget ();
336 4 : test_wrapper_widget ();
337 4 : test_empty_wrapper_widget ();
338 4 : test_vbox_1 ();
339 4 : test_vbox_2 ();
340 4 : test_canvas_widget ();
341 4 : }
342 :
343 : } // namespace selftest
344 :
345 :
346 : #endif /* #if CHECKING_P */
|