Commit | Line | Data |
---|---|---|
3af6e338 | 1 | #include "../util.h" |
e039fc72 | 2 | #include "../cache.h" |
3af6e338 | 3 | #include "../../perf.h" |
8f9bbc40 | 4 | #include "libslang.h" |
3af6e338 | 5 | #include <newt.h> |
5c35d69f | 6 | #include "ui.h" |
71172ed9 | 7 | #include "util.h" |
8f9bbc40 | 8 | #include <linux/compiler.h> |
ef8f34aa ACM |
9 | #include <linux/list.h> |
10 | #include <linux/rbtree.h> | |
11 | #include <stdlib.h> | |
12 | #include <sys/ttydefaults.h> | |
13 | #include "browser.h" | |
59e8fe32 | 14 | #include "helpline.h" |
cf958003 | 15 | #include "keysyms.h" |
ef8f34aa | 16 | #include "../color.h" |
3af6e338 | 17 | |
c172f742 ACM |
18 | static int ui_browser__percent_color(struct ui_browser *browser, |
19 | double percent, bool current) | |
ef8f34aa | 20 | { |
c172f742 | 21 | if (current && (!browser->use_navkeypressed || browser->navkeypressed)) |
ef8f34aa ACM |
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 | ||
08709165 | 30 | int ui_browser__set_color(struct ui_browser *browser, int color) |
8f9bbc40 | 31 | { |
08709165 ACM |
32 | int ret = browser->current_color; |
33 | browser->current_color = color; | |
8f9bbc40 | 34 | SLsmg_set_color(color); |
08709165 | 35 | return ret; |
8f9bbc40 ACM |
36 | } |
37 | ||
38 | void ui_browser__set_percent_color(struct ui_browser *self, | |
39 | double percent, bool current) | |
40 | { | |
c172f742 | 41 | int color = ui_browser__percent_color(self, percent, current); |
8f9bbc40 ACM |
42 | ui_browser__set_color(self, color); |
43 | } | |
44 | ||
45 | void ui_browser__gotorc(struct ui_browser *self, int y, int x) | |
46 | { | |
47 | SLsmg_gotorc(self->y + y, self->x + x); | |
48 | } | |
49 | ||
250611cf ACM |
50 | static struct list_head * |
51 | ui_browser__list_head_filter_entries(struct ui_browser *browser, | |
52 | struct list_head *pos) | |
53 | { | |
54 | do { | |
55 | if (!browser->filter || !browser->filter(browser, pos)) | |
56 | return pos; | |
57 | pos = pos->next; | |
58 | } while (pos != browser->entries); | |
59 | ||
60 | return NULL; | |
61 | } | |
62 | ||
63 | static struct list_head * | |
64 | ui_browser__list_head_filter_prev_entries(struct ui_browser *browser, | |
65 | struct list_head *pos) | |
66 | { | |
67 | do { | |
68 | if (!browser->filter || !browser->filter(browser, pos)) | |
69 | return pos; | |
70 | pos = pos->prev; | |
71 | } while (pos != browser->entries); | |
72 | ||
73 | return NULL; | |
74 | } | |
75 | ||
ef8f34aa ACM |
76 | void ui_browser__list_head_seek(struct ui_browser *self, off_t offset, int whence) |
77 | { | |
78 | struct list_head *head = self->entries; | |
79 | struct list_head *pos; | |
80 | ||
250611cf ACM |
81 | if (self->nr_entries == 0) |
82 | return; | |
83 | ||
ef8f34aa ACM |
84 | switch (whence) { |
85 | case SEEK_SET: | |
250611cf | 86 | pos = ui_browser__list_head_filter_entries(self, head->next); |
ef8f34aa ACM |
87 | break; |
88 | case SEEK_CUR: | |
d247eb6b | 89 | pos = self->top; |
ef8f34aa ACM |
90 | break; |
91 | case SEEK_END: | |
250611cf | 92 | pos = ui_browser__list_head_filter_prev_entries(self, head->prev); |
ef8f34aa ACM |
93 | break; |
94 | default: | |
95 | return; | |
96 | } | |
97 | ||
250611cf ACM |
98 | assert(pos != NULL); |
99 | ||
ef8f34aa ACM |
100 | if (offset > 0) { |
101 | while (offset-- != 0) | |
250611cf | 102 | pos = ui_browser__list_head_filter_entries(self, pos->next); |
ef8f34aa ACM |
103 | } else { |
104 | while (offset++ != 0) | |
250611cf | 105 | pos = ui_browser__list_head_filter_prev_entries(self, pos->prev); |
ef8f34aa ACM |
106 | } |
107 | ||
d247eb6b | 108 | self->top = pos; |
ef8f34aa ACM |
109 | } |
110 | ||
111 | void ui_browser__rb_tree_seek(struct ui_browser *self, off_t offset, int whence) | |
112 | { | |
113 | struct rb_root *root = self->entries; | |
114 | struct rb_node *nd; | |
115 | ||
116 | switch (whence) { | |
117 | case SEEK_SET: | |
118 | nd = rb_first(root); | |
119 | break; | |
120 | case SEEK_CUR: | |
d247eb6b | 121 | nd = self->top; |
ef8f34aa ACM |
122 | break; |
123 | case SEEK_END: | |
124 | nd = rb_last(root); | |
125 | break; | |
126 | default: | |
127 | return; | |
128 | } | |
129 | ||
130 | if (offset > 0) { | |
131 | while (offset-- != 0) | |
132 | nd = rb_next(nd); | |
133 | } else { | |
134 | while (offset++ != 0) | |
135 | nd = rb_prev(nd); | |
136 | } | |
137 | ||
d247eb6b | 138 | self->top = nd; |
ef8f34aa ACM |
139 | } |
140 | ||
141 | unsigned int ui_browser__rb_tree_refresh(struct ui_browser *self) | |
142 | { | |
143 | struct rb_node *nd; | |
144 | int row = 0; | |
145 | ||
d247eb6b ACM |
146 | if (self->top == NULL) |
147 | self->top = rb_first(self->entries); | |
ef8f34aa | 148 | |
d247eb6b | 149 | nd = self->top; |
ef8f34aa ACM |
150 | |
151 | while (nd != NULL) { | |
8f9bbc40 | 152 | ui_browser__gotorc(self, row, 0); |
ef8f34aa ACM |
153 | self->write(self, nd, row); |
154 | if (++row == self->height) | |
155 | break; | |
156 | nd = rb_next(nd); | |
157 | } | |
158 | ||
159 | return row; | |
160 | } | |
161 | ||
162 | bool ui_browser__is_current_entry(struct ui_browser *self, unsigned row) | |
163 | { | |
d247eb6b | 164 | return self->top_idx + row == self->index; |
ef8f34aa ACM |
165 | } |
166 | ||
167 | void ui_browser__refresh_dimensions(struct ui_browser *self) | |
168 | { | |
3af6e338 ACM |
169 | self->width = SLtt_Screen_Cols - 1; |
170 | self->height = SLtt_Screen_Rows - 2; | |
469917ce ACM |
171 | self->y = 1; |
172 | self->x = 0; | |
ef8f34aa ACM |
173 | } |
174 | ||
4610e413 ACM |
175 | void ui_browser__handle_resize(struct ui_browser *browser) |
176 | { | |
177 | ui__refresh_dimensions(false); | |
178 | ui_browser__show(browser, browser->title, ui_helpline__current); | |
179 | ui_browser__refresh(browser); | |
180 | } | |
181 | ||
7b27509f ACM |
182 | int ui_browser__warning(struct ui_browser *browser, int timeout, |
183 | const char *format, ...) | |
4610e413 ACM |
184 | { |
185 | va_list args; | |
7b27509f ACM |
186 | char *text; |
187 | int key = 0, err; | |
4610e413 ACM |
188 | |
189 | va_start(args, format); | |
7b27509f | 190 | err = vasprintf(&text, format, args); |
4610e413 ACM |
191 | va_end(args); |
192 | ||
7b27509f ACM |
193 | if (err < 0) { |
194 | va_start(args, format); | |
195 | ui_helpline__vpush(format, args); | |
196 | va_end(args); | |
197 | } else { | |
198 | while ((key == ui__question_window("Warning!", text, | |
199 | "Press any key...", | |
200 | timeout)) == K_RESIZE) | |
201 | ui_browser__handle_resize(browser); | |
202 | free(text); | |
203 | } | |
204 | ||
4610e413 ACM |
205 | return key; |
206 | } | |
207 | ||
208 | int ui_browser__help_window(struct ui_browser *browser, const char *text) | |
209 | { | |
210 | int key; | |
211 | ||
212 | while ((key = ui__help_window(text)) == K_RESIZE) | |
213 | ui_browser__handle_resize(browser); | |
214 | ||
215 | return key; | |
216 | } | |
217 | ||
218 | bool ui_browser__dialog_yesno(struct ui_browser *browser, const char *text) | |
219 | { | |
220 | int key; | |
221 | ||
222 | while ((key = ui__dialog_yesno(text)) == K_RESIZE) | |
223 | ui_browser__handle_resize(browser); | |
224 | ||
225 | return key == K_ENTER || toupper(key) == 'Y'; | |
226 | } | |
227 | ||
ef8f34aa ACM |
228 | void ui_browser__reset_index(struct ui_browser *self) |
229 | { | |
d247eb6b | 230 | self->index = self->top_idx = 0; |
ef8f34aa ACM |
231 | self->seek(self, 0, SEEK_SET); |
232 | } | |
233 | ||
b210b3bb ACM |
234 | void __ui_browser__show_title(struct ui_browser *browser, const char *title) |
235 | { | |
236 | SLsmg_gotorc(0, 0); | |
237 | ui_browser__set_color(browser, NEWT_COLORSET_ROOT); | |
3af6e338 | 238 | slsmg_write_nstring(title, browser->width + 1); |
b210b3bb ACM |
239 | } |
240 | ||
241 | void ui_browser__show_title(struct ui_browser *browser, const char *title) | |
242 | { | |
243 | pthread_mutex_lock(&ui__lock); | |
244 | __ui_browser__show_title(browser, title); | |
245 | pthread_mutex_unlock(&ui__lock); | |
246 | } | |
247 | ||
59e8fe32 ACM |
248 | int ui_browser__show(struct ui_browser *self, const char *title, |
249 | const char *helpline, ...) | |
ef8f34aa | 250 | { |
3af6e338 | 251 | int err; |
59e8fe32 ACM |
252 | va_list ap; |
253 | ||
ef8f34aa | 254 | ui_browser__refresh_dimensions(self); |
ef8f34aa | 255 | |
5c35d69f | 256 | pthread_mutex_lock(&ui__lock); |
b210b3bb | 257 | __ui_browser__show_title(self, title); |
469917ce | 258 | |
3af6e338 ACM |
259 | self->title = title; |
260 | free(self->helpline); | |
261 | self->helpline = NULL; | |
59e8fe32 ACM |
262 | |
263 | va_start(ap, helpline); | |
3af6e338 | 264 | err = vasprintf(&self->helpline, helpline, ap); |
59e8fe32 | 265 | va_end(ap); |
3af6e338 ACM |
266 | if (err > 0) |
267 | ui_helpline__push(self->helpline); | |
5c35d69f | 268 | pthread_mutex_unlock(&ui__lock); |
3af6e338 | 269 | return err ? 0 : -1; |
ef8f34aa ACM |
270 | } |
271 | ||
3af6e338 | 272 | void ui_browser__hide(struct ui_browser *browser __used) |
59e8fe32 | 273 | { |
5c35d69f | 274 | pthread_mutex_lock(&ui__lock); |
59e8fe32 | 275 | ui_helpline__pop(); |
5c35d69f | 276 | pthread_mutex_unlock(&ui__lock); |
59e8fe32 ACM |
277 | } |
278 | ||
3af6e338 ACM |
279 | static void ui_browser__scrollbar_set(struct ui_browser *browser) |
280 | { | |
281 | int height = browser->height, h = 0, pct = 0, | |
282 | col = browser->width, | |
283 | row = browser->y - 1; | |
284 | ||
285 | if (browser->nr_entries > 1) { | |
286 | pct = ((browser->index * (browser->height - 1)) / | |
287 | (browser->nr_entries - 1)); | |
288 | } | |
289 | ||
0458122d ACM |
290 | SLsmg_set_char_set(1); |
291 | ||
3af6e338 ACM |
292 | while (h < height) { |
293 | ui_browser__gotorc(browser, row++, col); | |
0458122d | 294 | SLsmg_write_char(h == pct ? SLSMG_DIAMOND_CHAR : SLSMG_CKBRD_CHAR); |
3af6e338 ACM |
295 | ++h; |
296 | } | |
0458122d ACM |
297 | |
298 | SLsmg_set_char_set(0); | |
3af6e338 ACM |
299 | } |
300 | ||
301 | static int __ui_browser__refresh(struct ui_browser *browser) | |
ef8f34aa ACM |
302 | { |
303 | int row; | |
c172f742 | 304 | int width = browser->width; |
ef8f34aa | 305 | |
3af6e338 ACM |
306 | row = browser->refresh(browser); |
307 | ui_browser__set_color(browser, HE_COLORSET_NORMAL); | |
c172f742 ACM |
308 | |
309 | if (!browser->use_navkeypressed || browser->navkeypressed) | |
310 | ui_browser__scrollbar_set(browser); | |
311 | else | |
312 | width += 1; | |
313 | ||
3af6e338 | 314 | SLsmg_fill_region(browser->y + row, browser->x, |
c172f742 | 315 | browser->height - row, width, ' '); |
3af6e338 ACM |
316 | |
317 | return 0; | |
318 | } | |
319 | ||
320 | int ui_browser__refresh(struct ui_browser *browser) | |
321 | { | |
5c35d69f | 322 | pthread_mutex_lock(&ui__lock); |
3af6e338 | 323 | __ui_browser__refresh(browser); |
5c35d69f | 324 | pthread_mutex_unlock(&ui__lock); |
ef8f34aa ACM |
325 | |
326 | return 0; | |
327 | } | |
328 | ||
900e14a8 ACM |
329 | /* |
330 | * Here we're updating nr_entries _after_ we started browsing, i.e. we have to | |
331 | * forget about any reference to any entry in the underlying data structure, | |
332 | * that is why we do a SEEK_SET. Think about 'perf top' in the hists browser | |
333 | * after an output_resort and hist decay. | |
334 | */ | |
335 | void ui_browser__update_nr_entries(struct ui_browser *browser, u32 nr_entries) | |
336 | { | |
337 | off_t offset = nr_entries - browser->nr_entries; | |
338 | ||
339 | browser->nr_entries = nr_entries; | |
340 | ||
341 | if (offset < 0) { | |
342 | if (browser->top_idx < (u64)-offset) | |
343 | offset = -browser->top_idx; | |
344 | ||
345 | browser->index += offset; | |
346 | browser->top_idx += offset; | |
347 | } | |
348 | ||
437cfe7a | 349 | browser->top = NULL; |
900e14a8 ACM |
350 | browser->seek(browser, browser->top_idx, SEEK_SET); |
351 | } | |
352 | ||
3af6e338 | 353 | int ui_browser__run(struct ui_browser *self, int delay_secs) |
ef8f34aa | 354 | { |
3af6e338 | 355 | int err, key; |
b50e003d | 356 | |
ef8f34aa ACM |
357 | while (1) { |
358 | off_t offset; | |
359 | ||
3af6e338 ACM |
360 | pthread_mutex_lock(&ui__lock); |
361 | err = __ui_browser__refresh(self); | |
362 | SLsmg_refresh(); | |
363 | pthread_mutex_unlock(&ui__lock); | |
364 | if (err < 0) | |
365 | break; | |
366 | ||
cf958003 | 367 | key = ui__getch(delay_secs); |
3af6e338 | 368 | |
cf958003 | 369 | if (key == K_RESIZE) { |
71172ed9 | 370 | ui__refresh_dimensions(false); |
3af6e338 ACM |
371 | ui_browser__refresh_dimensions(self); |
372 | __ui_browser__show_title(self, self->title); | |
373 | ui_helpline__puts(self->helpline); | |
374 | continue; | |
375 | } | |
376 | ||
c172f742 | 377 | if (self->use_navkeypressed && !self->navkeypressed) { |
cf958003 ACM |
378 | if (key == K_DOWN || key == K_UP || |
379 | key == K_PGDN || key == K_PGUP || | |
380 | key == K_HOME || key == K_END || | |
c172f742 ACM |
381 | key == ' ') { |
382 | self->navkeypressed = true; | |
383 | continue; | |
384 | } else | |
385 | return key; | |
386 | } | |
387 | ||
3af6e338 | 388 | switch (key) { |
cf958003 | 389 | case K_DOWN: |
ef8f34aa ACM |
390 | if (self->index == self->nr_entries - 1) |
391 | break; | |
392 | ++self->index; | |
d247eb6b ACM |
393 | if (self->index == self->top_idx + self->height) { |
394 | ++self->top_idx; | |
ef8f34aa ACM |
395 | self->seek(self, +1, SEEK_CUR); |
396 | } | |
397 | break; | |
cf958003 | 398 | case K_UP: |
ef8f34aa ACM |
399 | if (self->index == 0) |
400 | break; | |
401 | --self->index; | |
d247eb6b ACM |
402 | if (self->index < self->top_idx) { |
403 | --self->top_idx; | |
ef8f34aa ACM |
404 | self->seek(self, -1, SEEK_CUR); |
405 | } | |
406 | break; | |
cf958003 | 407 | case K_PGDN: |
ef8f34aa | 408 | case ' ': |
d247eb6b | 409 | if (self->top_idx + self->height > self->nr_entries - 1) |
ef8f34aa ACM |
410 | break; |
411 | ||
412 | offset = self->height; | |
413 | if (self->index + offset > self->nr_entries - 1) | |
414 | offset = self->nr_entries - 1 - self->index; | |
415 | self->index += offset; | |
d247eb6b | 416 | self->top_idx += offset; |
ef8f34aa ACM |
417 | self->seek(self, +offset, SEEK_CUR); |
418 | break; | |
cf958003 | 419 | case K_PGUP: |
d247eb6b | 420 | if (self->top_idx == 0) |
ef8f34aa ACM |
421 | break; |
422 | ||
d247eb6b ACM |
423 | if (self->top_idx < self->height) |
424 | offset = self->top_idx; | |
ef8f34aa ACM |
425 | else |
426 | offset = self->height; | |
427 | ||
428 | self->index -= offset; | |
d247eb6b | 429 | self->top_idx -= offset; |
ef8f34aa ACM |
430 | self->seek(self, -offset, SEEK_CUR); |
431 | break; | |
cf958003 | 432 | case K_HOME: |
ef8f34aa ACM |
433 | ui_browser__reset_index(self); |
434 | break; | |
cf958003 | 435 | case K_END: |
ef8f34aa ACM |
436 | offset = self->height - 1; |
437 | if (offset >= self->nr_entries) | |
438 | offset = self->nr_entries - 1; | |
439 | ||
440 | self->index = self->nr_entries - 1; | |
d247eb6b | 441 | self->top_idx = self->index - offset; |
ef8f34aa ACM |
442 | self->seek(self, -offset, SEEK_END); |
443 | break; | |
444 | default: | |
3af6e338 | 445 | return key; |
ef8f34aa | 446 | } |
ef8f34aa | 447 | } |
b50e003d | 448 | return -1; |
ef8f34aa ACM |
449 | } |
450 | ||
451 | unsigned int ui_browser__list_head_refresh(struct ui_browser *self) | |
452 | { | |
453 | struct list_head *pos; | |
454 | struct list_head *head = self->entries; | |
455 | int row = 0; | |
456 | ||
d247eb6b | 457 | if (self->top == NULL || self->top == self->entries) |
250611cf | 458 | self->top = ui_browser__list_head_filter_entries(self, head->next); |
ef8f34aa | 459 | |
d247eb6b | 460 | pos = self->top; |
ef8f34aa ACM |
461 | |
462 | list_for_each_from(pos, head) { | |
250611cf ACM |
463 | if (!self->filter || !self->filter(self, pos)) { |
464 | ui_browser__gotorc(self, row, 0); | |
465 | self->write(self, pos, row); | |
466 | if (++row == self->height) | |
467 | break; | |
468 | } | |
ef8f34aa ACM |
469 | } |
470 | ||
471 | return row; | |
472 | } | |
473 | ||
e039fc72 ACM |
474 | static struct ui_browser__colorset { |
475 | const char *name, *fg, *bg; | |
476 | int colorset; | |
477 | } ui_browser__colorsets[] = { | |
478 | { | |
479 | .colorset = HE_COLORSET_TOP, | |
480 | .name = "top", | |
481 | .fg = "red", | |
82e0af87 | 482 | .bg = "default", |
e039fc72 ACM |
483 | }, |
484 | { | |
485 | .colorset = HE_COLORSET_MEDIUM, | |
486 | .name = "medium", | |
487 | .fg = "green", | |
82e0af87 | 488 | .bg = "default", |
e039fc72 ACM |
489 | }, |
490 | { | |
491 | .colorset = HE_COLORSET_NORMAL, | |
492 | .name = "normal", | |
82e0af87 ACM |
493 | .fg = "default", |
494 | .bg = "default", | |
e039fc72 ACM |
495 | }, |
496 | { | |
497 | .colorset = HE_COLORSET_SELECTED, | |
498 | .name = "selected", | |
499 | .fg = "black", | |
500 | .bg = "lightgray", | |
501 | }, | |
502 | { | |
503 | .colorset = HE_COLORSET_CODE, | |
504 | .name = "code", | |
505 | .fg = "blue", | |
82e0af87 | 506 | .bg = "default", |
e039fc72 | 507 | }, |
058b4cc9 ACM |
508 | { |
509 | .colorset = HE_COLORSET_ADDR, | |
510 | .name = "addr", | |
511 | .fg = "magenta", | |
512 | .bg = "default", | |
513 | }, | |
e039fc72 ACM |
514 | { |
515 | .name = NULL, | |
516 | } | |
ef8f34aa ACM |
517 | }; |
518 | ||
e039fc72 ACM |
519 | |
520 | static int ui_browser__color_config(const char *var, const char *value, | |
521 | void *data __used) | |
522 | { | |
523 | char *fg = NULL, *bg; | |
524 | int i; | |
525 | ||
526 | /* same dir for all commands */ | |
527 | if (prefixcmp(var, "colors.") != 0) | |
528 | return 0; | |
529 | ||
530 | for (i = 0; ui_browser__colorsets[i].name != NULL; ++i) { | |
531 | const char *name = var + 7; | |
532 | ||
533 | if (strcmp(ui_browser__colorsets[i].name, name) != 0) | |
534 | continue; | |
535 | ||
536 | fg = strdup(value); | |
537 | if (fg == NULL) | |
538 | break; | |
539 | ||
540 | bg = strchr(fg, ','); | |
541 | if (bg == NULL) | |
542 | break; | |
543 | ||
544 | *bg = '\0'; | |
545 | while (isspace(*++bg)); | |
546 | ui_browser__colorsets[i].bg = bg; | |
547 | ui_browser__colorsets[i].fg = fg; | |
548 | return 0; | |
549 | } | |
550 | ||
551 | free(fg); | |
552 | return -1; | |
553 | } | |
554 | ||
1056d3dd ACM |
555 | void ui_browser__argv_seek(struct ui_browser *browser, off_t offset, int whence) |
556 | { | |
557 | switch (whence) { | |
558 | case SEEK_SET: | |
559 | browser->top = browser->entries; | |
560 | break; | |
561 | case SEEK_CUR: | |
562 | browser->top = browser->top + browser->top_idx + offset; | |
563 | break; | |
564 | case SEEK_END: | |
565 | browser->top = browser->top + browser->nr_entries + offset; | |
566 | break; | |
567 | default: | |
568 | return; | |
569 | } | |
570 | } | |
571 | ||
572 | unsigned int ui_browser__argv_refresh(struct ui_browser *browser) | |
573 | { | |
574 | unsigned int row = 0, idx = browser->top_idx; | |
575 | char **pos; | |
576 | ||
577 | if (browser->top == NULL) | |
578 | browser->top = browser->entries; | |
579 | ||
580 | pos = (char **)browser->top; | |
581 | while (idx < browser->nr_entries) { | |
582 | if (!browser->filter || !browser->filter(browser, *pos)) { | |
583 | ui_browser__gotorc(browser, row, 0); | |
584 | browser->write(browser, pos, row); | |
585 | if (++row == browser->height) | |
586 | break; | |
587 | } | |
588 | ||
589 | ++idx; | |
590 | ++pos; | |
591 | } | |
592 | ||
593 | return row; | |
594 | } | |
595 | ||
4656cca1 ACM |
596 | void __ui_browser__vline(struct ui_browser *browser, unsigned int column, |
597 | u16 start, u16 end) | |
598 | { | |
599 | SLsmg_set_char_set(1); | |
600 | ui_browser__gotorc(browser, start, column); | |
601 | SLsmg_draw_vline(end - start + 1); | |
602 | SLsmg_set_char_set(0); | |
603 | } | |
604 | ||
59d038d5 ACM |
605 | void ui_browser__write_graph(struct ui_browser *browser __used, int graph) |
606 | { | |
607 | SLsmg_set_char_set(1); | |
608 | SLsmg_write_char(graph); | |
609 | SLsmg_set_char_set(0); | |
610 | } | |
611 | ||
944e1abe ACM |
612 | static void __ui_browser__line_arrow_up(struct ui_browser *browser, |
613 | unsigned int column, | |
83b1f2aa | 614 | u64 start, u64 end) |
a3f895be ACM |
615 | { |
616 | unsigned int row, end_row; | |
617 | ||
618 | SLsmg_set_char_set(1); | |
619 | ||
620 | if (start < browser->top_idx + browser->height) { | |
621 | row = start - browser->top_idx; | |
622 | ui_browser__gotorc(browser, row, column); | |
623 | SLsmg_write_char(SLSMG_LLCORN_CHAR); | |
624 | ui_browser__gotorc(browser, row, column + 1); | |
83b1f2aa | 625 | SLsmg_draw_hline(2); |
a3f895be ACM |
626 | |
627 | if (row-- == 0) | |
628 | goto out; | |
629 | } else | |
630 | row = browser->height - 1; | |
631 | ||
632 | if (end > browser->top_idx) | |
633 | end_row = end - browser->top_idx; | |
634 | else | |
635 | end_row = 0; | |
636 | ||
637 | ui_browser__gotorc(browser, end_row, column); | |
638 | SLsmg_draw_vline(row - end_row + 1); | |
639 | ||
640 | ui_browser__gotorc(browser, end_row, column); | |
641 | if (end >= browser->top_idx) { | |
642 | SLsmg_write_char(SLSMG_ULCORN_CHAR); | |
643 | ui_browser__gotorc(browser, end_row, column + 1); | |
644 | SLsmg_write_char(SLSMG_HLINE_CHAR); | |
645 | ui_browser__gotorc(browser, end_row, column + 2); | |
646 | SLsmg_write_char(SLSMG_RARROW_CHAR); | |
647 | } | |
648 | out: | |
649 | SLsmg_set_char_set(0); | |
650 | } | |
651 | ||
944e1abe ACM |
652 | static void __ui_browser__line_arrow_down(struct ui_browser *browser, |
653 | unsigned int column, | |
83b1f2aa | 654 | u64 start, u64 end) |
944e1abe ACM |
655 | { |
656 | unsigned int row, end_row; | |
657 | ||
658 | SLsmg_set_char_set(1); | |
659 | ||
660 | if (start >= browser->top_idx) { | |
661 | row = start - browser->top_idx; | |
662 | ui_browser__gotorc(browser, row, column); | |
663 | SLsmg_write_char(SLSMG_ULCORN_CHAR); | |
664 | ui_browser__gotorc(browser, row, column + 1); | |
83b1f2aa | 665 | SLsmg_draw_hline(2); |
944e1abe ACM |
666 | |
667 | if (row++ == 0) | |
668 | goto out; | |
669 | } else | |
670 | row = 0; | |
671 | ||
672 | if (end >= browser->top_idx + browser->height) | |
673 | end_row = browser->height - 1; | |
674 | else | |
675 | end_row = end - browser->top_idx;; | |
676 | ||
677 | ui_browser__gotorc(browser, row, column); | |
678 | SLsmg_draw_vline(end_row - row + 1); | |
679 | ||
680 | ui_browser__gotorc(browser, end_row, column); | |
681 | if (end < browser->top_idx + browser->height) { | |
682 | SLsmg_write_char(SLSMG_LLCORN_CHAR); | |
683 | ui_browser__gotorc(browser, end_row, column + 1); | |
684 | SLsmg_write_char(SLSMG_HLINE_CHAR); | |
685 | ui_browser__gotorc(browser, end_row, column + 2); | |
686 | SLsmg_write_char(SLSMG_RARROW_CHAR); | |
687 | } | |
688 | out: | |
689 | SLsmg_set_char_set(0); | |
690 | } | |
691 | ||
692 | void __ui_browser__line_arrow(struct ui_browser *browser, unsigned int column, | |
83b1f2aa | 693 | u64 start, u64 end) |
944e1abe ACM |
694 | { |
695 | if (start > end) | |
83b1f2aa | 696 | __ui_browser__line_arrow_up(browser, column, start, end); |
944e1abe | 697 | else |
83b1f2aa | 698 | __ui_browser__line_arrow_down(browser, column, start, end); |
944e1abe ACM |
699 | } |
700 | ||
ef8f34aa ACM |
701 | void ui_browser__init(void) |
702 | { | |
e039fc72 | 703 | int i = 0; |
ef8f34aa | 704 | |
e039fc72 ACM |
705 | perf_config(ui_browser__color_config, NULL); |
706 | ||
707 | while (ui_browser__colorsets[i].name) { | |
708 | struct ui_browser__colorset *c = &ui_browser__colorsets[i++]; | |
709 | sltt_set_color(c->colorset, c->name, c->fg, c->bg); | |
710 | } | |
c323cf04 ACM |
711 | |
712 | annotate_browser__init(); | |
ef8f34aa | 713 | } |