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