[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 <newt.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 *self,
				   double percent, bool current)
{
	 int color = ui_browser__percent_color(self, percent, current);
	 ui_browser__set_color(self, color);
}

void ui_browser__gotorc(struct ui_browser *self, int y, int x)
{
	SLsmg_gotorc(self->y + y, self->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 *self, off_t offset, int whence)
{
	struct list_head *head = self->entries;
	struct list_head *pos;

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

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

	assert(pos != NULL);

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

	self->top = pos;
}

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

	switch (whence) {
	case SEEK_SET:
		nd = rb_first(root);
		break;
	case SEEK_CUR:
		nd = self->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);
	}

	self->top = nd;
}

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

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

	nd = self->top;

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

	return row;
}

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

void ui_browser__refresh_dimensions(struct ui_browser *self)
{
	self->width = SLtt_Screen_Cols - 1;
	self->height = SLtt_Screen_Rows - 2;
	self->y = 1;
	self->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 *self)
{
	self->index = self->top_idx = 0;
	self->seek(self, 0, SEEK_SET);
}

void __ui_browser__show_title(struct ui_browser *browser, const char *title)
{
	SLsmg_gotorc(0, 0);
	ui_browser__set_color(browser, NEWT_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 *self, const char *title,
		     const char *helpline, ...)
{
	int err;
	va_list ap;

	ui_browser__refresh_dimensions(self);

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

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

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

void ui_browser__hide(struct ui_browser *browser __used)
{
	pthread_mutex_lock(&ui__lock);
	ui_helpline__pop();
	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 *self, int delay_secs)
{
	int err, key;

	while (1) {
		off_t offset;

		pthread_mutex_lock(&ui__lock);
		err = __ui_browser__refresh(self);
		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(self);
			__ui_browser__show_title(self, self->title);
			ui_helpline__puts(self->helpline);
			continue;
		}

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

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

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

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

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

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

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

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

	pos = self->top;

	list_for_each_from(pos, head) {
		if (!self->filter || !self->filter(self, pos)) {
			ui_browser__gotorc(self, row, 0);
			self->write(self, pos, row);
			if (++row == self->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",
	},
	{
		.name = NULL,
	}
};


static int ui_browser__color_config(const char *var, const char *value,
				    void *data __used)
{
	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__write_graph(struct ui_browser *browser __used, int graph)
{
	SLsmg_set_char_set(1);
	SLsmg_write_char(graph);
	SLsmg_set_char_set(0);
}

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);
	}
}
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,
c172f742 ACM	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;
08709165 ACM	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) {
ef8f34aa ACM	85	case SEEK_SET:
250611cf	86	pos = ui_browser__list_head_filter_entries(self, head->next);
ef8f34aa ACM	87	break;
ef8f34aa ACM	88	case SEEK_CUR:
d247eb6b	89	pos = self->top;
ef8f34aa ACM	90	break;
ef8f34aa ACM	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);
250611cf ACM	99
ef8f34aa ACM	100	if (offset > 0) {
ef8f34aa ACM	101	while (offset-- != 0)
250611cf	102	pos = ui_browser__list_head_filter_entries(self, pos->next);
ef8f34aa ACM	103	} else {
ef8f34aa ACM	104	while (offset++ != 0)
250611cf	105	pos = ui_browser__list_head_filter_prev_entries(self, pos->prev);
ef8f34aa ACM	106	}
ef8f34aa ACM	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)
d247eb6b ACM	147	self->top = rb_first(self->entries);
ef8f34aa	148
d247eb6b	149	nd = self->top;
ef8f34aa ACM	150
ef8f34aa ACM	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;
3af6e338 ACM	170	self->height = SLtt_Screen_Rows - 2;
469917ce ACM	171	self->y = 1;
469917ce ACM	172	self->x = 0;
ef8f34aa ACM	173	}
ef8f34aa ACM	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,
7b27509f ACM	183	const char *format, ...)
4610e413 ACM	184	{
4610e413 ACM	185	va_list args;
7b27509f ACM	186	char *text;
7b27509f ACM	187	int key = 0, err;
4610e413 ACM	188
4610e413 ACM	189	va_start(args, format);
7b27509f	190	err = vasprintf(&text, format, args);
4610e413 ACM	191	va_end(args);
4610e413 ACM	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)
ef8f34aa ACM	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,
59e8fe32 ACM	249	const char *helpline, ...)
ef8f34aa	250	{
3af6e338	251	int err;
59e8fe32 ACM	252	va_list ap;
59e8fe32 ACM	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
59e8fe32 ACM	263	va_start(ap, helpline);
3af6e338	264	err = vasprintf(&self->helpline, helpline, ap);
59e8fe32	265	va_end(ap);
3af6e338 ACM	266	if (err > 0)
3af6e338 ACM	267	ui_helpline__push(self->helpline);
5c35d69f	268	pthread_mutex_unlock(&ui__lock);
3af6e338	269	return err ? 0 : -1;
ef8f34aa ACM	270	}
ef8f34aa ACM	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	}
59e8fe32 ACM	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);
0458122d ACM	291
3af6e338 ACM	292	while (h < height) {
3af6e338 ACM	293	ui_browser__gotorc(browser, row++, col);
0458122d	294	SLsmg_write_char(h == pct ? SLSMG_DIAMOND_CHAR : SLSMG_CKBRD_CHAR);
3af6e338 ACM	295	++h;
3af6e338 ACM	296	}
0458122d ACM	297
0458122d ACM	298	SLsmg_set_char_set(0);
3af6e338 ACM	299	}
	300
	301	static int __ui_browser__refresh(struct ui_browser *browser)
ef8f34aa ACM	302	{
ef8f34aa ACM	303	int row;
c172f742	304	int width = browser->width;
ef8f34aa	305
3af6e338 ACM	306	row = browser->refresh(browser);
3af6e338 ACM	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) {
d247eb6b ACM	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) {
d247eb6b ACM	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);
ef8f34aa ACM	418	break;
cf958003	419	case K_PGUP:
d247eb6b	420	if (self->top_idx == 0)
ef8f34aa ACM	421	break;
ef8f34aa ACM	422
d247eb6b ACM	423	if (self->top_idx < self->height)
d247eb6b ACM	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);
ef8f34aa ACM	431	break;
cf958003	432	case K_HOME:
ef8f34aa ACM	433	ui_browser__reset_index(self);
ef8f34aa ACM	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
ef8f34aa ACM	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",
82e0af87 ACM	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	};
ef8f34aa ACM	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
59d038d5 ACM	596	void ui_browser__write_graph(struct ui_browser *browser __used, int graph)
	597	{
	598	SLsmg_set_char_set(1);
	599	SLsmg_write_char(graph);
	600	SLsmg_set_char_set(0);
	601	}
	602
ef8f34aa ACM	603	void ui_browser__init(void)
ef8f34aa ACM	604	{
e039fc72	605	int i = 0;
ef8f34aa	606
e039fc72 ACM	607	perf_config(ui_browser__color_config, NULL);
	608
	609	while (ui_browser__colorsets[i].name) {
	610	struct ui_browser__colorset *c = &ui_browser__colorsets[i++];
	611	sltt_set_color(c->colorset, c->name, c->fg, c->bg);
	612	}
ef8f34aa	613	}