tools/perf/util/ui/browser.c

   1 #include <slang.h>
   2 #include "libslang.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 newtComponent newt_form__new(void);
  15
  16 static int ui_browser__percent_color(double percent, bool current)
  17 {
  18         if (current)
  19                 return HE_COLORSET_SELECTED;
  20         if (percent >= MIN_RED)
  21                 return HE_COLORSET_TOP;
  22         if (percent >= MIN_GREEN)
  23                 return HE_COLORSET_MEDIUM;
  24         return HE_COLORSET_NORMAL;
  25 }
  26
  27 void ui_browser__set_color(struct ui_browser *self __used, int color)
  28 {
  29         SLsmg_set_color(color);
  30 }
  31
  32 void ui_browser__set_percent_color(struct ui_browser *self,
  33                                    double percent, bool current)
  34 {
  35          int color = ui_browser__percent_color(percent, current);
  36          ui_browser__set_color(self, color);
  37 }
  38
  39 void ui_browser__gotorc(struct ui_browser *self, int y, int x)
  40 {
  41         SLsmg_gotorc(self->y + y, self->x + x);
  42 }
  43
  44 void ui_browser__list_head_seek(struct ui_browser *self, off_t offset, int whence)
  45 {
  46         struct list_head *head = self->entries;
  47         struct list_head *pos;
  48
  49         switch (whence) {
  50         case SEEK_SET:
  51                 pos = head->next;
  52                 break;
  53         case SEEK_CUR:
  54                 pos = self->top;
  55                 break;
  56         case SEEK_END:
  57                 pos = head->prev;
  58                 break;
  59         default:
  60                 return;
  61         }
  62
  63         if (offset > 0) {
  64                 while (offset-- != 0)
  65                         pos = pos->next;
  66         } else {
  67                 while (offset++ != 0)
  68                         pos = pos->prev;
  69         }
  70
  71         self->top = pos;
  72 }
  73
  74 void ui_browser__rb_tree_seek(struct ui_browser *self, off_t offset, int whence)
  75 {
  76         struct rb_root *root = self->entries;
  77         struct rb_node *nd;
  78
  79         switch (whence) {
  80         case SEEK_SET:
  81                 nd = rb_first(root);
  82                 break;
  83         case SEEK_CUR:
  84                 nd = self->top;
  85                 break;
  86         case SEEK_END:
  87                 nd = rb_last(root);
  88                 break;
  89         default:
  90                 return;
  91         }
  92
  93         if (offset > 0) {
  94                 while (offset-- != 0)
  95                         nd = rb_next(nd);
  96         } else {
  97                 while (offset++ != 0)
  98                         nd = rb_prev(nd);
  99         }
 100
 101         self->top = nd;
 102 }
 103
 104 unsigned int ui_browser__rb_tree_refresh(struct ui_browser *self)
 105 {
 106         struct rb_node *nd;
 107         int row = 0;
 108
 109         if (self->top == NULL)
 110                 self->top = rb_first(self->entries);
 111
 112         nd = self->top;
 113
 114         while (nd != NULL) {
 115                 ui_browser__gotorc(self, row, 0);
 116                 self->write(self, nd, row);
 117                 if (++row == self->height)
 118                         break;
 119                 nd = rb_next(nd);
 120         }
 121
 122         return row;
 123 }
 124
 125 bool ui_browser__is_current_entry(struct ui_browser *self, unsigned row)
 126 {
 127         return self->top_idx + row == self->index;
 128 }
 129
 130 void ui_browser__refresh_dimensions(struct ui_browser *self)
 131 {
 132         int cols, rows;
 133         newtGetScreenSize(&cols, &rows);
 134
 135         if (self->width > cols - 4)
 136                 self->width = cols - 4;
 137         self->height = rows - 5;
 138         if (self->height > self->nr_entries)
 139                 self->height = self->nr_entries;
 140         self->y  = (rows - self->height) / 2;
 141         self->x = (cols - self->width) / 2;
 142 }
 143
 144 void ui_browser__reset_index(struct ui_browser *self)
 145 {
 146         self->index = self->top_idx = 0;
 147         self->seek(self, 0, SEEK_SET);
 148 }
 149
 150 int ui_browser__show(struct ui_browser *self, const char *title,
 151                      const char *helpline, ...)
 152 {
 153         va_list ap;
 154
 155         if (self->form != NULL) {
 156                 newtFormDestroy(self->form);
 157                 newtPopWindow();
 158         }
 159         ui_browser__refresh_dimensions(self);
 160         newtCenteredWindow(self->width, self->height, title);
 161         self->form = newt_form__new();
 162         if (self->form == NULL)
 163                 return -1;
 164
 165         self->sb = newtVerticalScrollbar(self->width, 0, self->height,
 166                                          HE_COLORSET_NORMAL,
 167                                          HE_COLORSET_SELECTED);
 168         if (self->sb == NULL)
 169                 return -1;
 170
 171         newtFormAddHotKey(self->form, NEWT_KEY_UP);
 172         newtFormAddHotKey(self->form, NEWT_KEY_DOWN);
 173         newtFormAddHotKey(self->form, NEWT_KEY_PGUP);
 174         newtFormAddHotKey(self->form, NEWT_KEY_PGDN);
 175         newtFormAddHotKey(self->form, NEWT_KEY_HOME);
 176         newtFormAddHotKey(self->form, NEWT_KEY_END);
 177         newtFormAddHotKey(self->form, ' ');
 178         newtFormAddComponent(self->form, self->sb);
 179
 180         va_start(ap, helpline);
 181         ui_helpline__vpush(helpline, ap);
 182         va_end(ap);
 183         return 0;
 184 }
 185
 186 void ui_browser__hide(struct ui_browser *self)
 187 {
 188         newtFormDestroy(self->form);
 189         newtPopWindow();
 190         self->form = NULL;
 191         ui_helpline__pop();
 192 }
 193
 194 int ui_browser__refresh(struct ui_browser *self)
 195 {
 196         int row;
 197
 198         newtScrollbarSet(self->sb, self->index, self->nr_entries - 1);
 199         row = self->refresh(self);
 200         ui_browser__set_color(self, HE_COLORSET_NORMAL);
 201         SLsmg_fill_region(self->y + row, self->x,
 202                           self->height - row, self->width, ' ');
 203
 204         return 0;
 205 }
 206
 207 int ui_browser__run(struct ui_browser *self)
 208 {
 209         struct newtExitStruct es;
 210
 211         if (ui_browser__refresh(self) < 0)
 212                 return -1;
 213
 214         while (1) {
 215                 off_t offset;
 216
 217                 newtFormRun(self->form, &es);
 218
 219                 if (es.reason != NEWT_EXIT_HOTKEY)
 220                         break;
 221                 switch (es.u.key) {
 222                 case NEWT_KEY_DOWN:
 223                         if (self->index == self->nr_entries - 1)
 224                                 break;
 225                         ++self->index;
 226                         if (self->index == self->top_idx + self->height) {
 227                                 ++self->top_idx;
 228                                 self->seek(self, +1, SEEK_CUR);
 229                         }
 230                         break;
 231                 case NEWT_KEY_UP:
 232                         if (self->index == 0)
 233                                 break;
 234                         --self->index;
 235                         if (self->index < self->top_idx) {
 236                                 --self->top_idx;
 237                                 self->seek(self, -1, SEEK_CUR);
 238                         }
 239                         break;
 240                 case NEWT_KEY_PGDN:
 241                 case ' ':
 242                         if (self->top_idx + self->height > self->nr_entries - 1)
 243                                 break;
 244
 245                         offset = self->height;
 246                         if (self->index + offset > self->nr_entries - 1)
 247                                 offset = self->nr_entries - 1 - self->index;
 248                         self->index += offset;
 249                         self->top_idx += offset;
 250                         self->seek(self, +offset, SEEK_CUR);
 251                         break;
 252                 case NEWT_KEY_PGUP:
 253                         if (self->top_idx == 0)
 254                                 break;
 255
 256                         if (self->top_idx < self->height)
 257                                 offset = self->top_idx;
 258                         else
 259                                 offset = self->height;
 260
 261                         self->index -= offset;
 262                         self->top_idx -= offset;
 263                         self->seek(self, -offset, SEEK_CUR);
 264                         break;
 265                 case NEWT_KEY_HOME:
 266                         ui_browser__reset_index(self);
 267                         break;
 268                 case NEWT_KEY_END:
 269                         offset = self->height - 1;
 270                         if (offset >= self->nr_entries)
 271                                 offset = self->nr_entries - 1;
 272
 273                         self->index = self->nr_entries - 1;
 274                         self->top_idx = self->index - offset;
 275                         self->seek(self, -offset, SEEK_END);
 276                         break;
 277                 default:
 278                         return es.u.key;
 279                 }
 280                 if (ui_browser__refresh(self) < 0)
 281                         return -1;
 282         }
 283         return -1;
 284 }
 285
 286 unsigned int ui_browser__list_head_refresh(struct ui_browser *self)
 287 {
 288         struct list_head *pos;
 289         struct list_head *head = self->entries;
 290         int row = 0;
 291
 292         if (self->top == NULL || self->top == self->entries)
 293                 self->top = head->next;
 294
 295         pos = self->top;
 296
 297         list_for_each_from(pos, head) {
 298                 ui_browser__gotorc(self, row, 0);
 299                 self->write(self, pos, row);
 300                 if (++row == self->height)
 301                         break;
 302         }
 303
 304         return row;
 305 }
 306
 307 static struct newtPercentTreeColors {
 308         const char *topColorFg, *topColorBg;
 309         const char *mediumColorFg, *mediumColorBg;
 310         const char *normalColorFg, *normalColorBg;
 311         const char *selColorFg, *selColorBg;
 312         const char *codeColorFg, *codeColorBg;
 313 } defaultPercentTreeColors = {
 314         "red",       "lightgray",
 315         "green",     "lightgray",
 316         "black",     "lightgray",
 317         "lightgray", "magenta",
 318         "blue",      "lightgray",
 319 };
 320
 321 void ui_browser__init(void)
 322 {
 323         struct newtPercentTreeColors *c = &defaultPercentTreeColors;
 324
 325         sltt_set_color(HE_COLORSET_TOP, NULL, c->topColorFg, c->topColorBg);
 326         sltt_set_color(HE_COLORSET_MEDIUM, NULL, c->mediumColorFg, c->mediumColorBg);
 327         sltt_set_color(HE_COLORSET_NORMAL, NULL, c->normalColorFg, c->normalColorBg);
 328         sltt_set_color(HE_COLORSET_SELECTED, NULL, c->selColorFg, c->selColorBg);
 329         sltt_set_color(HE_COLORSET_CODE, NULL, c->codeColorFg, c->codeColorBg);
 330 }