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