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 20 static 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 32 int 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 40 void 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 47 void ui_browser__gotorc_title(struct ui_browser *browser, int y, int x) 48 { 49 SLsmg_gotorc(browser->y + y, browser->x + x); 50 } 51 52 void 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 57 void 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 63 void ui_browser__vprintf(struct ui_browser *browser __maybe_unused, const char *fmt, va_list args) 64 { 65 SLsmg_vprintf(fmt, args); 66 } 67 68 void 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 77 static struct list_head * 78 ui_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 90 static struct list_head * 91 ui_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 103 void 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 138 void 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 168 unsigned 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 189 bool ui_browser__is_current_entry(struct ui_browser *browser, unsigned row) 190 { 191 return browser->top_idx + row == browser->index; 192 } 193 194 void 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 203 void 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 210 int 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 236 int ui_browser__warn_unhandled_hotkey(struct ui_browser *browser, int key, int timeout, const char *help) 237 { 238 char kname[32]; 239 240 key_name(key, kname, sizeof(kname)); 241 return ui_browser__warning(browser, timeout, "\n'%s' key not associated%s!\n", kname, help ?: ""); 242 } 243 244 int ui_browser__help_window(struct ui_browser *browser, const char *text) 245 { 246 int key; 247 248 while ((key = ui__help_window(text)) == K_RESIZE) 249 ui_browser__handle_resize(browser); 250 251 return key; 252 } 253 254 bool ui_browser__dialog_yesno(struct ui_browser *browser, const char *text) 255 { 256 int key; 257 258 while ((key = ui__dialog_yesno(text)) == K_RESIZE) 259 ui_browser__handle_resize(browser); 260 261 return key == K_ENTER || toupper(key) == 'Y'; 262 } 263 264 void ui_browser__reset_index(struct ui_browser *browser) 265 { 266 browser->index = browser->top_idx = 0; 267 browser->seek(browser, 0, SEEK_SET); 268 } 269 270 void __ui_browser__show_title(struct ui_browser *browser, const char *title) 271 { 272 SLsmg_gotorc(0, 0); 273 ui_browser__set_color(browser, HE_COLORSET_ROOT); 274 ui_browser__write_nstring(browser, title, browser->width + 1); 275 } 276 277 void ui_browser__show_title(struct ui_browser *browser, const char *title) 278 { 279 mutex_lock(&ui__lock); 280 __ui_browser__show_title(browser, title); 281 mutex_unlock(&ui__lock); 282 } 283 284 int ui_browser__show(struct ui_browser *browser, const char *title, 285 const char *helpline, ...) 286 { 287 int err; 288 va_list ap; 289 290 if (browser->refresh_dimensions == NULL) 291 browser->refresh_dimensions = ui_browser__refresh_dimensions; 292 293 browser->refresh_dimensions(browser); 294 295 mutex_lock(&ui__lock); 296 __ui_browser__show_title(browser, title); 297 298 free(browser->title); 299 browser->title = strdup(title); 300 zfree(&browser->helpline); 301 302 va_start(ap, helpline); 303 err = vasprintf(&browser->helpline, helpline, ap); 304 va_end(ap); 305 if (err > 0) 306 ui_helpline__push(browser->helpline); 307 mutex_unlock(&ui__lock); 308 return err ? 0 : -1; 309 } 310 311 void ui_browser__hide(struct ui_browser *browser) 312 { 313 mutex_lock(&ui__lock); 314 ui_helpline__pop(); 315 zfree(&browser->helpline); 316 zfree(&browser->title); 317 mutex_unlock(&ui__lock); 318 } 319 320 static void ui_browser__scrollbar_set(struct ui_browser *browser) 321 { 322 int height = browser->height, h = 0, pct = 0, 323 col = browser->width, 324 row = 0; 325 326 if (browser->nr_entries > 1) { 327 pct = ((browser->index * (browser->height - 1)) / 328 (browser->nr_entries - 1)); 329 } 330 331 SLsmg_set_char_set(1); 332 333 while (h < height) { 334 ui_browser__gotorc(browser, row++, col); 335 SLsmg_write_char(h == pct ? SLSMG_DIAMOND_CHAR : SLSMG_CKBRD_CHAR); 336 ++h; 337 } 338 339 SLsmg_set_char_set(0); 340 } 341 342 static int __ui_browser__refresh(struct ui_browser *browser) 343 { 344 int row; 345 int width = browser->width; 346 347 row = browser->refresh(browser); 348 ui_browser__set_color(browser, HE_COLORSET_NORMAL); 349 350 if (!browser->use_navkeypressed || browser->navkeypressed) 351 ui_browser__scrollbar_set(browser); 352 else 353 width += 1; 354 355 SLsmg_fill_region(browser->y + row + browser->extra_title_lines, browser->x, 356 browser->rows - row, width, ' '); 357 358 if (browser->nr_entries == 0 && browser->no_samples_msg) 359 __ui__info_window(NULL, browser->no_samples_msg, NULL); 360 return 0; 361 } 362 363 int ui_browser__refresh(struct ui_browser *browser) 364 { 365 mutex_lock(&ui__lock); 366 __ui_browser__refresh(browser); 367 mutex_unlock(&ui__lock); 368 369 return 0; 370 } 371 372 /* 373 * Here we're updating nr_entries _after_ we started browsing, i.e. we have to 374 * forget about any reference to any entry in the underlying data structure, 375 * that is why we do a SEEK_SET. Think about 'perf top' in the hists browser 376 * after an output_resort and hist decay. 377 */ 378 void ui_browser__update_nr_entries(struct ui_browser *browser, u32 nr_entries) 379 { 380 off_t offset = nr_entries - browser->nr_entries; 381 382 browser->nr_entries = nr_entries; 383 384 if (offset < 0) { 385 if (browser->top_idx < (u64)-offset) 386 offset = -browser->top_idx; 387 388 browser->index += offset; 389 browser->top_idx += offset; 390 } 391 392 browser->top = NULL; 393 browser->seek(browser, browser->top_idx, SEEK_SET); 394 } 395 396 int ui_browser__run(struct ui_browser *browser, int delay_secs) 397 { 398 int err, key; 399 400 while (1) { 401 off_t offset; 402 403 mutex_lock(&ui__lock); 404 err = __ui_browser__refresh(browser); 405 SLsmg_refresh(); 406 mutex_unlock(&ui__lock); 407 if (err < 0) 408 break; 409 410 key = ui__getch(delay_secs); 411 412 if (key == K_RESIZE) { 413 ui__refresh_dimensions(false); 414 browser->refresh_dimensions(browser); 415 __ui_browser__show_title(browser, browser->title); 416 ui_helpline__puts(browser->helpline); 417 continue; 418 } 419 420 if (browser->use_navkeypressed && !browser->navkeypressed) { 421 if (key == K_DOWN || key == K_UP || 422 (browser->columns && (key == K_LEFT || key == K_RIGHT)) || 423 key == K_PGDN || key == K_PGUP || 424 key == K_HOME || key == K_END || 425 key == ' ') { 426 browser->navkeypressed = true; 427 continue; 428 } else 429 return key; 430 } 431 432 switch (key) { 433 case K_DOWN: 434 if (browser->index == browser->nr_entries - 1) 435 break; 436 ++browser->index; 437 if (browser->index == browser->top_idx + browser->rows) { 438 ++browser->top_idx; 439 browser->seek(browser, +1, SEEK_CUR); 440 } 441 break; 442 case K_UP: 443 if (browser->index == 0) 444 break; 445 --browser->index; 446 if (browser->index < browser->top_idx) { 447 --browser->top_idx; 448 browser->seek(browser, -1, SEEK_CUR); 449 } 450 break; 451 case K_RIGHT: 452 if (!browser->columns) 453 goto out; 454 if (browser->horiz_scroll < browser->columns - 1) 455 ++browser->horiz_scroll; 456 break; 457 case K_LEFT: 458 if (!browser->columns) 459 goto out; 460 if (browser->horiz_scroll != 0) 461 --browser->horiz_scroll; 462 else 463 goto out; 464 break; 465 case K_PGDN: 466 case ' ': 467 if (browser->top_idx + browser->rows > browser->nr_entries - 1) 468 break; 469 470 offset = browser->rows; 471 if (browser->index + offset > browser->nr_entries - 1) 472 offset = browser->nr_entries - 1 - browser->index; 473 browser->index += offset; 474 browser->top_idx += offset; 475 browser->seek(browser, +offset, SEEK_CUR); 476 break; 477 case K_PGUP: 478 if (browser->top_idx == 0) 479 break; 480 481 if (browser->top_idx < browser->rows) 482 offset = browser->top_idx; 483 else 484 offset = browser->rows; 485 486 browser->index -= offset; 487 browser->top_idx -= offset; 488 browser->seek(browser, -offset, SEEK_CUR); 489 break; 490 case K_HOME: 491 ui_browser__reset_index(browser); 492 break; 493 case K_END: 494 offset = browser->rows - 1; 495 if (offset >= browser->nr_entries) 496 offset = browser->nr_entries - 1; 497 498 browser->index = browser->nr_entries - 1; 499 browser->top_idx = browser->index - offset; 500 browser->seek(browser, -offset, SEEK_END); 501 break; 502 default: 503 out: 504 return key; 505 } 506 } 507 return -1; 508 } 509 510 unsigned int ui_browser__list_head_refresh(struct ui_browser *browser) 511 { 512 struct list_head *pos; 513 struct list_head *head = browser->entries; 514 int row = 0; 515 516 if (browser->nr_entries == 0) 517 return 0; 518 519 if (browser->top == NULL || browser->top == browser->entries) 520 browser->top = ui_browser__list_head_filter_entries(browser, head->next); 521 522 pos = browser->top; 523 524 list_for_each_from(pos, head) { 525 if (!browser->filter || !browser->filter(browser, pos)) { 526 ui_browser__gotorc(browser, row, 0); 527 browser->write(browser, pos, row); 528 if (++row == browser->rows) 529 break; 530 } 531 } 532 533 return row; 534 } 535 536 static struct ui_browser_colorset { 537 const char *name, *fg, *bg; 538 int colorset; 539 } ui_browser__colorsets[] = { 540 { 541 .colorset = HE_COLORSET_TOP, 542 .name = "top", 543 .fg = "red", 544 .bg = "default", 545 }, 546 { 547 .colorset = HE_COLORSET_MEDIUM, 548 .name = "medium", 549 .fg = "green", 550 .bg = "default", 551 }, 552 { 553 .colorset = HE_COLORSET_NORMAL, 554 .name = "normal", 555 .fg = "default", 556 .bg = "default", 557 }, 558 { 559 .colorset = HE_COLORSET_SELECTED, 560 .name = "selected", 561 .fg = "black", 562 .bg = "yellow", 563 }, 564 { 565 .colorset = HE_COLORSET_JUMP_ARROWS, 566 .name = "jump_arrows", 567 .fg = "blue", 568 .bg = "default", 569 }, 570 { 571 .colorset = HE_COLORSET_ADDR, 572 .name = "addr", 573 .fg = "magenta", 574 .bg = "default", 575 }, 576 { 577 .colorset = HE_COLORSET_ROOT, 578 .name = "root", 579 .fg = "white", 580 .bg = "blue", 581 }, 582 { 583 .name = NULL, 584 } 585 }; 586 587 588 static int ui_browser__color_config(const char *var, const char *value, 589 void *data __maybe_unused) 590 { 591 char *fg = NULL, *bg; 592 int i; 593 594 /* same dir for all commands */ 595 if (!strstarts(var, "colors.") != 0) 596 return 0; 597 598 for (i = 0; ui_browser__colorsets[i].name != NULL; ++i) { 599 const char *name = var + 7; 600 601 if (strcmp(ui_browser__colorsets[i].name, name) != 0) 602 continue; 603 604 fg = strdup(value); 605 if (fg == NULL) 606 break; 607 608 bg = strchr(fg, ','); 609 if (bg == NULL) 610 break; 611 612 *bg = '\0'; 613 bg = skip_spaces(bg + 1); 614 ui_browser__colorsets[i].bg = bg; 615 ui_browser__colorsets[i].fg = fg; 616 return 0; 617 } 618 619 free(fg); 620 return -1; 621 } 622 623 void ui_browser__argv_seek(struct ui_browser *browser, off_t offset, int whence) 624 { 625 switch (whence) { 626 case SEEK_SET: 627 browser->top = browser->entries; 628 break; 629 case SEEK_CUR: 630 browser->top = (char **)browser->top + offset; 631 break; 632 case SEEK_END: 633 browser->top = (char **)browser->entries + browser->nr_entries - 1 + offset; 634 break; 635 default: 636 return; 637 } 638 assert((char **)browser->top < (char **)browser->entries + browser->nr_entries); 639 assert((char **)browser->top >= (char **)browser->entries); 640 } 641 642 unsigned int ui_browser__argv_refresh(struct ui_browser *browser) 643 { 644 unsigned int row = 0, idx = browser->top_idx; 645 char **pos; 646 647 if (browser->top == NULL) 648 browser->top = browser->entries; 649 650 pos = (char **)browser->top; 651 while (idx < browser->nr_entries && 652 row < (unsigned)SLtt_Screen_Rows - 1) { 653 assert(pos < (char **)browser->entries + browser->nr_entries); 654 if (!browser->filter || !browser->filter(browser, *pos)) { 655 ui_browser__gotorc(browser, row, 0); 656 browser->write(browser, pos, row); 657 if (++row == browser->rows) 658 break; 659 } 660 661 ++idx; 662 ++pos; 663 } 664 665 return row; 666 } 667 668 void __ui_browser__vline(struct ui_browser *browser, unsigned int column, 669 u16 start, u16 end) 670 { 671 SLsmg_set_char_set(1); 672 ui_browser__gotorc(browser, start, column); 673 SLsmg_draw_vline(end - start + 1); 674 SLsmg_set_char_set(0); 675 } 676 677 void ui_browser__write_graph(struct ui_browser *browser __maybe_unused, 678 int graph) 679 { 680 SLsmg_set_char_set(1); 681 SLsmg_write_char(graph); 682 SLsmg_set_char_set(0); 683 } 684 685 static void __ui_browser__line_arrow_up(struct ui_browser *browser, 686 unsigned int column, 687 u64 start, u64 end) 688 { 689 unsigned int row, end_row; 690 691 SLsmg_set_char_set(1); 692 693 if (start < browser->top_idx + browser->rows) { 694 row = start - browser->top_idx; 695 ui_browser__gotorc(browser, row, column); 696 SLsmg_write_char(SLSMG_LLCORN_CHAR); 697 ui_browser__gotorc(browser, row, column + 1); 698 SLsmg_draw_hline(2); 699 700 if (row-- == 0) 701 goto out; 702 } else 703 row = browser->rows - 1; 704 705 if (end > browser->top_idx) 706 end_row = end - browser->top_idx; 707 else 708 end_row = 0; 709 710 ui_browser__gotorc(browser, end_row, column); 711 SLsmg_draw_vline(row - end_row + 1); 712 713 ui_browser__gotorc(browser, end_row, column); 714 if (end >= browser->top_idx) { 715 SLsmg_write_char(SLSMG_ULCORN_CHAR); 716 ui_browser__gotorc(browser, end_row, column + 1); 717 SLsmg_write_char(SLSMG_HLINE_CHAR); 718 ui_browser__gotorc(browser, end_row, column + 2); 719 SLsmg_write_char(SLSMG_RARROW_CHAR); 720 } 721 out: 722 SLsmg_set_char_set(0); 723 } 724 725 static void __ui_browser__line_arrow_down(struct ui_browser *browser, 726 unsigned int column, 727 u64 start, u64 end) 728 { 729 unsigned int row, end_row; 730 731 SLsmg_set_char_set(1); 732 733 if (start >= browser->top_idx) { 734 row = start - browser->top_idx; 735 ui_browser__gotorc(browser, row, column); 736 SLsmg_write_char(SLSMG_ULCORN_CHAR); 737 ui_browser__gotorc(browser, row, column + 1); 738 SLsmg_draw_hline(2); 739 740 if (++row == 0) 741 goto out; 742 } else 743 row = 0; 744 745 if (end >= browser->top_idx + browser->rows) 746 end_row = browser->rows - 1; 747 else 748 end_row = end - browser->top_idx; 749 750 ui_browser__gotorc(browser, row, column); 751 SLsmg_draw_vline(end_row - row + 1); 752 753 ui_browser__gotorc(browser, end_row, column); 754 if (end < browser->top_idx + browser->rows) { 755 SLsmg_write_char(SLSMG_LLCORN_CHAR); 756 ui_browser__gotorc(browser, end_row, column + 1); 757 SLsmg_write_char(SLSMG_HLINE_CHAR); 758 ui_browser__gotorc(browser, end_row, column + 2); 759 SLsmg_write_char(SLSMG_RARROW_CHAR); 760 } 761 out: 762 SLsmg_set_char_set(0); 763 } 764 765 void __ui_browser__line_arrow(struct ui_browser *browser, unsigned int column, 766 u64 start, u64 end) 767 { 768 if (start > end) 769 __ui_browser__line_arrow_up(browser, column, start, end); 770 else 771 __ui_browser__line_arrow_down(browser, column, start, end); 772 } 773 774 void ui_browser__mark_fused(struct ui_browser *browser, unsigned int column, 775 unsigned int row, int diff, bool arrow_down) 776 { 777 int end_row; 778 779 if (diff <= 0) 780 return; 781 782 SLsmg_set_char_set(1); 783 784 if (arrow_down) { 785 if (row + diff <= browser->top_idx) 786 return; 787 788 end_row = row + diff - browser->top_idx; 789 ui_browser__gotorc(browser, end_row, column - 1); 790 SLsmg_write_char(SLSMG_LTEE_CHAR); 791 792 while (--end_row >= 0 && end_row > (int)(row - browser->top_idx)) { 793 ui_browser__gotorc(browser, end_row, column - 1); 794 SLsmg_draw_vline(1); 795 } 796 797 end_row = (int)(row - browser->top_idx); 798 if (end_row >= 0) { 799 ui_browser__gotorc(browser, end_row, column - 1); 800 SLsmg_write_char(SLSMG_ULCORN_CHAR); 801 ui_browser__gotorc(browser, end_row, column); 802 SLsmg_draw_hline(2); 803 } 804 } else { 805 if (row < browser->top_idx) 806 return; 807 808 end_row = row - browser->top_idx; 809 ui_browser__gotorc(browser, end_row, column - 1); 810 SLsmg_write_char(SLSMG_LTEE_CHAR); 811 ui_browser__gotorc(browser, end_row, column); 812 SLsmg_draw_hline(2); 813 } 814 815 SLsmg_set_char_set(0); 816 } 817 818 void ui_browser__init(void) 819 { 820 int i = 0; 821 822 perf_config(ui_browser__color_config, NULL); 823 824 while (ui_browser__colorsets[i].name) { 825 struct ui_browser_colorset *c = &ui_browser__colorsets[i++]; 826 SLtt_set_color(c->colorset, c->name, c->fg, c->bg); 827 } 828 } 829