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