tools/perf/util/ui/browser.c

   1 #include "../util.h"
   2 #include "../cache.h"
   3 #include "../../perf.h"
   4 #include "libslang.h"
   5 #include <newt.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
  18 static int ui_browser__percent_color(struct ui_browser *browser,
  19                                      double percent, bool current)
  20 {
  21         if (current && (!browser->use_navkeypressed || browser->navkeypressed))
  22                 return HE_COLORSET_SELECTED;
  23         if (percent >= MIN_RED)
  24                 return HE_COLORSET_TOP;
  25         if (percent >= MIN_GREEN)
  26                 return HE_COLORSET_MEDIUM;
  27         return HE_COLORSET_NORMAL;
  28 }
  29
  30 void ui_browser__set_color(struct ui_browser *self __used, int color)
  31 {
  32         SLsmg_set_color(color);
  33 }
  34
  35 void ui_browser__set_percent_color(struct ui_browser *self,
  36                                    double percent, bool current)
  37 {
  38          int color = ui_browser__percent_color(self, percent, current);
  39          ui_browser__set_color(self, color);
  40 }
  41
  42 void ui_browser__gotorc(struct ui_browser *self, int y, int x)
  43 {
  44         SLsmg_gotorc(self->y + y, self->x + x);
  45 }
  46
  47 static struct list_head *
  48 ui_browser__list_head_filter_entries(struct ui_browser *browser,
  49                                      struct list_head *pos)
  50 {
  51         do {
  52                 if (!browser->filter || !browser->filter(browser, pos))
  53                         return pos;
  54                 pos = pos->next;
  55         } while (pos != browser->entries);
  56
  57         return NULL;
  58 }
  59
  60 static struct list_head *
  61 ui_browser__list_head_filter_prev_entries(struct ui_browser *browser,
  62                                           struct list_head *pos)
  63 {
  64         do {
  65                 if (!browser->filter || !browser->filter(browser, pos))
  66                         return pos;
  67                 pos = pos->prev;
  68         } while (pos != browser->entries);
  69
  70         return NULL;
  71 }
  72
  73 void ui_browser__list_head_seek(struct ui_browser *self, off_t offset, int whence)
  74 {
  75         struct list_head *head = self->entries;
  76         struct list_head *pos;
  77
  78         if (self->nr_entries == 0)
  79                 return;
  80
  81         switch (whence) {
  82         case SEEK_SET:
  83                 pos = ui_browser__list_head_filter_entries(self, head->next);
  84                 break;
  85         case SEEK_CUR:
  86                 pos = self->top;
  87                 break;
  88         case SEEK_END:
  89                 pos = ui_browser__list_head_filter_prev_entries(self, head->prev);
  90                 break;
  91         default:
  92                 return;
  93         }
  94
  95         assert(pos != NULL);
  96
  97         if (offset > 0) {
  98                 while (offset-- != 0)
  99                         pos = ui_browser__list_head_filter_entries(self, pos->next);
 100         } else {
 101                 while (offset++ != 0)
 102                         pos = ui_browser__list_head_filter_prev_entries(self, pos->prev);
 103         }
 104
 105         self->top = pos;
 106 }
 107
 108 void ui_browser__rb_tree_seek(struct ui_browser *self, off_t offset, int whence)
 109 {
 110         struct rb_root *root = self->entries;
 111         struct rb_node *nd;
 112
 113         switch (whence) {
 114         case SEEK_SET:
 115                 nd = rb_first(root);
 116                 break;
 117         case SEEK_CUR:
 118                 nd = self->top;
 119                 break;
 120         case SEEK_END:
 121                 nd = rb_last(root);
 122                 break;
 123         default:
 124                 return;
 125         }
 126
 127         if (offset > 0) {
 128                 while (offset-- != 0)
 129                         nd = rb_next(nd);
 130         } else {
 131                 while (offset++ != 0)
 132                         nd = rb_prev(nd);
 133         }
 134
 135         self->top = nd;
 136 }
 137
 138 unsigned int ui_browser__rb_tree_refresh(struct ui_browser *self)
 139 {
 140         struct rb_node *nd;
 141         int row = 0;
 142
 143         if (self->top == NULL)
 144                 self->top = rb_first(self->entries);
 145
 146         nd = self->top;
 147
 148         while (nd != NULL) {
 149                 ui_browser__gotorc(self, row, 0);
 150                 self->write(self, nd, row);
 151                 if (++row == self->height)
 152                         break;
 153                 nd = rb_next(nd);
 154         }
 155
 156         return row;
 157 }
 158
 159 bool ui_browser__is_current_entry(struct ui_browser *self, unsigned row)
 160 {
 161         return self->top_idx + row == self->index;
 162 }
 163
 164 void ui_browser__refresh_dimensions(struct ui_browser *self)
 165 {
 166         self->width = SLtt_Screen_Cols - 1;
 167         self->height = SLtt_Screen_Rows - 2;
 168         self->y = 1;
 169         self->x = 0;
 170 }
 171
 172 void ui_browser__reset_index(struct ui_browser *self)
 173 {
 174         self->index = self->top_idx = 0;
 175         self->seek(self, 0, SEEK_SET);
 176 }
 177
 178 void __ui_browser__show_title(struct ui_browser *browser, const char *title)
 179 {
 180         SLsmg_gotorc(0, 0);
 181         ui_browser__set_color(browser, NEWT_COLORSET_ROOT);
 182         slsmg_write_nstring(title, browser->width + 1);
 183 }
 184
 185 void ui_browser__show_title(struct ui_browser *browser, const char *title)
 186 {
 187         pthread_mutex_lock(&ui__lock);
 188         __ui_browser__show_title(browser, title);
 189         pthread_mutex_unlock(&ui__lock);
 190 }
 191
 192 int ui_browser__show(struct ui_browser *self, const char *title,
 193                      const char *helpline, ...)
 194 {
 195         int err;
 196         va_list ap;
 197
 198         ui_browser__refresh_dimensions(self);
 199
 200         pthread_mutex_lock(&ui__lock);
 201         __ui_browser__show_title(self, title);
 202
 203         self->title = title;
 204         free(self->helpline);
 205         self->helpline = NULL;
 206
 207         va_start(ap, helpline);
 208         err = vasprintf(&self->helpline, helpline, ap);
 209         va_end(ap);
 210         if (err > 0)
 211                 ui_helpline__push(self->helpline);
 212         pthread_mutex_unlock(&ui__lock);
 213         return err ? 0 : -1;
 214 }
 215
 216 void ui_browser__hide(struct ui_browser *browser __used)
 217 {
 218         pthread_mutex_lock(&ui__lock);
 219         ui_helpline__pop();
 220         pthread_mutex_unlock(&ui__lock);
 221 }
 222
 223 static void ui_browser__scrollbar_set(struct ui_browser *browser)
 224 {
 225         int height = browser->height, h = 0, pct = 0,
 226             col = browser->width,
 227             row = browser->y - 1;
 228
 229         if (browser->nr_entries > 1) {
 230                 pct = ((browser->index * (browser->height - 1)) /
 231                        (browser->nr_entries - 1));
 232         }
 233
 234         while (h < height) {
 235                 ui_browser__gotorc(browser, row++, col);
 236                 SLsmg_set_char_set(1);
 237                 SLsmg_write_char(h == pct ? SLSMG_DIAMOND_CHAR : SLSMG_BOARD_CHAR);
 238                 SLsmg_set_char_set(0);
 239                 ++h;
 240         }
 241 }
 242
 243 static int __ui_browser__refresh(struct ui_browser *browser)
 244 {
 245         int row;
 246         int width = browser->width;
 247
 248         row = browser->refresh(browser);
 249         ui_browser__set_color(browser, HE_COLORSET_NORMAL);
 250
 251         if (!browser->use_navkeypressed || browser->navkeypressed)
 252                 ui_browser__scrollbar_set(browser);
 253         else
 254                 width += 1;
 255
 256         SLsmg_fill_region(browser->y + row, browser->x,
 257                           browser->height - row, width, ' ');
 258
 259         return 0;
 260 }
 261
 262 int ui_browser__refresh(struct ui_browser *browser)
 263 {
 264         pthread_mutex_lock(&ui__lock);
 265         __ui_browser__refresh(browser);
 266         pthread_mutex_unlock(&ui__lock);
 267
 268         return 0;
 269 }
 270
 271 /*
 272  * Here we're updating nr_entries _after_ we started browsing, i.e.  we have to
 273  * forget about any reference to any entry in the underlying data structure,
 274  * that is why we do a SEEK_SET. Think about 'perf top' in the hists browser
 275  * after an output_resort and hist decay.
 276  */
 277 void ui_browser__update_nr_entries(struct ui_browser *browser, u32 nr_entries)
 278 {
 279         off_t offset = nr_entries - browser->nr_entries;
 280
 281         browser->nr_entries = nr_entries;
 282
 283         if (offset < 0) {
 284                 if (browser->top_idx < (u64)-offset)
 285                         offset = -browser->top_idx;
 286
 287                 browser->index += offset;
 288                 browser->top_idx += offset;
 289         }
 290
 291         browser->top = NULL;
 292         browser->seek(browser, browser->top_idx, SEEK_SET);
 293 }
 294
 295 int ui_browser__run(struct ui_browser *self, int delay_secs)
 296 {
 297         int err, key;
 298
 299         while (1) {
 300                 off_t offset;
 301
 302                 pthread_mutex_lock(&ui__lock);
 303                 err = __ui_browser__refresh(self);
 304                 SLsmg_refresh();
 305                 pthread_mutex_unlock(&ui__lock);
 306                 if (err < 0)
 307                         break;
 308
 309                 key = ui__getch(delay_secs);
 310
 311                 if (key == K_RESIZE) {
 312                         ui__refresh_dimensions(false);
 313                         ui_browser__refresh_dimensions(self);
 314                         __ui_browser__show_title(self, self->title);
 315                         ui_helpline__puts(self->helpline);
 316                         continue;
 317                 }
 318
 319                 if (self->use_navkeypressed && !self->navkeypressed) {
 320                         if (key == K_DOWN || key == K_UP ||
 321                             key == K_PGDN || key == K_PGUP ||
 322                             key == K_HOME || key == K_END ||
 323                             key == ' ') {
 324                                 self->navkeypressed = true;
 325                                 continue;
 326                         } else
 327                                 return key;
 328                 }
 329
 330                 switch (key) {
 331                 case K_DOWN:
 332                         if (self->index == self->nr_entries - 1)
 333                                 break;
 334                         ++self->index;
 335                         if (self->index == self->top_idx + self->height) {
 336                                 ++self->top_idx;
 337                                 self->seek(self, +1, SEEK_CUR);
 338                         }
 339                         break;
 340                 case K_UP:
 341                         if (self->index == 0)
 342                                 break;
 343                         --self->index;
 344                         if (self->index < self->top_idx) {
 345                                 --self->top_idx;
 346                                 self->seek(self, -1, SEEK_CUR);
 347                         }
 348                         break;
 349                 case K_PGDN:
 350                 case ' ':
 351                         if (self->top_idx + self->height > self->nr_entries - 1)
 352                                 break;
 353
 354                         offset = self->height;
 355                         if (self->index + offset > self->nr_entries - 1)
 356                                 offset = self->nr_entries - 1 - self->index;
 357                         self->index += offset;
 358                         self->top_idx += offset;
 359                         self->seek(self, +offset, SEEK_CUR);
 360                         break;
 361                 case K_PGUP:
 362                         if (self->top_idx == 0)
 363                                 break;
 364
 365                         if (self->top_idx < self->height)
 366                                 offset = self->top_idx;
 367                         else
 368                                 offset = self->height;
 369
 370                         self->index -= offset;
 371                         self->top_idx -= offset;
 372                         self->seek(self, -offset, SEEK_CUR);
 373                         break;
 374                 case K_HOME:
 375                         ui_browser__reset_index(self);
 376                         break;
 377                 case K_END:
 378                         offset = self->height - 1;
 379                         if (offset >= self->nr_entries)
 380                                 offset = self->nr_entries - 1;
 381
 382                         self->index = self->nr_entries - 1;
 383                         self->top_idx = self->index - offset;
 384                         self->seek(self, -offset, SEEK_END);
 385                         break;
 386                 default:
 387                         return key;
 388                 }
 389         }
 390         return -1;
 391 }
 392
 393 unsigned int ui_browser__list_head_refresh(struct ui_browser *self)
 394 {
 395         struct list_head *pos;
 396         struct list_head *head = self->entries;
 397         int row = 0;
 398
 399         if (self->top == NULL || self->top == self->entries)
 400                 self->top = ui_browser__list_head_filter_entries(self, head->next);
 401
 402         pos = self->top;
 403
 404         list_for_each_from(pos, head) {
 405                 if (!self->filter || !self->filter(self, pos)) {
 406                         ui_browser__gotorc(self, row, 0);
 407                         self->write(self, pos, row);
 408                         if (++row == self->height)
 409                                 break;
 410                 }
 411         }
 412
 413         return row;
 414 }
 415
 416 static struct ui_browser__colorset {
 417         const char *name, *fg, *bg;
 418         int colorset;
 419 } ui_browser__colorsets[] = {
 420         {
 421                 .colorset = HE_COLORSET_TOP,
 422                 .name     = "top",
 423                 .fg       = "red",
 424                 .bg       = "default",
 425         },
 426         {
 427                 .colorset = HE_COLORSET_MEDIUM,
 428                 .name     = "medium",
 429                 .fg       = "green",
 430                 .bg       = "default",
 431         },
 432         {
 433                 .colorset = HE_COLORSET_NORMAL,
 434                 .name     = "normal",
 435                 .fg       = "default",
 436                 .bg       = "default",
 437         },
 438         {
 439                 .colorset = HE_COLORSET_SELECTED,
 440                 .name     = "selected",
 441                 .fg       = "black",
 442                 .bg       = "lightgray",
 443         },
 444         {
 445                 .colorset = HE_COLORSET_CODE,
 446                 .name     = "code",
 447                 .fg       = "blue",
 448                 .bg       = "default",
 449         },
 450         {
 451                 .name = NULL,
 452         }
 453 };
 454
 455
 456 static int ui_browser__color_config(const char *var, const char *value,
 457                                     void *data __used)
 458 {
 459         char *fg = NULL, *bg;
 460         int i;
 461
 462         /* same dir for all commands */
 463         if (prefixcmp(var, "colors.") != 0)
 464                 return 0;
 465
 466         for (i = 0; ui_browser__colorsets[i].name != NULL; ++i) {
 467                 const char *name = var + 7;
 468
 469                 if (strcmp(ui_browser__colorsets[i].name, name) != 0)
 470                         continue;
 471
 472                 fg = strdup(value);
 473                 if (fg == NULL)
 474                         break;
 475
 476                 bg = strchr(fg, ',');
 477                 if (bg == NULL)
 478                         break;
 479
 480                 *bg = '\0';
 481                 while (isspace(*++bg));
 482                 ui_browser__colorsets[i].bg = bg;
 483                 ui_browser__colorsets[i].fg = fg;
 484                 return 0;
 485         }
 486
 487         free(fg);
 488         return -1;
 489 }
 490
 491 void ui_browser__init(void)
 492 {
 493         int i = 0;
 494
 495         perf_config(ui_browser__color_config, NULL);
 496
 497         while (ui_browser__colorsets[i].name) {
 498                 struct ui_browser__colorset *c = &ui_browser__colorsets[i++];
 499                 sltt_set_color(c->colorset, c->name, c->fg, c->bg);
 500         }
 501 }