[linux-2.6-block.git] / tools / perf / util / 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;
}

void ui_browser__set_color(struct ui_browser *self __used, int color)
{
	SLsmg_set_color(color);
}

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__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));
	}

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

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",
	},
	{
		.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__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
8f9bbc40 ACM	30	void ui_browser__set_color(struct ui_browser *self __used, int color)
	31	{
	32	SLsmg_set_color(color);
	33	}
	34
	35	void ui_browser__set_percent_color(struct ui_browser *self,
	36	double percent, bool current)
	37	{
c172f742	38	int color = ui_browser__percent_color(self, percent, current);
8f9bbc40 ACM	39	ui_browser__set_color(self, color);
	40	}
	41
	42	void ui_browser__gotorc(struct ui_browser *self, int y, int x)
	43	{
	44	SLsmg_gotorc(self->y + y, self->x + x);
	45	}
	46
250611cf ACM	47	static struct list_head *
	48	ui_browser__list_head_filter_entries(struct ui_browser *browser,
	49	struct list_head *pos)
	50	{
	51	do {
	52	if (!browser->filter \|\| !browser->filter(browser, pos))
	53	return pos;
	54	pos = pos->next;
	55	} while (pos != browser->entries);
	56
	57	return NULL;
	58	}
	59
	60	static struct list_head *
	61	ui_browser__list_head_filter_prev_entries(struct ui_browser *browser,
	62	struct list_head *pos)
	63	{
	64	do {
	65	if (!browser->filter \|\| !browser->filter(browser, pos))
	66	return pos;
	67	pos = pos->prev;
	68	} while (pos != browser->entries);
	69
	70	return NULL;
	71	}
	72
ef8f34aa ACM	73	void ui_browser__list_head_seek(struct ui_browser *self, off_t offset, int whence)
	74	{
	75	struct list_head *head = self->entries;
	76	struct list_head *pos;
	77
250611cf ACM	78	if (self->nr_entries == 0)
	79	return;
	80
ef8f34aa ACM	81	switch (whence) {
ef8f34aa ACM	82	case SEEK_SET:
250611cf	83	pos = ui_browser__list_head_filter_entries(self, head->next);
ef8f34aa ACM	84	break;
ef8f34aa ACM	85	case SEEK_CUR:
d247eb6b	86	pos = self->top;
ef8f34aa ACM	87	break;
ef8f34aa ACM	88	case SEEK_END:
250611cf	89	pos = ui_browser__list_head_filter_prev_entries(self, head->prev);
ef8f34aa ACM	90	break;
	91	default:
	92	return;
	93	}
	94
250611cf ACM	95	assert(pos != NULL);
250611cf ACM	96
ef8f34aa ACM	97	if (offset > 0) {
ef8f34aa ACM	98	while (offset-- != 0)
250611cf	99	pos = ui_browser__list_head_filter_entries(self, pos->next);
ef8f34aa ACM	100	} else {
ef8f34aa ACM	101	while (offset++ != 0)
250611cf	102	pos = ui_browser__list_head_filter_prev_entries(self, pos->prev);
ef8f34aa ACM	103	}
ef8f34aa ACM	104
d247eb6b	105	self->top = pos;
ef8f34aa ACM	106	}
	107
	108	void ui_browser__rb_tree_seek(struct ui_browser *self, off_t offset, int whence)
	109	{
	110	struct rb_root *root = self->entries;
	111	struct rb_node *nd;
	112
	113	switch (whence) {
	114	case SEEK_SET:
	115	nd = rb_first(root);
	116	break;
	117	case SEEK_CUR:
d247eb6b	118	nd = self->top;
ef8f34aa ACM	119	break;
	120	case SEEK_END:
	121	nd = rb_last(root);
	122	break;
	123	default:
	124	return;
	125	}
	126
	127	if (offset > 0) {
	128	while (offset-- != 0)
	129	nd = rb_next(nd);
	130	} else {
	131	while (offset++ != 0)
	132	nd = rb_prev(nd);
	133	}
	134
d247eb6b	135	self->top = nd;
ef8f34aa ACM	136	}
	137
	138	unsigned int ui_browser__rb_tree_refresh(struct ui_browser *self)
	139	{
	140	struct rb_node *nd;
	141	int row = 0;
	142
d247eb6b ACM	143	if (self->top == NULL)
d247eb6b ACM	144	self->top = rb_first(self->entries);
ef8f34aa	145
d247eb6b	146	nd = self->top;
ef8f34aa ACM	147
ef8f34aa ACM	148	while (nd != NULL) {
8f9bbc40	149	ui_browser__gotorc(self, row, 0);
ef8f34aa ACM	150	self->write(self, nd, row);
	151	if (++row == self->height)
	152	break;
	153	nd = rb_next(nd);
	154	}
	155
	156	return row;
	157	}
	158
	159	bool ui_browser__is_current_entry(struct ui_browser *self, unsigned row)
	160	{
d247eb6b	161	return self->top_idx + row == self->index;
ef8f34aa ACM	162	}
	163
	164	void ui_browser__refresh_dimensions(struct ui_browser *self)
	165	{
3af6e338 ACM	166	self->width = SLtt_Screen_Cols - 1;
3af6e338 ACM	167	self->height = SLtt_Screen_Rows - 2;
469917ce ACM	168	self->y = 1;
469917ce ACM	169	self->x = 0;
ef8f34aa ACM	170	}
	171
	172	void ui_browser__reset_index(struct ui_browser *self)
	173	{
d247eb6b	174	self->index = self->top_idx = 0;
ef8f34aa ACM	175	self->seek(self, 0, SEEK_SET);
	176	}
	177
b210b3bb ACM	178	void __ui_browser__show_title(struct ui_browser browser, const char title)
	179	{
	180	SLsmg_gotorc(0, 0);
	181	ui_browser__set_color(browser, NEWT_COLORSET_ROOT);
3af6e338	182	slsmg_write_nstring(title, browser->width + 1);
b210b3bb ACM	183	}
	184
	185	void ui_browser__show_title(struct ui_browser browser, const char title)
	186	{
	187	pthread_mutex_lock(&ui__lock);
	188	__ui_browser__show_title(browser, title);
	189	pthread_mutex_unlock(&ui__lock);
	190	}
	191
59e8fe32 ACM	192	int ui_browser__show(struct ui_browser self, const char title,
59e8fe32 ACM	193	const char *helpline, ...)
ef8f34aa	194	{
3af6e338	195	int err;
59e8fe32 ACM	196	va_list ap;
59e8fe32 ACM	197
ef8f34aa	198	ui_browser__refresh_dimensions(self);
ef8f34aa	199
5c35d69f	200	pthread_mutex_lock(&ui__lock);
b210b3bb	201	__ui_browser__show_title(self, title);
469917ce	202
3af6e338 ACM	203	self->title = title;
	204	free(self->helpline);
	205	self->helpline = NULL;
59e8fe32 ACM	206
59e8fe32 ACM	207	va_start(ap, helpline);
3af6e338	208	err = vasprintf(&self->helpline, helpline, ap);
59e8fe32	209	va_end(ap);
3af6e338 ACM	210	if (err > 0)
3af6e338 ACM	211	ui_helpline__push(self->helpline);
5c35d69f	212	pthread_mutex_unlock(&ui__lock);
3af6e338	213	return err ? 0 : -1;
ef8f34aa ACM	214	}
ef8f34aa ACM	215
3af6e338	216	void ui_browser__hide(struct ui_browser *browser __used)
59e8fe32	217	{
5c35d69f	218	pthread_mutex_lock(&ui__lock);
59e8fe32	219	ui_helpline__pop();
5c35d69f	220	pthread_mutex_unlock(&ui__lock);
59e8fe32 ACM	221	}
59e8fe32 ACM	222
3af6e338 ACM	223	static void ui_browser__scrollbar_set(struct ui_browser *browser)
	224	{
	225	int height = browser->height, h = 0, pct = 0,
	226	col = browser->width,
	227	row = browser->y - 1;
	228
	229	if (browser->nr_entries > 1) {
	230	pct = ((browser->index * (browser->height - 1)) /
	231	(browser->nr_entries - 1));
	232	}
	233
	234	while (h < height) {
	235	ui_browser__gotorc(browser, row++, col);
	236	SLsmg_set_char_set(1);
	237	SLsmg_write_char(h == pct ? SLSMG_DIAMOND_CHAR : SLSMG_BOARD_CHAR);
	238	SLsmg_set_char_set(0);
	239	++h;
	240	}
	241	}
	242
	243	static int __ui_browser__refresh(struct ui_browser *browser)
ef8f34aa ACM	244	{
ef8f34aa ACM	245	int row;
c172f742	246	int width = browser->width;
ef8f34aa	247
3af6e338 ACM	248	row = browser->refresh(browser);
3af6e338 ACM	249	ui_browser__set_color(browser, HE_COLORSET_NORMAL);
c172f742 ACM	250
	251	if (!browser->use_navkeypressed \|\| browser->navkeypressed)
	252	ui_browser__scrollbar_set(browser);
	253	else
	254	width += 1;
	255
3af6e338	256	SLsmg_fill_region(browser->y + row, browser->x,
c172f742	257	browser->height - row, width, ' ');
3af6e338 ACM	258
	259	return 0;
	260	}
	261
	262	int ui_browser__refresh(struct ui_browser *browser)
	263	{
5c35d69f	264	pthread_mutex_lock(&ui__lock);
3af6e338	265	__ui_browser__refresh(browser);
5c35d69f	266	pthread_mutex_unlock(&ui__lock);
ef8f34aa ACM	267
	268	return 0;
	269	}
	270
900e14a8 ACM	271	/*
	272	* Here we're updating nr_entries _after_ we started browsing, i.e. we have to
	273	* forget about any reference to any entry in the underlying data structure,
	274	* that is why we do a SEEK_SET. Think about 'perf top' in the hists browser
	275	* after an output_resort and hist decay.
	276	*/
	277	void ui_browser__update_nr_entries(struct ui_browser *browser, u32 nr_entries)
	278	{
	279	off_t offset = nr_entries - browser->nr_entries;
	280
	281	browser->nr_entries = nr_entries;
	282
	283	if (offset < 0) {
	284	if (browser->top_idx < (u64)-offset)
	285	offset = -browser->top_idx;
	286
	287	browser->index += offset;
	288	browser->top_idx += offset;
	289	}
	290
437cfe7a	291	browser->top = NULL;
900e14a8 ACM	292	browser->seek(browser, browser->top_idx, SEEK_SET);
	293	}
	294
3af6e338	295	int ui_browser__run(struct ui_browser *self, int delay_secs)
ef8f34aa	296	{
3af6e338	297	int err, key;
b50e003d	298
ef8f34aa ACM	299	while (1) {
	300	off_t offset;
	301
3af6e338 ACM	302	pthread_mutex_lock(&ui__lock);
	303	err = __ui_browser__refresh(self);
	304	SLsmg_refresh();
	305	pthread_mutex_unlock(&ui__lock);
	306	if (err < 0)
	307	break;
	308
cf958003	309	key = ui__getch(delay_secs);
3af6e338	310
cf958003	311	if (key == K_RESIZE) {
71172ed9	312	ui__refresh_dimensions(false);
3af6e338 ACM	313	ui_browser__refresh_dimensions(self);
	314	__ui_browser__show_title(self, self->title);
	315	ui_helpline__puts(self->helpline);
	316	continue;
	317	}
	318
c172f742	319	if (self->use_navkeypressed && !self->navkeypressed) {
cf958003 ACM	320	if (key == K_DOWN \|\| key == K_UP \|\|
	321	key == K_PGDN \|\| key == K_PGUP \|\|
	322	key == K_HOME \|\| key == K_END \|\|
c172f742 ACM	323	key == ' ') {
	324	self->navkeypressed = true;
	325	continue;
	326	} else
	327	return key;
	328	}
	329
3af6e338	330	switch (key) {
cf958003	331	case K_DOWN:
ef8f34aa ACM	332	if (self->index == self->nr_entries - 1)
	333	break;
	334	++self->index;
d247eb6b ACM	335	if (self->index == self->top_idx + self->height) {
d247eb6b ACM	336	++self->top_idx;
ef8f34aa ACM	337	self->seek(self, +1, SEEK_CUR);
	338	}
	339	break;
cf958003	340	case K_UP:
ef8f34aa ACM	341	if (self->index == 0)
	342	break;
	343	--self->index;
d247eb6b ACM	344	if (self->index < self->top_idx) {
d247eb6b ACM	345	--self->top_idx;
ef8f34aa ACM	346	self->seek(self, -1, SEEK_CUR);
	347	}
	348	break;
cf958003	349	case K_PGDN:
ef8f34aa	350	case ' ':
d247eb6b	351	if (self->top_idx + self->height > self->nr_entries - 1)
ef8f34aa ACM	352	break;
	353
	354	offset = self->height;
	355	if (self->index + offset > self->nr_entries - 1)
	356	offset = self->nr_entries - 1 - self->index;
	357	self->index += offset;
d247eb6b	358	self->top_idx += offset;
ef8f34aa ACM	359	self->seek(self, +offset, SEEK_CUR);
ef8f34aa ACM	360	break;
cf958003	361	case K_PGUP:
d247eb6b	362	if (self->top_idx == 0)
ef8f34aa ACM	363	break;
ef8f34aa ACM	364
d247eb6b ACM	365	if (self->top_idx < self->height)
d247eb6b ACM	366	offset = self->top_idx;
ef8f34aa ACM	367	else
	368	offset = self->height;
	369
	370	self->index -= offset;
d247eb6b	371	self->top_idx -= offset;
ef8f34aa ACM	372	self->seek(self, -offset, SEEK_CUR);
ef8f34aa ACM	373	break;
cf958003	374	case K_HOME:
ef8f34aa ACM	375	ui_browser__reset_index(self);
ef8f34aa ACM	376	break;
cf958003	377	case K_END:
ef8f34aa ACM	378	offset = self->height - 1;
	379	if (offset >= self->nr_entries)
	380	offset = self->nr_entries - 1;
	381
	382	self->index = self->nr_entries - 1;
d247eb6b	383	self->top_idx = self->index - offset;
ef8f34aa ACM	384	self->seek(self, -offset, SEEK_END);
	385	break;
	386	default:
3af6e338	387	return key;
ef8f34aa	388	}
ef8f34aa	389	}
b50e003d	390	return -1;
ef8f34aa ACM	391	}
	392
	393	unsigned int ui_browser__list_head_refresh(struct ui_browser *self)
	394	{
	395	struct list_head *pos;
	396	struct list_head *head = self->entries;
	397	int row = 0;
	398
d247eb6b	399	if (self->top == NULL \|\| self->top == self->entries)
250611cf	400	self->top = ui_browser__list_head_filter_entries(self, head->next);
ef8f34aa	401
d247eb6b	402	pos = self->top;
ef8f34aa ACM	403
ef8f34aa ACM	404	list_for_each_from(pos, head) {
250611cf ACM	405	if (!self->filter \|\| !self->filter(self, pos)) {
	406	ui_browser__gotorc(self, row, 0);
	407	self->write(self, pos, row);
	408	if (++row == self->height)
	409	break;
	410	}
ef8f34aa ACM	411	}
	412
	413	return row;
	414	}
	415
e039fc72 ACM	416	static struct ui_browser__colorset {
	417	const char name, fg, *bg;
	418	int colorset;
	419	} ui_browser__colorsets[] = {
	420	{
	421	.colorset = HE_COLORSET_TOP,
	422	.name = "top",
	423	.fg = "red",
82e0af87	424	.bg = "default",
e039fc72 ACM	425	},
	426	{
	427	.colorset = HE_COLORSET_MEDIUM,
	428	.name = "medium",
	429	.fg = "green",
82e0af87	430	.bg = "default",
e039fc72 ACM	431	},
	432	{
	433	.colorset = HE_COLORSET_NORMAL,
	434	.name = "normal",
82e0af87 ACM	435	.fg = "default",
82e0af87 ACM	436	.bg = "default",
e039fc72 ACM	437	},
	438	{
	439	.colorset = HE_COLORSET_SELECTED,
	440	.name = "selected",
	441	.fg = "black",
	442	.bg = "lightgray",
	443	},
	444	{
	445	.colorset = HE_COLORSET_CODE,
	446	.name = "code",
	447	.fg = "blue",
82e0af87	448	.bg = "default",
e039fc72 ACM	449	},
	450	{
	451	.name = NULL,
	452	}
ef8f34aa ACM	453	};
ef8f34aa ACM	454
e039fc72 ACM	455
	456	static int ui_browser__color_config(const char var, const char value,
	457	void *data __used)
	458	{
	459	char fg = NULL, bg;
	460	int i;
	461
	462	/* same dir for all commands */
	463	if (prefixcmp(var, "colors.") != 0)
	464	return 0;
	465
	466	for (i = 0; ui_browser__colorsets[i].name != NULL; ++i) {
	467	const char *name = var + 7;
	468
	469	if (strcmp(ui_browser__colorsets[i].name, name) != 0)
	470	continue;
	471
	472	fg = strdup(value);
	473	if (fg == NULL)
	474	break;
	475
	476	bg = strchr(fg, ',');
	477	if (bg == NULL)
	478	break;
	479
	480	*bg = '\0';
	481	while (isspace(*++bg));
	482	ui_browser__colorsets[i].bg = bg;
	483	ui_browser__colorsets[i].fg = fg;
	484	return 0;
	485	}
	486
	487	free(fg);
	488	return -1;
	489	}
	490
1056d3dd ACM	491	void ui_browser__argv_seek(struct ui_browser *browser, off_t offset, int whence)
	492	{
	493	switch (whence) {
	494	case SEEK_SET:
	495	browser->top = browser->entries;
	496	break;
	497	case SEEK_CUR:
	498	browser->top = browser->top + browser->top_idx + offset;
	499	break;
	500	case SEEK_END:
	501	browser->top = browser->top + browser->nr_entries + offset;
	502	break;
	503	default:
	504	return;
	505	}
	506	}
	507
	508	unsigned int ui_browser__argv_refresh(struct ui_browser *browser)
	509	{
	510	unsigned int row = 0, idx = browser->top_idx;
	511	char **pos;
	512
	513	if (browser->top == NULL)
	514	browser->top = browser->entries;
	515
	516	pos = (char **)browser->top;
	517	while (idx < browser->nr_entries) {
	518	if (!browser->filter \|\| !browser->filter(browser, *pos)) {
	519	ui_browser__gotorc(browser, row, 0);
	520	browser->write(browser, pos, row);
	521	if (++row == browser->height)
	522	break;
	523	}
	524
	525	++idx;
	526	++pos;
	527	}
	528
	529	return row;
	530	}
	531
ef8f34aa ACM	532	void ui_browser__init(void)
ef8f34aa ACM	533	{
e039fc72	534	int i = 0;
ef8f34aa	535
e039fc72 ACM	536	perf_config(ui_browser__color_config, NULL);
	537
	538	while (ui_browser__colorsets[i].name) {
	539	struct ui_browser__colorset *c = &ui_browser__colorsets[i++];
	540	sltt_set_color(c->colorset, c->name, c->fg, c->bg);
	541	}
ef8f34aa	542	}