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