tools/perf/ui/browser.c

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