tools/perf/ui/browser.c

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