[GitHub/mt8127/android_kernel_alcatel_ttab.git] / tools / perf / ui / browser.c

#include "../util.h"
#include "../cache.h"
#include "../../perf.h"
#include "libslang.h"
#include "ui.h"
#include "util.h"
#include <linux/compiler.h>
#include <linux/list.h>
#include <linux/rbtree.h>
#include <stdlib.h>
#include <sys/ttydefaults.h>
#include "browser.h"
#include "helpline.h"
#include "keysyms.h"
#include "../color.h"

static int ui_browser__percent_color(struct ui_browser *browser,
				     double percent, bool current)
{
	if (current && (!browser->use_navkeypressed || browser->navkeypressed))
		return HE_COLORSET_SELECTED;
	if (percent >= MIN_RED)
		return HE_COLORSET_TOP;
	if (percent >= MIN_GREEN)
		return HE_COLORSET_MEDIUM;
	return HE_COLORSET_NORMAL;
}

int ui_browser__set_color(struct ui_browser *browser, int color)
{
	int ret = browser->current_color;
	browser->current_color = color;
	SLsmg_set_color(color);
	return ret;
}

void ui_browser__set_percent_color(struct ui_browser *browser,
				   double percent, bool current)
{
	 int color = ui_browser__percent_color(browser, percent, current);
	 ui_browser__set_color(browser, color);
}

void ui_browser__gotorc(struct ui_browser *browser, int y, int x)
{
	SLsmg_gotorc(browser->y + y, browser->x + x);
}

static struct list_head *
ui_browser__list_head_filter_entries(struct ui_browser *browser,
				     struct list_head *pos)
{
	do {
		if (!browser->filter || !browser->filter(browser, pos))
			return pos;
		pos = pos->next;
	} while (pos != browser->entries);

	return NULL;
}

static struct list_head *
ui_browser__list_head_filter_prev_entries(struct ui_browser *browser,
					  struct list_head *pos)
{
	do {
		if (!browser->filter || !browser->filter(browser, pos))
			return pos;
		pos = pos->prev;
	} while (pos != browser->entries);

	return NULL;
}

void ui_browser__list_head_seek(struct ui_browser *browser, off_t offset, int whence)
{
	struct list_head *head = browser->entries;
	struct list_head *pos;

	if (browser->nr_entries == 0)
		return;

	switch (whence) {
	case SEEK_SET:
		pos = ui_browser__list_head_filter_entries(browser, head->next);
		break;
	case SEEK_CUR:
		pos = browser->top;
		break;
	case SEEK_END:
		pos = ui_browser__list_head_filter_prev_entries(browser, head->prev);
		break;
	default:
		return;
	}

	assert(pos != NULL);

	if (offset > 0) {
		while (offset-- != 0)
			pos = ui_browser__list_head_filter_entries(browser, pos->next);
	} else {
		while (offset++ != 0)
			pos = ui_browser__list_head_filter_prev_entries(browser, pos->prev);
	}

	browser->top = pos;
}

void ui_browser__rb_tree_seek(struct ui_browser *browser, off_t offset, int whence)
{
	struct rb_root *root = browser->entries;
	struct rb_node *nd;

	switch (whence) {
	case SEEK_SET:
		nd = rb_first(root);
		break;
	case SEEK_CUR:
		nd = browser->top;
		break;
	case SEEK_END:
		nd = rb_last(root);
		break;
	default:
		return;
	}

	if (offset > 0) {
		while (offset-- != 0)
			nd = rb_next(nd);
	} else {
		while (offset++ != 0)
			nd = rb_prev(nd);
	}

	browser->top = nd;
}

unsigned int ui_browser__rb_tree_refresh(struct ui_browser *browser)
{
	struct rb_node *nd;
	int row = 0;

	if (browser->top == NULL)
                browser->top = rb_first(browser->entries);

	nd = browser->top;

	while (nd != NULL) {
		ui_browser__gotorc(browser, row, 0);
		browser->write(browser, nd, row);
		if (++row == browser->height)
			break;
		nd = rb_next(nd);
	}

	return row;
}

