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