xref: /openbmc/linux/tools/perf/ui/browser.c (revision b8d312aa) 
1 // SPDX-License-Identifier: GPL-2.0
2 #include "../string2.h"
3 #include "../config.h"
4 #include "../../perf.h"
5 #include "libslang.h"
6 #include "ui.h"
7 #include "util.h"
8 #include <linux/compiler.h>
9 #include <linux/list.h>
10 #include <linux/rbtree.h>
11 #include <linux/string.h>
12 #include <stdlib.h>
13 #include <sys/ttydefaults.h>
14 #include "browser.h"
15 #include "helpline.h"
16 #include "keysyms.h"
17 #include "../color.h"
18 #include <linux/ctype.h>
19 #include <linux/zalloc.h>
20 
21 static int ui_browser__percent_color(struct ui_browser *browser,
22 				     double percent, bool current)
23 {
24 	if (current && (!browser->use_navkeypressed || browser->navkeypressed))
25 		return HE_COLORSET_SELECTED;
26 	if (percent >= MIN_RED)
27 		return HE_COLORSET_TOP;
28 	if (percent >= MIN_GREEN)
29 		return HE_COLORSET_MEDIUM;
30 	return HE_COLORSET_NORMAL;
31 }
32 
33 int ui_browser__set_color(struct ui_browser *browser, int color)
34 {
35 	int ret = browser->current_color;
36 	browser->current_color = color;
37 	SLsmg_set_color(color);
38 	return ret;
39 }
40 
41 void ui_browser__set_percent_color(struct ui_browser *browser,
42 				   double percent, bool current)
43 {
44 	 int color = ui_browser__percent_color(browser, percent, current);
45 	 ui_browser__set_color(browser, color);
46 }
47 
48 void ui_browser__gotorc_title(struct ui_browser *browser, int y, int x)
49 {
50 	SLsmg_gotorc(browser->y + y, browser->x + x);
51 }
52 
53 void ui_browser__gotorc(struct ui_browser *browser, int y, int x)
54 {
55 	SLsmg_gotorc(browser->y + y + browser->extra_title_lines, browser->x + x);
56 }
57 
58 void ui_browser__write_nstring(struct ui_browser *browser __maybe_unused, const char *msg,
59 			       unsigned int width)
60 {
61 	slsmg_write_nstring(msg, width);
62 }
63 
64 void ui_browser__vprintf(struct ui_browser *browser __maybe_unused, const char *fmt, va_list args)
65 {
66 	slsmg_vprintf(fmt, args);
67 }
68 
69 void ui_browser__printf(struct ui_browser *browser __maybe_unused, const char *fmt, ...)
70 {
71 	va_list args;
72 
73 	va_start(args, fmt);
74 	ui_browser__vprintf(browser, fmt, args);
75 	va_end(args);
76 }
77 
78 static struct list_head *
79 ui_browser__list_head_filter_entries(struct ui_browser *browser,
80 				     struct list_head *pos)
81 {
82 	do {
83 		if (!browser->filter || !browser->filter(browser, pos))
84 			return pos;
85 		pos = pos->next;
86 	} while (pos != browser->entries);
87 
88 	return NULL;
89 }
90 
91 static struct list_head *
92 ui_browser__list_head_filter_prev_entries(struct ui_browser *browser,
93 					  struct list_head *pos)
94 {
95 	do {
96 		if (!browser->filter || !browser->filter(browser, pos))
97 			return pos;
98 		pos = pos->prev;
99 	} while (pos != browser->entries);
100 
101 	return NULL;
102 }
103 
104 void ui_browser__list_head_seek(struct ui_browser *browser, off_t offset, int whence)
105 {
106 	struct list_head *head = browser->entries;
107 	struct list_head *pos;
108 
109 	if (browser->nr_entries == 0)
110 		return;
111 
112 	switch (whence) {
113 	case SEEK_SET:
114 		pos = ui_browser__list_head_filter_entries(browser, head->next);
115 		break;
116 	case SEEK_CUR:
117 		pos = browser->top;
118 		break;
119 	case SEEK_END:
120 		pos = ui_browser__list_head_filter_prev_entries(browser, head->prev);
121 		break;
122 	default:
123 		return;
124 	}
125 
126 	assert(pos != NULL);
127 
128 	if (offset > 0) {
129 		while (offset-- != 0)
130 			pos = ui_browser__list_head_filter_entries(browser, pos->next);
131 	} else {
132 		while (offset++ != 0)
133 			pos = ui_browser__list_head_filter_prev_entries(browser, pos->prev);
134 	}
135 
136 	browser->top = pos;
137 }
138 
139 void ui_browser__rb_tree_seek(struct ui_browser *browser, off_t offset, int whence)
140 {
141 	struct rb_root *root = browser->entries;
142 	struct rb_node *nd;
143 
144 	switch (whence) {
145 	case SEEK_SET:
146 		nd = rb_first(root);
147 		break;
148 	case SEEK_CUR:
149 		nd = browser->top;
150 		break;
151 	case SEEK_END:
152 		nd = rb_last(root);
153 		break;
154 	default:
155 		return;
156 	}
157 
158 	if (offset > 0) {
159 		while (offset-- != 0)
160 			nd = rb_next(nd);
161 	} else {
162 		while (offset++ != 0)
163 			nd = rb_prev(nd);
164 	}
165 
166 	browser->top = nd;
167 }
168 
169 unsigned int ui_browser__rb_tree_refresh(struct ui_browser *browser)
170 {
171 	struct rb_node *nd;
172 	int row = 0;
173 
174 	if (browser->top == NULL)
175                 browser->top = rb_first(browser->entries);
176 
177 	nd = browser->top;
178 
179 	while (nd != NULL) {
180 		ui_browser__gotorc(browser, row, 0);
181 		browser->write(browser, nd, row);
182 		if (++row == browser->rows)
183 			break;
184 		nd = rb_next(nd);
185 	}
186 
187 	return row;
188 }
189 
190 bool ui_browser__is_current_entry(struct ui_browser *browser, unsigned row)
191 {
192 	return browser->top_idx + row == browser->index;
193 }
194 
195 void ui_browser__refresh_dimensions(struct ui_browser *browser)
196 {
197 	browser->width = SLtt_Screen_Cols - 1;
198 	browser->height = browser->rows = SLtt_Screen_Rows - 2;
199 	browser->rows -= browser->extra_title_lines;
200 	browser->y = 1;
201 	browser->x = 0;
202 }
203 
204 void ui_browser__handle_resize(struct ui_browser *browser)
205 {
206 	ui__refresh_dimensions(false);
207 	ui_browser__show(browser, browser->title, ui_helpline__current);
208 	ui_browser__refresh(browser);
209 }
210 
211 int ui_browser__warning(struct ui_browser *browser, int timeout,
212 			const char *format, ...)
213 {
214 	va_list args;
215 	char *text;
216 	int key = 0, err;
217 
218 	va_start(args, format);
219 	err = vasprintf(&text, format, args);
220 	va_end(args);
221 
222 	if (err < 0) {
223 		va_start(args, format);
224 		ui_helpline__vpush(format, args);
225 		va_end(args);
226 	} else {
227 		while ((key = ui__question_window("Warning!", text,
228 						   "Press any key...",
229 						   timeout)) == K_RESIZE)
230 			ui_browser__handle_resize(browser);
231 		free(text);
232 	}
233 
234 	return key;
235 }
236 
237 int ui_browser__help_window(struct ui_browser *browser, const char *text)
238 {
239 	int key;
240 
241 	while ((key = ui__help_window(text)) == K_RESIZE)
242 		ui_browser__handle_resize(browser);
243 
244 	return key;
245 }
246 
247 bool ui_browser__dialog_yesno(struct ui_browser *browser, const char *text)
248 {
249 	int key;
250 
251 	while ((key = ui__dialog_yesno(text)) == K_RESIZE)
252 		ui_browser__handle_resize(browser);
253 
254 	return key == K_ENTER || toupper(key) == 'Y';
255 }
256 
257 void ui_browser__reset_index(struct ui_browser *browser)
258 {
259 	browser->index = browser->top_idx = 0;
260 	browser->seek(browser, 0, SEEK_SET);
261 }
262 
263 void __ui_browser__show_title(struct ui_browser *browser, const char *title)
264 {
265 	SLsmg_gotorc(0, 0);
266 	ui_browser__set_color(browser, HE_COLORSET_ROOT);
267 	ui_browser__write_nstring(browser, title, browser->width + 1);
268 }
269 
270 void ui_browser__show_title(struct ui_browser *browser, const char *title)
271 {
272 	pthread_mutex_lock(&ui__lock);
273 	__ui_browser__show_title(browser, title);
274 	pthread_mutex_unlock(&ui__lock);
275 }
276 
277 int ui_browser__show(struct ui_browser *browser, const char *title,
278 		     const char *helpline, ...)
279 {
280 	int err;
281 	va_list ap;
282 
283 	if (browser->refresh_dimensions == NULL)
284 		browser->refresh_dimensions = ui_browser__refresh_dimensions;
285 
286 	browser->refresh_dimensions(browser);
287 
288 	pthread_mutex_lock(&ui__lock);
289 	__ui_browser__show_title(browser, title);
290 
291 	browser->title = title;
292 	zfree(&browser->helpline);
293 
294 	va_start(ap, helpline);
295 	err = vasprintf(&browser->helpline, helpline, ap);
296 	va_end(ap);
297 	if (err > 0)
298 		ui_helpline__push(browser->helpline);
299 	pthread_mutex_unlock(&ui__lock);
300 	return err ? 0 : -1;
301 }
302 
303 void ui_browser__hide(struct ui_browser *browser)
304 {
305 	pthread_mutex_lock(&ui__lock);
306 	ui_helpline__pop();
307 	zfree(&browser->helpline);
308 	pthread_mutex_unlock(&ui__lock);
309 }
310 
311 static void ui_browser__scrollbar_set(struct ui_browser *browser)
312 {
313 	int height = browser->height, h = 0, pct = 0,
314 	    col = browser->width,
315 	    row = 0;
316 
317 	if (browser->nr_entries > 1) {
318 		pct = ((browser->index * (browser->height - 1)) /
319 		       (browser->nr_entries - 1));
320 	}
321 
322 	SLsmg_set_char_set(1);
323 
324 	while (h < height) {
325 	        ui_browser__gotorc(browser, row++, col);
326 		SLsmg_write_char(h == pct ? SLSMG_DIAMOND_CHAR : SLSMG_CKBRD_CHAR);
327 		++h;
328 	}
329 
330 	SLsmg_set_char_set(0);
331 }
332 
333 static int __ui_browser__refresh(struct ui_browser *browser)
334 {
335 	int row;
336 	int width = browser->width;
337 
338 	row = browser->refresh(browser);
339 	ui_browser__set_color(browser, HE_COLORSET_NORMAL);
340 
341 	if (!browser->use_navkeypressed || browser->navkeypressed)
342 		ui_browser__scrollbar_set(browser);
343 	else
344 		width += 1;
345 
346 	SLsmg_fill_region(browser->y + row + browser->extra_title_lines, browser->x,
347 			  browser->rows - row, width, ' ');
348 
349 	return 0;
350 }
351 
352 int ui_browser__refresh(struct ui_browser *browser)
353 {
354 	pthread_mutex_lock(&ui__lock);
355 	__ui_browser__refresh(browser);
356 	pthread_mutex_unlock(&ui__lock);
357 
358 	return 0;
359 }
360 
361 /*
362  * Here we're updating nr_entries _after_ we started browsing, i.e.  we have to
363  * forget about any reference to any entry in the underlying data structure,
364  * that is why we do a SEEK_SET. Think about 'perf top' in the hists browser
365  * after an output_resort and hist decay.
366  */
367 void ui_browser__update_nr_entries(struct ui_browser *browser, u32 nr_entries)
368 {
369 	off_t offset = nr_entries - browser->nr_entries;
370 
371 	browser->nr_entries = nr_entries;
372 
373 	if (offset < 0) {
374 		if (browser->top_idx < (u64)-offset)
375 			offset = -browser->top_idx;
376 
377 		browser->index += offset;
378 		browser->top_idx += offset;
379 	}
380 
381 	browser->top = NULL;
382 	browser->seek(browser, browser->top_idx, SEEK_SET);
383 }
384 
385 int ui_browser__run(struct ui_browser *browser, int delay_secs)
386 {
387 	int err, key;
388 
389 	while (1) {
390 		off_t offset;
391 
392 		pthread_mutex_lock(&ui__lock);
393 		err = __ui_browser__refresh(browser);
394 		SLsmg_refresh();
395 		pthread_mutex_unlock(&ui__lock);
396 		if (err < 0)
397 			break;
398 
399 		key = ui__getch(delay_secs);
400 
401 		if (key == K_RESIZE) {
402 			ui__refresh_dimensions(false);
403 			browser->refresh_dimensions(browser);
404 			__ui_browser__show_title(browser, browser->title);
405 			ui_helpline__puts(browser->helpline);
406 			continue;
407 		}
408 
409 		if (browser->use_navkeypressed && !browser->navkeypressed) {
410 			if (key == K_DOWN || key == K_UP ||
411 			    (browser->columns && (key == K_LEFT || key == K_RIGHT)) ||
412 			    key == K_PGDN || key == K_PGUP ||
413 			    key == K_HOME || key == K_END ||
414 			    key == ' ') {
415 				browser->navkeypressed = true;
416 				continue;
417 			} else
418 				return key;
419 		}
420 
421 		switch (key) {
422 		case K_DOWN:
423 			if (browser->index == browser->nr_entries - 1)
424 				break;
425 			++browser->index;
426 			if (browser->index == browser->top_idx + browser->rows) {
427 				++browser->top_idx;
428 				browser->seek(browser, +1, SEEK_CUR);
429 			}
430 			break;
431 		case K_UP:
432 			if (browser->index == 0)
433 				break;
434 			--browser->index;
435 			if (browser->index < browser->top_idx) {
436 				--browser->top_idx;
437 				browser->seek(browser, -1, SEEK_CUR);
438 			}
439 			break;
440 		case K_RIGHT:
441 			if (!browser->columns)
442 				goto out;
443 			if (browser->horiz_scroll < browser->columns - 1)
444 				++browser->horiz_scroll;
445 			break;
446 		case K_LEFT:
447 			if (!browser->columns)
448 				goto out;
449 			if (browser->horiz_scroll != 0)
450 				--browser->horiz_scroll;
451 			break;
452 		case K_PGDN:
453 		case ' ':
454 			if (browser->top_idx + browser->rows > browser->nr_entries - 1)
455 				break;
456 
457 			offset = browser->rows;
458 			if (browser->index + offset > browser->nr_entries - 1)
459 				offset = browser->nr_entries - 1 - browser->index;
460 			browser->index += offset;
461 			browser->top_idx += offset;
462 			browser->seek(browser, +offset, SEEK_CUR);
463 			break;
464 		case K_PGUP:
465 			if (browser->top_idx == 0)
466 				break;
467 
468 			if (browser->top_idx < browser->rows)
469 				offset = browser->top_idx;
470 			else
471 				offset = browser->rows;
472 
473 			browser->index -= offset;
474 			browser->top_idx -= offset;
475 			browser->seek(browser, -offset, SEEK_CUR);
476 			break;
477 		case K_HOME:
478 			ui_browser__reset_index(browser);
479 			break;
480 		case K_END:
481 			offset = browser->rows - 1;
482 			if (offset >= browser->nr_entries)
483 				offset = browser->nr_entries - 1;
484 
485 			browser->index = browser->nr_entries - 1;
486 			browser->top_idx = browser->index - offset;
487 			browser->seek(browser, -offset, SEEK_END);
488 			break;
489 		default:
490 		out:
491 			return key;
492 		}
493 	}
494 	return -1;
495 }
496 
497 unsigned int ui_browser__list_head_refresh(struct ui_browser *browser)
498 {
499 	struct list_head *pos;
500 	struct list_head *head = browser->entries;
501 	int row = 0;
502 
503 	if (browser->top == NULL || browser->top == browser->entries)
504                 browser->top = ui_browser__list_head_filter_entries(browser, head->next);
505 
506 	pos = browser->top;
507 
508 	list_for_each_from(pos, head) {
509 		if (!browser->filter || !browser->filter(browser, pos)) {
510 			ui_browser__gotorc(browser, row, 0);
511 			browser->write(browser, pos, row);
512 			if (++row == browser->rows)
513 				break;
514 		}
515 	}
516 
517 	return row;
518 }
519 
520 static struct ui_browser_colorset {
521 	const char *name, *fg, *bg;
522 	int colorset;
523 } ui_browser__colorsets[] = {
524 	{
525 		.colorset = HE_COLORSET_TOP,
526 		.name	  = "top",
527 		.fg	  = "red",
528 		.bg	  = "default",
529 	},
530 	{
531 		.colorset = HE_COLORSET_MEDIUM,
532 		.name	  = "medium",
533 		.fg	  = "green",
534 		.bg	  = "default",
535 	},
536 	{
537 		.colorset = HE_COLORSET_NORMAL,
538 		.name	  = "normal",
539 		.fg	  = "default",
540 		.bg	  = "default",
541 	},
542 	{
543 		.colorset = HE_COLORSET_SELECTED,
544 		.name	  = "selected",
545 		.fg	  = "black",
546 		.bg	  = "yellow",
547 	},
548 	{
549 		.colorset = HE_COLORSET_JUMP_ARROWS,
550 		.name	  = "jump_arrows",
551 		.fg	  = "blue",
552 		.bg	  = "default",
553 	},
554 	{
555 		.colorset = HE_COLORSET_ADDR,
556 		.name	  = "addr",
557 		.fg	  = "magenta",
558 		.bg	  = "default",
559 	},
560 	{
561 		.colorset = HE_COLORSET_ROOT,
562 		.name	  = "root",
563 		.fg	  = "white",
564 		.bg	  = "blue",
565 	},
566 	{
567 		.name = NULL,
568 	}
569 };
570 
571 
572 static int ui_browser__color_config(const char *var, const char *value,
573 				    void *data __maybe_unused)
574 {
575 	char *fg = NULL, *bg;
576 	int i;
577 
578 	/* same dir for all commands */
579 	if (!strstarts(var, "colors.") != 0)
580 		return 0;
581 
582 	for (i = 0; ui_browser__colorsets[i].name != NULL; ++i) {
583 		const char *name = var + 7;
584 
585 		if (strcmp(ui_browser__colorsets[i].name, name) != 0)
586 			continue;
587 
588 		fg = strdup(value);
589 		if (fg == NULL)
590 			break;
591 
592 		bg = strchr(fg, ',');
593 		if (bg == NULL)
594 			break;
595 
596 		*bg = '\0';
597 		bg = skip_spaces(bg + 1);
598 		ui_browser__colorsets[i].bg = bg;
599 		ui_browser__colorsets[i].fg = fg;
600 		return 0;
601 	}
602 
603 	free(fg);
604 	return -1;
605 }
606 
607 void ui_browser__argv_seek(struct ui_browser *browser, off_t offset, int whence)
608 {
609 	switch (whence) {
610 	case SEEK_SET:
611 		browser->top = browser->entries;
612 		break;
613 	case SEEK_CUR:
614 		browser->top = (char **)browser->top + offset;
615 		break;
616 	case SEEK_END:
617 		browser->top = (char **)browser->entries + browser->nr_entries - 1 + offset;
618 		break;
619 	default:
620 		return;
621 	}
622 	assert((char **)browser->top < (char **)browser->entries + browser->nr_entries);
623 	assert((char **)browser->top >= (char **)browser->entries);
624 }
625 
626 unsigned int ui_browser__argv_refresh(struct ui_browser *browser)
627 {
628 	unsigned int row = 0, idx = browser->top_idx;
629 	char **pos;
630 
631 	if (browser->top == NULL)
632 		browser->top = browser->entries;
633 
634 	pos = (char **)browser->top;
635 	while (idx < browser->nr_entries &&
636 	       row < (unsigned)SLtt_Screen_Rows - 1) {
637 		assert(pos < (char **)browser->entries + browser->nr_entries);
638 		if (!browser->filter || !browser->filter(browser, *pos)) {
639 			ui_browser__gotorc(browser, row, 0);
640 			browser->write(browser, pos, row);
641 			if (++row == browser->rows)
642 				break;
643 		}
644 
645 		++idx;
646 		++pos;
647 	}
648 
649 	return row;
650 }
651 
652 void __ui_browser__vline(struct ui_browser *browser, unsigned int column,
653 			 u16 start, u16 end)
654 {
655 	SLsmg_set_char_set(1);
656 	ui_browser__gotorc(browser, start, column);
657 	SLsmg_draw_vline(end - start + 1);
658 	SLsmg_set_char_set(0);
659 }
660 
661 void ui_browser__write_graph(struct ui_browser *browser __maybe_unused,
662 			     int graph)
663 {
664 	SLsmg_set_char_set(1);
665 	SLsmg_write_char(graph);
666 	SLsmg_set_char_set(0);
667 }
668 
669 static void __ui_browser__line_arrow_up(struct ui_browser *browser,
670 					unsigned int column,
671 					u64 start, u64 end)
672 {
673 	unsigned int row, end_row;
674 
675 	SLsmg_set_char_set(1);
676 
677 	if (start < browser->top_idx + browser->rows) {
678 		row = start - browser->top_idx;
679 		ui_browser__gotorc(browser, row, column);
680 		SLsmg_write_char(SLSMG_LLCORN_CHAR);
681 		ui_browser__gotorc(browser, row, column + 1);
682 		SLsmg_draw_hline(2);
683 
684 		if (row-- == 0)
685 			goto out;
686 	} else
687 		row = browser->rows - 1;
688 
689 	if (end > browser->top_idx)
690 		end_row = end - browser->top_idx;
691 	else
692 		end_row = 0;
693 
694 	ui_browser__gotorc(browser, end_row, column);
695 	SLsmg_draw_vline(row - end_row + 1);
696 
697 	ui_browser__gotorc(browser, end_row, column);
698 	if (end >= browser->top_idx) {
699 		SLsmg_write_char(SLSMG_ULCORN_CHAR);
700 		ui_browser__gotorc(browser, end_row, column + 1);
701 		SLsmg_write_char(SLSMG_HLINE_CHAR);
702 		ui_browser__gotorc(browser, end_row, column + 2);
703 		SLsmg_write_char(SLSMG_RARROW_CHAR);
704 	}
705 out:
706 	SLsmg_set_char_set(0);
707 }
708 
709 static void __ui_browser__line_arrow_down(struct ui_browser *browser,
710 					  unsigned int column,
711 					  u64 start, u64 end)
712 {
713 	unsigned int row, end_row;
714 
715 	SLsmg_set_char_set(1);
716 
717 	if (start >= browser->top_idx) {
718 		row = start - browser->top_idx;
719 		ui_browser__gotorc(browser, row, column);
720 		SLsmg_write_char(SLSMG_ULCORN_CHAR);
721 		ui_browser__gotorc(browser, row, column + 1);
722 		SLsmg_draw_hline(2);
723 
724 		if (++row == 0)
725 			goto out;
726 	} else
727 		row = 0;
728 
729 	if (end >= browser->top_idx + browser->rows)
730 		end_row = browser->rows - 1;
731 	else
732 		end_row = end - browser->top_idx;
733 
734 	ui_browser__gotorc(browser, row, column);
735 	SLsmg_draw_vline(end_row - row + 1);
736 
737 	ui_browser__gotorc(browser, end_row, column);
738 	if (end < browser->top_idx + browser->rows) {
739 		SLsmg_write_char(SLSMG_LLCORN_CHAR);
740 		ui_browser__gotorc(browser, end_row, column + 1);
741 		SLsmg_write_char(SLSMG_HLINE_CHAR);
742 		ui_browser__gotorc(browser, end_row, column + 2);
743 		SLsmg_write_char(SLSMG_RARROW_CHAR);
744 	}
745 out:
746 	SLsmg_set_char_set(0);
747 }
748 
749 void __ui_browser__line_arrow(struct ui_browser *browser, unsigned int column,
750 			      u64 start, u64 end)
751 {
752 	if (start > end)
753 		__ui_browser__line_arrow_up(browser, column, start, end);
754 	else
755 		__ui_browser__line_arrow_down(browser, column, start, end);
756 }
757 
758 void ui_browser__mark_fused(struct ui_browser *browser, unsigned int column,
759 			    unsigned int row, bool arrow_down)
760 {
761 	unsigned int end_row;
762 
763 	if (row >= browser->top_idx)
764 		end_row = row - browser->top_idx;
765 	else
766 		return;
767 
768 	SLsmg_set_char_set(1);
769 
770 	if (arrow_down) {
771 		ui_browser__gotorc(browser, end_row, column - 1);
772 		SLsmg_write_char(SLSMG_ULCORN_CHAR);
773 		ui_browser__gotorc(browser, end_row, column);
774 		SLsmg_draw_hline(2);
775 		ui_browser__gotorc(browser, end_row + 1, column - 1);
776 		SLsmg_write_char(SLSMG_LTEE_CHAR);
777 	} else {
778 		ui_browser__gotorc(browser, end_row, column - 1);
779 		SLsmg_write_char(SLSMG_LTEE_CHAR);
780 		ui_browser__gotorc(browser, end_row, column);
781 		SLsmg_draw_hline(2);
782 	}
783 
784 	SLsmg_set_char_set(0);
785 }
786 
787 void ui_browser__init(void)
788 {
789 	int i = 0;
790 
791 	perf_config(ui_browser__color_config, NULL);
792 
793 	while (ui_browser__colorsets[i].name) {
794 		struct ui_browser_colorset *c = &ui_browser__colorsets[i++];
795 		sltt_set_color(c->colorset, c->name, c->fg, c->bg);
796 	}
797 }
798