bool ui_browser__is_current_entry(struct ui_browser *browser, unsigned row)
{
	return browser->top_idx + row == browser->index;
}

void ui_browser__refresh_dimensions(struct ui_browser *browser)
{
	browser->width = SLtt_Screen_Cols - 1;
	browser->height = SLtt_Screen_Rows - 2;
	browser->y = 1;
	browser->x = 0;
}

void ui_browser__handle_resize(struct ui_browser *browser)
{
	ui__refresh_dimensions(false);
	ui_browser__show(browser, browser->title, ui_helpline__current);
	ui_browser__refresh(browser);
}

int ui_browser__warning(struct ui_browser *browser, int timeout,
			const char *format, ...)
{
	va_list args;
	char *text;
	int key = 0, err;

	va_start(args, format);
	err = vasprintf(&text, format, args);
	va_end(args);

	if (err < 0) {
		va_start(args, format);
		ui_helpline__vpush(format, args);
		va_end(args);
	} else {
		while ((key == ui__question_window("Warning!", text,
						   "Press any key...",
						   timeout)) == K_RESIZE)
			ui_browser__handle_resize(browser);
		free(text);
	}

	return key;
}

int ui_browser__help_window(struct ui_browser *browser, const char *text)
{
	int key;

	while ((key = ui__help_window(text)) == K_RESIZE)
		ui_browser__handle_resize(browser);

	return key;
}

bool ui_browser__dialog_yesno(struct ui_browser *browser, const char *text)
{
	int key;

	while ((key = ui__dialog_yesno(text)) == K_RESIZE)
		ui_browser__handle_resize(browser);

	return key == K_ENTER || toupper(key) == 'Y';
}

void ui_browser__reset_index(struct ui_browser *browser)
{
	browser->index = browser->top_idx = 0;
	browser->seek(browser, 0, SEEK_SET);
}

void __ui_browser__show_title(struct ui_browser *browser, const char *title)
{
	SLsmg_gotorc(0, 0);
	ui_browser__set_color(browser, HE_COLORSET_ROOT);
	slsmg_write_nstring(title, browser->width + 1);
}

void ui_browser__show_title(struct ui_browser *browser, const char *title)
{
	pthread_mutex_lock(&ui__lock);
	__ui_browser__show_title(browser, title);
	pthread_mutex_unlock(&ui__lock);
}

int ui_browser__show(struct ui_browser *browser, const char *title,
		     const char *helpline, ...)
{
	int err;
	va_list ap;

	ui_browser__refresh_dimensions(browser);

	pthread_mutex_lock(&ui__lock);
	__ui_browser__show_title(browser, title);

	browser->title = title;
	free(browser->helpline);
	browser->helpline = NULL;

	va_start(ap, helpline);
	err = vasprintf(&browser->helpline, helpline, ap);
	va_end(ap);
	if (err > 0)
		ui_helpline__push(browser->helpline);
	pthread_mutex_unlock(&ui__lock);
	return err ? 0 : -1;
}

void ui_browser__hide(struct ui_browser *browser __maybe_unused)
{
	pthread_mutex_lock(&ui__lock);
	ui_helpline__pop();
	free(browser->helpline);
	browser->helpline = NULL;
	pthread_mutex_unlock(&ui__lock);
}

static void ui_browser__scrollbar_set(struct ui_browser *browser)
{
	int height = browser->height, h = 0, pct = 0,
	    col = browser->width,
	    row = browser->y - 1;

	if (browser->nr_entries > 1) {
		pct = ((browser->index * (browser->height - 1)) /
		       (browser->nr_entries - 1));
	}

	SLsmg_set_char_set(1);

	while (h < height) {
	        ui_browser__gotorc(browser, row++, col);
		SLsmg_write_char(h == pct ? SLSMG_DIAMOND_CHAR : SLSMG_CKBRD_CHAR);
		++h;
	}

	SLsmg_set_char_set(0);
}

