tools/perf/util/ui/browser.c

   1 #include "libslang.h"
   2 #include "ui.h"
   3 #include <linux/compiler.h>
   4 #include <linux/list.h>
   5 #include <linux/rbtree.h>
   6 #include <stdlib.h>
   7 #include <sys/ttydefaults.h>
   8 #include "browser.h"
   9 #include "helpline.h"
  10 #include "../color.h"
  11 #include "../util.h"
  12 #include <stdio.h>
  13
  14 static int ui_browser__percent_color(double percent, bool current)
  15 {
  16         if (current)
  17                 return HE_COLORSET_SELECTED;
  18         if (percent >= MIN_RED)
  19                 return HE_COLORSET_TOP;
  20         if (percent >= MIN_GREEN)
  21                 return HE_COLORSET_MEDIUM;
  22         return HE_COLORSET_NORMAL;
  23 }
  24
  25 void ui_browser__set_color(struct ui_browser *self __used, int color)
  26 {
  27         SLsmg_set_color(color);
  28 }
  29
  30 void ui_browser__set_percent_color(struct ui_browser *self,
  31                                    double percent, bool current)
  32 {
  33          int color = ui_browser__percent_color(percent, current);
  34          ui_browser__set_color(self, color);
  35 }
  36
  37 void ui_browser__gotorc(struct ui_browser *self, int y, int x)
  38 {
  39         SLsmg_gotorc(self->y + y, self->x + x);
  40 }
  41
  42 void ui_browser__list_head_seek(struct ui_browser *self, off_t offset, int whence)
  43 {
  44         struct list_head *head = self->entries;
  45         struct list_head *pos;
  46
  47         switch (whence) {
  48         case SEEK_SET:
  49                 pos = head->next;
  50                 break;
  51         case SEEK_CUR:
  52                 pos = self->top;
  53                 break;
  54         case SEEK_END:
  55                 pos = head->prev;
  56                 break;
  57         default:
  58                 return;
  59         }
  60
  61         if (offset > 0) {
  62                 while (offset-- != 0)
  63                         pos = pos->next;
  64         } else {
  65                 while (offset++ != 0)
  66                         pos = pos->prev;
  67         }
  68
  69         self->top = pos;
  70 }
  71
  72 void ui_browser__rb_tree_seek(struct ui_browser *self, off_t offset, int whence)
  73 {
  74         struct rb_root *root = self->entries;
  75         struct rb_node *nd;
  76
  77         switch (whence) {
  78         case SEEK_SET:
  79                 nd = rb_first(root);
  80                 break;
  81         case SEEK_CUR:
  82                 nd = self->top;
  83                 break;
  84         case SEEK_END:
  85                 nd = rb_last(root);
  86                 break;
  87         default:
  88                 return;
  89         }
  90
  91         if (offset > 0) {
  92                 while (offset-- != 0)
  93                         nd = rb_next(nd);
  94         } else {
  95                 while (offset++ != 0)
  96                         nd = rb_prev(nd);
  97         }
  98
  99         self->top = nd;
 100 }
 101
 102 unsigned int ui_browser__rb_tree_refresh(struct ui_browser *self)
 103 {
 104         struct rb_node *nd;
 105         int row = 0;
 106
 107         if (self->top == NULL)
 108                 self->top = rb_first(self->entries);
 109
 110         nd = self->top;
 111
 112         while (nd != NULL) {
 113                 ui_browser__gotorc(self, row, 0);
 114                 self->write(self, nd, row);
 115                 if (++row == self->height)
 116                         break;
 117                 nd = rb_next(nd);
 118         }
 119
 120         return row;
 121 }
 122
 123 bool ui_browser__is_current_entry(struct ui_browser *self, unsigned row)
 124 {
 125         return self->top_idx + row == self->index;
 126 }
 127
 128 void ui_browser__refresh_dimensions(struct ui_browser *self)
 129 {
 130         int cols, rows;
 131         newtGetScreenSize(&cols, &rows);
 132
 133         self->width = cols - 1;
 134         self->height = rows - 2;
 135         self->y = 1;
 136         self->x = 0;
 137 }
 138
 139 void ui_browser__reset_index(struct ui_browser *self)
 140 {
 141         self->index = self->top_idx = 0;
 142         self->seek(self, 0, SEEK_SET);
 143 }
 144
 145 void ui_browser__add_exit_key(struct ui_browser *self, int key)
 146 {
 147         newtFormAddHotKey(self->form, key);
 148 }
 149
 150 void ui_browser__add_exit_keys(struct ui_browser *self, int keys[])
 151 {
 152         int i = 0;
 153
 154         while (keys[i] && i < 64) {
 155                 ui_browser__add_exit_key(self, keys[i]);
 156                 ++i;
 157         }
 158 }
 159
 160 void __ui_browser__show_title(struct ui_browser *browser, const char *title)
 161 {
 162         SLsmg_gotorc(0, 0);
 163         ui_browser__set_color(browser, NEWT_COLORSET_ROOT);
 164         slsmg_write_nstring(title, browser->width);
 165 }
 166
 167 void ui_browser__show_title(struct ui_browser *browser, const char *title)
 168 {
 169         pthread_mutex_lock(&ui__lock);
 170         __ui_browser__show_title(browser, title);
 171         pthread_mutex_unlock(&ui__lock);
 172 }
 173
 174 int ui_browser__show(struct ui_browser *self, const char *title,
 175                      const char *helpline, ...)
 176 {
 177         va_list ap;
 178         int keys[] = { NEWT_KEY_UP, NEWT_KEY_DOWN, NEWT_KEY_PGUP,
 179                        NEWT_KEY_PGDN, NEWT_KEY_HOME, NEWT_KEY_END, ' ',
 180                        NEWT_KEY_LEFT, NEWT_KEY_ESCAPE, 'q', CTRL('c'), 0 };
 181
 182         if (self->form != NULL)
 183                 newtFormDestroy(self->form);
 184
 185         ui_browser__refresh_dimensions(self);
 186         self->form = newtForm(NULL, NULL, 0);
 187         if (self->form == NULL)
 188                 return -1;
 189
 190         self->sb = newtVerticalScrollbar(self->width, 1, self->height,
 191                                          HE_COLORSET_NORMAL,
 192                                          HE_COLORSET_SELECTED);
 193         if (self->sb == NULL)
 194                 return -1;
 195
 196         pthread_mutex_lock(&ui__lock);
 197         __ui_browser__show_title(self, title);
 198
 199         ui_browser__add_exit_keys(self, keys);
 200         newtFormAddComponent(self->form, self->sb);
 201
 202         va_start(ap, helpline);
 203         ui_helpline__vpush(helpline, ap);
 204         va_end(ap);
 205         pthread_mutex_unlock(&ui__lock);
 206         return 0;
 207 }
 208
 209 void ui_browser__hide(struct ui_browser *self)
 210 {
 211         pthread_mutex_lock(&ui__lock);
 212         newtFormDestroy(self->form);
 213         self->form = NULL;
 214         ui_helpline__pop();
 215         pthread_mutex_unlock(&ui__lock);
 216 }
 217
 218 int ui_browser__refresh(struct ui_browser *self)
 219 {
 220         int row;
 221
 222         pthread_mutex_lock(&ui__lock);
 223         newtScrollbarSet(self->sb, self->index, self->nr_entries - 1);
 224         row = self->refresh(self);
 225         ui_browser__set_color(self, HE_COLORSET_NORMAL);
 226         SLsmg_fill_region(self->y + row, self->x,
 227                           self->height - row, self->width, ' ');
 228         pthread_mutex_unlock(&ui__lock);
 229
 230         return 0;
 231 }
 232
 233 /*
 234  * Here we're updating nr_entries _after_ we started browsing, i.e.  we have to
 235  * forget about any reference to any entry in the underlying data structure,
 236  * that is why we do a SEEK_SET. Think about 'perf top' in the hists browser
 237  * after an output_resort and hist decay.
 238  */
 239 void ui_browser__update_nr_entries(struct ui_browser *browser, u32 nr_entries)
 240 {
 241         off_t offset = nr_entries - browser->nr_entries;
 242
 243         browser->nr_entries = nr_entries;
 244
 245         if (offset < 0) {
 246                 if (browser->top_idx < (u64)-offset)
 247                         offset = -browser->top_idx;
 248
 249                 browser->index += offset;
 250                 browser->top_idx += offset;
 251         }
 252
 253         browser->seek(browser, browser->top_idx, SEEK_SET);
 254 }
 255
 256 int ui_browser__run(struct ui_browser *self)
 257 {
 258         struct newtExitStruct es;
 259
 260         if (ui_browser__refresh(self) < 0)
 261                 return -1;
 262
 263         while (1) {
 264                 off_t offset;
 265
 266                 newtFormRun(self->form, &es);
 267
 268                 if (es.reason != NEWT_EXIT_HOTKEY)
 269                         break;
 270                 switch (es.u.key) {
 271                 case NEWT_KEY_DOWN:
 272                         if (self->index == self->nr_entries - 1)
 273                                 break;
 274                         ++self->index;
 275                         if (self->index == self->top_idx + self->height) {
 276                                 ++self->top_idx;
 277                                 self->seek(self, +1, SEEK_CUR);
 278                         }
 279                         break;
 280                 case NEWT_KEY_UP:
 281                         if (self->index == 0)
 282                                 break;
 283                         --self->index;
 284                         if (self->index < self->top_idx) {
 285                                 --self->top_idx;
 286                                 self->seek(self, -1, SEEK_CUR);
 287                         }
 288                         break;
 289                 case NEWT_KEY_PGDN:
 290                 case ' ':
 291                         if (self->top_idx + self->height > self->nr_entries - 1)
 292                                 break;
 293
 294                         offset = self->height;
 295                         if (self->index + offset > self->nr_entries - 1)
 296                                 offset = self->nr_entries - 1 - self->index;
 297                         self->index += offset;
 298                         self->top_idx += offset;
 299                         self->seek(self, +offset, SEEK_CUR);
 300                         break;
 301                 case NEWT_KEY_PGUP:
 302                         if (self->top_idx == 0)
 303                                 break;
 304
 305                         if (self->top_idx < self->height)
 306                                 offset = self->top_idx;
 307                         else
 308                                 offset = self->height;
 309
 310                         self->index -= offset;
 311                         self->top_idx -= offset;
 312                         self->seek(self, -offset, SEEK_CUR);
 313                         break;
 314                 case NEWT_KEY_HOME:
 315                         ui_browser__reset_index(self);
 316                         break;
 317                 case NEWT_KEY_END:
 318                         offset = self->height - 1;
 319                         if (offset >= self->nr_entries)
 320                                 offset = self->nr_entries - 1;
 321
 322                         self->index = self->nr_entries - 1;
 323                         self->top_idx = self->index - offset;
 324                         self->seek(self, -offset, SEEK_END);
 325                         break;
 326                 default:
 327                         return es.u.key;
 328                 }
 329                 if (ui_browser__refresh(self) < 0)
 330                         return -1;
 331         }
 332         return -1;
 333 }
 334
 335 unsigned int ui_browser__list_head_refresh(struct ui_browser *self)
 336 {
 337         struct list_head *pos;
 338         struct list_head *head = self->entries;
 339         int row = 0;
 340
 341         if (self->top == NULL || self->top == self->entries)
 342                 self->top = head->next;
 343
 344         pos = self->top;
 345
 346         list_for_each_from(pos, head) {
 347                 ui_browser__gotorc(self, row, 0);
 348                 self->write(self, pos, row);
 349                 if (++row == self->height)
 350                         break;
 351         }
 352
 353         return row;
 354 }
 355
 356 static struct newtPercentTreeColors {
 357         const char *topColorFg, *topColorBg;
 358         const char *mediumColorFg, *mediumColorBg;
 359         const char *normalColorFg, *normalColorBg;
 360         const char *selColorFg, *selColorBg;
 361         const char *codeColorFg, *codeColorBg;
 362 } defaultPercentTreeColors = {
 363         "red",       "lightgray",
 364         "green",     "lightgray",
 365         "black",     "lightgray",
 366         "lightgray", "magenta",
 367         "blue",      "lightgray",
 368 };
 369
 370 void ui_browser__init(void)
 371 {
 372         struct newtPercentTreeColors *c = &defaultPercentTreeColors;
 373
 374         sltt_set_color(HE_COLORSET_TOP, NULL, c->topColorFg, c->topColorBg);
 375         sltt_set_color(HE_COLORSET_MEDIUM, NULL, c->mediumColorFg, c->mediumColorBg);
 376         sltt_set_color(HE_COLORSET_NORMAL, NULL, c->normalColorFg, c->normalColorBg);
 377         sltt_set_color(HE_COLORSET_SELECTED, NULL, c->selColorFg, c->selColorBg);
 378         sltt_set_color(HE_COLORSET_CODE, NULL, c->codeColorFg, c->codeColorBg);
 379 }