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 17 static 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 29 int 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 37 void 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 44 void ui_browser__gotorc(struct ui_browser *browser, int y, int x) 45 { 46 SLsmg_gotorc(browser->y + y, browser->x + x); 47 } 48 49 void 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 55 void 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 64 static struct list_head * 65 ui_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 77 static struct list_head * 78 ui_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 90 void 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 125 void 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 155 unsigned 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 176 bool ui_browser__is_current_entry(struct ui_browser *browser, unsigned row) 177 { 178 return browser->top_idx + row == browser->index; 179 } 180 181 void 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 189 void 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 196 int 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 222 int 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 232 bool 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 242 void 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 248 void __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 255 void 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 262 int 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 288 void 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 296 static 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 318 static 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 337 int 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 */ 352 void 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 370 int 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 482 unsigned 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 505 static 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 557 static 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 592 void 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 609 unsigned 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 633 void __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 642 void 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 650 static 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 } 686 out: 687 SLsmg_set_char_set(0); 688 } 689 690 static 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 } 726 out: 727 SLsmg_set_char_set(0); 728 } 729 730 void __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 739 void 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 } 752