static int __ui_browser__refresh(struct ui_browser *browser)
{
	int row;
	int width = browser->width;

	row = browser->refresh(browser);
	ui_browser__set_color(browser, HE_COLORSET_NORMAL);

	if (!browser->use_navkeypressed || browser->navkeypressed)
		ui_browser__scrollbar_set(browser);
	else
		width += 1;

	SLsmg_fill_region(browser->y + row, browser->x,
			  browser->height - row, width, ' ');

	return 0;
}

int ui_browser__refresh(struct ui_browser *browser)
{
	pthread_mutex_lock(&ui__lock);
	__ui_browser__refresh(browser);
	pthread_mutex_unlock(&ui__lock);

	return 0;
}

/*
 * Here we're updating nr_entries _after_ we started browsing, i.e.  we have to
 * forget about any reference to any entry in the underlying data structure,
 * that is why we do a SEEK_SET. Think about 'perf top' in the hists browser
 * after an output_resort and hist decay.
 */
void ui_browser__update_nr_entries(struct ui_browser *browser, u32 nr_entries)
{
	off_t offset = nr_entries - browser->nr_entries;

	browser->nr_entries = nr_entries;

	if (offset < 0) {
		if (browser->top_idx < (u64)-offset)
			offset = -browser->top_idx;

		browser->index += offset;
		browser->top_idx += offset;
	}

	browser->top = NULL;
	browser->seek(browser, browser->top_idx, SEEK_SET);
}

int ui_browser__run(struct ui_browser *browser, int delay_secs)
{
	int err, key;

	while (1) {
		off_t offset;

		pthread_mutex_lock(&ui__lock);
		err = __ui_browser__refresh(browser);
		SLsmg_refresh();
		pthread_mutex_unlock(&ui__lock);
		if (err < 0)
			break;

		key = ui__getch(delay_secs);

		if (key == K_RESIZE) {
			ui__refresh_dimensions(false);
			ui_browser__refresh_dimensions(browser);
			__ui_browser__show_title(browser, browser->title);
			ui_helpline__puts(browser->helpline);
			continue;
		}

		if (browser->use_navkeypressed && !browser->navkeypressed) {
			if (key == K_DOWN || key == K_UP ||
			    key == K_PGDN || key == K_PGUP ||
			    key == K_HOME || key == K_END ||
			    key == ' ') {
				browser->navkeypressed = true;
				continue;
			} else
				return key;
		}

		switch (key) {
		case K_DOWN:
			if (browser->index == browser->nr_entries - 1)
				break;
			++browser->index;
			if (browser->index == browser->top_idx + browser->height) {
				++browser->top_idx;
				browser->seek(browser, +1, SEEK_CUR);
			}
			break;
		case K_UP:
			if (browser->index == 0)
				break;
			--browser->index;
			if (browser->index < browser->top_idx) {
				--browser->top_idx;
				browser->seek(browser, -1, SEEK_CUR);
			}
			break;
		case K_PGDN:
		case ' ':
			if (browser->top_idx + browser->height > browser->nr_entries - 1)
				break;

			offset = browser->height;
			if (browser->index + offset > browser->nr_entries - 1)
				offset = browser->nr_entries - 1 - browser->index;
			browser->index += offset;
			browser->top_idx += offset;
			browser->seek(browser, +offset, SEEK_CUR);
			break;
		case K_PGUP:
			if (browser->top_idx == 0)
				break;

			if (browser->top_idx < browser->height)
				offset = browser->top_idx;
			else
				offset = browser->height;

			browser->index -= offset;
			browser->top_idx -= offset;
			browser->seek(browser, -offset, SEEK_CUR);
			break;
		case K_HOME:
			ui_browser__reset_index(browser);
			break;
		case K_END:
			offset = browser->height - 1;
			if (offset >= browser->nr_entries)
				offset = browser->nr_entries - 1;

			browser->index = browser->nr_entries - 1;
			browser->top_idx = browser->index - offset;
			browser->seek(browser, -offset, SEEK_END);
			break;
		default:
			return key;
		}
	}
	return -1;
}

unsigned int ui_browser__list_head_refresh(struct ui_browser *browser)
{
	struct list_head *pos;
	struct list_head *head = browser->entries;
	int row = 0;

	if (browser->top == NULL || browser->top == browser->entries)
                browser->top = ui_browser__list_head_filter_entries(browser, head->next);

	pos = browser->top;

	list_for_each_from(pos, head) {
		if (!browser->filter || !browser->filter(browser, pos)) {
			ui_browser__gotorc(browser, row, 0);
			browser->write(browser, pos, row);
			if (++row == browser->height)
				break;
		}
	}

	return row;
}

static struct ui_browser_colorset {
	const char *name, *fg, *bg;
	int colorset;
} ui_browser__colorsets[] = {
	{
		.colorset = HE_COLORSET_TOP,
		.name	  = "top",
		.fg	  = "red",
		.bg	  = "default",
	},
	{
		.colorset = HE_COLORSET_MEDIUM,
		.name	  = "medium",
		.fg	  = "green",
		.bg	  = "default",
	},
	{
		.colorset = HE_COLORSET_NORMAL,
		.name	  = "normal",
		.fg	  = "default",
		.bg	  = "default",
	},
	{
		.colorset = HE_COLORSET_SELECTED,
		.name	  = "selected",
		.fg	  = "black",
		.bg	  = "lightgray",
	},
	{
		.colorset = HE_COLORSET_CODE,
		.name	  = "code",
		.fg	  = "blue",
		.bg	  = "default",
	},
	{
		.colorset = HE_COLORSET_ADDR,
		.name	  = "addr",
		.fg	  = "magenta",
		.bg	  = "default",
	},
	{
		.colorset = HE_COLORSET_ROOT,
		.name	  = "root",
		.fg	  = "white",
		.bg	  = "blue",
	},
	{
		.name = NULL,
	}
};


static int ui_browser__color_config(const char *var, const char *value,
				    void *data __maybe_unused)
{
	char *fg = NULL, *bg;
	int i;

	/* same dir for all commands */
	if (prefixcmp(var, "colors.") != 0)
		return 0;

	for (i = 0; ui_browser__colorsets[i].name != NULL; ++i) {
		const char *name = var + 7;

		if (strcmp(ui_browser__colorsets[i].name, name) != 0)
			continue;

		fg = strdup(value);
		if (fg == NULL)
			break;

		bg = strchr(fg, ',');
		if (bg == NULL)
			break;

		*bg = '\0';
		while (isspace(*++bg));
		ui_browser__colorsets[i].bg = bg;
		ui_browser__colorsets[i].fg = fg;
		return 0;
	}

	free(fg);
	return -1;
}

void ui_browser__argv_seek(struct ui_browser *browser, off_t offset, int whence)
{
	switch (whence) {
	case SEEK_SET:
		browser->top = browser->entries;
		break;
	case SEEK_CUR:
		browser->top = browser->top + browser->top_idx + offset;
		break;
	case SEEK_END:
		browser->top = browser->top + browser->nr_entries + offset;
		break;
	default:
		return;
	}
}

unsigned int ui_browser__argv_refresh(struct ui_browser *browser)
{
	unsigned int row = 0, idx = browser->top_idx;
	char **pos;

	if (browser->top == NULL)
		browser->top = browser->entries;

	pos = (char **)browser->top;
	while (idx < browser->nr_entries) {
		if (!browser->filter || !browser->filter(browser, *pos)) {
			ui_browser__gotorc(browser, row, 0);
			browser->write(browser, pos, row);
			if (++row == browser->height)
				break;
		}

		++idx;
		++pos;
	}

	return row;
}

void __ui_browser__vline(struct ui_browser *browser, unsigned int column,
			 u16 start, u16 end)
{
	SLsmg_set_char_set(1);
	ui_browser__gotorc(browser, start, column);
	SLsmg_draw_vline(end - start + 1);
	SLsmg_set_char_set(0);
}

void ui_browser__write_graph(struct ui_browser *browser __maybe_unused,
			     int graph)
{
	SLsmg_set_char_set(1);
	SLsmg_write_char(graph);
	SLsmg_set_char_set(0);
}

static void __ui_browser__line_arrow_up(struct ui_browser *browser,
					unsigned int column,
					u64 start, u64 end)
{
	unsigned int row, end_row;

	SLsmg_set_char_set(1);

	if (start < browser->top_idx + browser->height) {
		row = start - browser->top_idx;
		ui_browser__gotorc(browser, row, column);
		SLsmg_write_char(SLSMG_LLCORN_CHAR);
		ui_browser__gotorc(browser, row, column + 1);
		SLsmg_draw_hline(2);

		if (row-- == 0)
			goto out;
	} else
		row = browser->height - 1;

	if (end > browser->top_idx)
		end_row = end - browser->top_idx;
	else
		end_row = 0;

	ui_browser__gotorc(browser, end_row, column);
	SLsmg_draw_vline(row - end_row + 1);

	ui_browser__gotorc(browser, end_row, column);
	if (end >= browser->top_idx) {
		SLsmg_write_char(SLSMG_ULCORN_CHAR);
		ui_browser__gotorc(browser, end_row, column + 1);
		SLsmg_write_char(SLSMG_HLINE_CHAR);
		ui_browser__gotorc(browser, end_row, column + 2);
		SLsmg_write_char(SLSMG_RARROW_CHAR);
	}
out:
	SLsmg_set_char_set(0);
}

static void __ui_browser__line_arrow_down(struct ui_browser *browser,
					  unsigned int column,
					  u64 start, u64 end)
{
	unsigned int row, end_row;

	SLsmg_set_char_set(1);

	if (start >= browser->top_idx) {
		row = start - browser->top_idx;
		ui_browser__gotorc(browser, row, column);
		SLsmg_write_char(SLSMG_ULCORN_CHAR);
		ui_browser__gotorc(browser, row, column + 1);
		SLsmg_draw_hline(2);

		if (++row == 0)
			goto out;
	} else
		row = 0;

	if (end >= browser->top_idx + browser->height)
		end_row = browser->height - 1;
	else
		end_row = end - browser->top_idx;;

	ui_browser__gotorc(browser, row, column);
	SLsmg_draw_vline(end_row - row + 1);

	ui_browser__gotorc(browser, end_row, column);
	if (end < browser->top_idx + browser->height) {
		SLsmg_write_char(SLSMG_LLCORN_CHAR);
		ui_browser__gotorc(browser, end_row, column + 1);
		SLsmg_write_char(SLSMG_HLINE_CHAR);
		ui_browser__gotorc(browser, end_row, column + 2);
		SLsmg_write_char(SLSMG_RARROW_CHAR);
	}
out:
	SLsmg_set_char_set(0);
}

void __ui_browser__line_arrow(struct ui_browser *browser, unsigned int column,
			      u64 start, u64 end)
{
	if (start > end)
		__ui_browser__line_arrow_up(browser, column, start, end);
	else
		__ui_browser__line_arrow_down(browser, column, start, end);
}

void ui_browser__init(void)
{
	int i = 0;

	perf_config(ui_browser__color_config, NULL);

	while (ui_browser__colorsets[i].name) {
		struct ui_browser_colorset *c = &ui_browser__colorsets[i++];
		sltt_set_color(c->colorset, c->name, c->fg, c->bg);
	}

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