pane

pane.c (12753B)

 #include <termbox.h>
 #include <stdarg.h>
 #include <stdlib.h>
 
 #include "pane.h"
 #include "utils.h"
 
 #define T Pane_T
 struct T {
 	int horizontal;
 	int children_num;
 	T *children;
 	int *rules;
 
 	int x;
 	int y;
 
 	int width;
 	int height;
 
 	int active;
 	T direction[4];
 
 	widget_T widget;
 
 	char *title;
 	int index;
 	int child_no;
 	T parent;
 };
 
 int pane_hasBorder(T self)
 {
 	return !self->children;
 }
 
 int pane_x(T self)
 {
 	if (pane_hasBorder(self))
 		return self->x + 1;
 	else
 		return self->x;
 }
 
 int pane_y(T self)
 {
 	if (pane_hasBorder(self))
 		return self->y + 1;
 	else
 		return self->y;
 }
 int pane_width(T self)
 {
 	if (pane_hasBorder(self))
 		return self->width - 2;
 	else
 		return self->width;
 }
 int pane_height(T self)
 {
 	if (pane_hasBorder(self))
 		return self->height - 2;
 	else
 		return self->height;
 }
 
 #define UP(pane) pane->direction[0]
 #define RIGHT(pane) pane->direction[1]
 #define DOWN(pane) pane->direction[2]
 #define LEFT(pane) pane->direction[3]
 
 Pane_T MAIN;
 Pane_T ACTIVE;
 
 #define BORDER_HORIZONTAL "─"
 #define BORDER_VERTICAL "│"
 #define BORDER_CORNER_1 "┌"
 #define BORDER_CORNER_2 "┐"
 #define BORDER_CORNER_3 "└"
 #define BORDER_CORNER_4 "┘"
 
 void draw_title(T self)
 {
 	if (self->title)
 		tb_printf(self->x + 1, self->y, TB_RED, 0, " %s ", self->title);
 	else
 		tb_printf(self->x + 1, self->y, TB_RED, 0, " %d ", self->index);
 }
 
 void draw_border(int x, int y, int x_max, int y_max, uintattr_t color)
 {
 	size_t i;
 
 	for (i = x + 1; i < x_max; i++) {
 		tb_print(i, y, color, 0, BORDER_HORIZONTAL);
 		tb_print(i, y_max, color, 0, BORDER_HORIZONTAL);
 	}
 
 	for (i = y + 1; i < y_max; i++) {
 		tb_print(x, i, color, 0, BORDER_VERTICAL);
 		tb_print(x_max, i, color, 0, BORDER_VERTICAL);
 	}
 
 	tb_print(x, y, color, 0, BORDER_CORNER_1);
 	tb_print(x_max, y, color, 0, BORDER_CORNER_2);
 	tb_print(x, y_max, color, 0, BORDER_CORNER_3);
 	tb_print(x_max, y_max, color, 0, BORDER_CORNER_4);
 }
 
 void pane_draw_border(T self)
 {
 	int x_max = self->x + self->width - 1;
 	int y_max = self->y + self->height - 1;
 	int color = (self == ACTIVE) ? TB_BLUE : TB_GREEN;
 
 	draw_border(self->x, self->y, x_max, y_max, color);
 	draw_title(self);
 }
 
 void pane_clear(T self, int clear_border)
 {
 	size_t i, j;
 	int border = !clear_border;
 
 	for (j = border; j < self->height - border; j++)
 		for (i = border; i < self->width - border; i++)
 			tb_printf(self->x + i, self->y + j, TB_BLACK, 0, " ");
 }
 
 #define SPLIT_FORMULA(ac, ad, sc, sd)                                    \
 	{                                                                \
 		int total = 0, part, next;                               \
 		size_t i;                                                \
 		int available = self->ad;                                \
 		int last_split = -1;                                     \
                                                                          \
 		for (i = 0; i < self->children_num; i++) {               \
 			self->children[i]->sc = self->sc;                \
 			self->children[i]->sd = self->sd;                \
 			if (self->rules[i] > 0) {                        \
 				total += self->rules[i];                 \
 				last_split = i;                          \
 			} else {                                         \
 				available += self->rules[i];             \
 			}                                                \
 		}                                                        \
                                                                          \
 		part = available / total;                                \
 		next = self->ac;                                         \
 		total = 0;                                               \
 		for (i = 0; i < last_split; i++) {                       \
 			self->children[i]->ac = next;                    \
 			if (self->rules[i] > 0) {                        \
 				total += self->children[i]->ad =         \
 					part * self->rules[i];           \
 			} else {                                         \
 				self->children[i]->ad = -self->rules[i]; \
 			}                                                \
 			next += self->children[i]->ad;                   \
 		}                                                        \
                                                                          \
 		self->children[i]->ac = next;                            \
 		self->children[i]->ad = available - total;               \
 		next += self->children[i]->ad;                           \
                                                                          \
 		for (i = i + 1; i < self->children_num; i++) {           \
 			self->children[i]->ac = next;                    \
 			self->children[i]->ad = -self->rules[i];         \
 			next += self->children[i]->ad;                   \
 		}                                                        \
 	}
 
 #define wrap_or_slap(dir, index)                                    \
 	dir(child) = (dir(self) && dir(self) != self) ? dir(self) : \
 							self->children[index];
 
 #define CONNECTION_FORMULA(af, ab, s1, s2)                             \
 	{                                                              \
 		T child;                                               \
 		for (i = 0; i < self->children_num; i++) {             \
 			child = self->children[i];                     \
 			wrap_or_slap(s1, i);                           \
 			wrap_or_slap(s2, i);                           \
 		}                                                      \
                                                                        \
 		for (i = 1; i < self->children_num; i++)               \
 			ab(self->children[i]) = self->children[i - 1]; \
 		child = self->children[0];                             \
 		wrap_or_slap(ab, self->children_num - 1);              \
                                                                        \
 		for (i = 0; i < self->children_num - 1; i++)           \
 			af(self->children[i]) = self->children[i + 1]; \
 		child = self->children[self->children_num - 1];        \
 		wrap_or_slap(af, 0);                                   \
 	}
 
 int calc_children(T self)
 {
 	if (self->horizontal)
 		SPLIT_FORMULA(x, width, y, height)
 	else
 		SPLIT_FORMULA(y, height, x, width)
 
 	return 1;
 }
 
 int pane_resize(T self)
 {
 	size_t i;
 
 	if (self->widget) {
 		self->widget->resized = 1;
 		self->widget->callback(self->widget);
 	}
 
 	if (self->children_num == 0) {
 		pane_draw_border(self);
 		return 1;
 	}
 
 	calc_children(self);
 	for (i = 0; i < self->children_num; i++)
 		pane_resize(self->children[i]);
 
 	return 1;
 }
 
 int pane_handle_resize(void)
 {
 	MAIN->height = tb_height();
 	MAIN->width = tb_width();
 	MAIN->x = 0;
 	MAIN->y = 0;
 	MAIN->direction[0] = NULL;
 	MAIN->direction[1] = NULL;
 	MAIN->direction[2] = NULL;
 	MAIN->direction[3] = NULL;
 
 	tb_clear();
 	pane_resize(MAIN);
 	tb_present();
 
 	return 1;
 }
 
 int pane_start(int active)
 {
 	tb_init();
 	MAIN = calloc(1, sizeof(*MAIN));
 	MAIN->height = tb_height();
 	MAIN->width = tb_width();
 	MAIN->parent = MAIN;
 	pane_handle_resize();
 
 	if (active) {
 		ACTIVE = MAIN;
 		MAIN->active = 1;
 	}
 
 	return 1;
 }
 
 int pane_stop(void)
 {
 	return tb_shutdown();
 }
 
 T pane_child(T self, int index)
 {
 	return self->children[index];
 }
 
 widget_T pane_widget(T self)
 {
 	return self->widget;
 }
 
 void split(T self, size_t count, va_list ap)
 {
 	static int index = 1;
 	size_t i;
 
 	self->children_num = count;
 	self->children = malloc(self->children_num * sizeof(T));
 	self->rules = malloc(self->children_num * sizeof(int));
 
 	for (i = 0; i < self->children_num; i++) {
 		self->children[i] = calloc(1, sizeof(struct T));
 		self->rules[i] = va_arg(ap, int);
 
 		self->children[i]->index = index++;
 		self->children[i]->parent = self;
 		self->children[i]->child_no = i;
 	}
 
 	if (self->active) {
 		self->active = 0;
 		self->children[0]->active = 1;
 		ACTIVE = self->children[0];
 	}
 
 	if (self->widget)
 		widget_deactivate(self->widget);
 
 	pane_resize(self);
 }
 
 void pane_unsplit(T self)
 {
 	size_t i;
 	int active = 0;
 
 	if (self->children_num) {
 		for (i = 0; i < self->children_num; i++) {
 			pane_unsplit(self->children[i]);
 			if (self->children[i]->active)
 				active = 1;
 			free(self->children[i]);
 		}
 		free(self->children);
 		free(self->rules);
 		self->children = NULL;
 		self->rules = NULL;
 	} else {
 		active = self->active;
 	}
 	self->children_num = 0;
 	self->active = active;
 	if (active) {
 		ACTIVE = self;
 	}
 	pane_clear(self, 1);
 	pane_draw_border(self);
 	tb_present();
 }
 
 T *pane_split(T self, size_t count, ...)
 {
 	size_t i;
 	va_list ap;
 
 	self->horizontal = 1;
 	va_start(ap, count);
 	split(self, count, ap);
 	va_end(ap);
 
 	CONNECTION_FORMULA(RIGHT, LEFT, UP, DOWN)
 
 	return self->children;
 }
 
 T *pane_vsplit(T self, size_t count, ...)
 {
 	size_t i;
 	va_list ap;
 
 	self->horizontal = 0;
 	va_start(ap, count);
 	split(self, count, ap);
 	va_end(ap);
 
 	CONNECTION_FORMULA(DOWN, UP, LEFT, RIGHT)
 
 	return self->children;
 }
 
 void pane_setTitle(T self, char *title)
 {
 	self->title = title;
 	if (self->children_num == 0) {
 		pane_draw_border(self);
 		draw_title(self);
 	}
 }
 
 void setActive(int dir)
 {
 	T old = ACTIVE, tmp;
 	if (!ACTIVE->direction[dir])
 		return;
 
 	ACTIVE = ACTIVE->direction[dir];
 
 	while (ACTIVE->children_num) {
 		int last = ACTIVE->children_num - 1;
 		if (!ACTIVE->horizontal) {
 			if (dir == 0 || dir == 2) {
 				ACTIVE = ACTIVE->children[dir == 2 ? 0 : last];
 				continue;
 			}
 		} else {
 			if (dir == 1 || dir == 3) {
 				ACTIVE = ACTIVE->children[dir == 1 ? 0 : last];
 				continue;
 			}
 		}
 		ACTIVE = ACTIVE->children[ACTIVE->active];
 	}
 
 	old->active = 0;
 	ACTIVE->active = 1;
 
 	for (tmp = ACTIVE; tmp->parent != tmp; tmp = tmp->parent) {
 		tmp->parent->active = tmp->child_no;
 	}
 
 	pane_draw_border(old);
 	pane_draw_border(ACTIVE);
 	tb_present();
 }
 
 int centerVertical(Pane_T pane, int len)
 {
 	if (len > pane_height(pane))
 		return pane_hasBorder(pane) ? 1 : 0;
 
 	return pane_y(pane) + (pane_height(pane) - len) / 2;
 }
 
 int centerHorisontal(Pane_T pane, int len)
 {
 	if (len > pane_width(pane))
 		return pane_hasBorder(pane) ? 1 : 0;
 
 	return pane_x(pane) + (pane_width(pane) - len - 2) / 2 + 1;
 }
 
 /* DATA */
 
 data_T data_new(void *payload, data_handler handler)
 {
 	data_T data = calloc(1, sizeof(*data));
 	data->handle_input = handler;
 	data->payload = payload;
 	data->widget_num = 0;
 	data->widgets = NULL;
 	return data;
 }
 
 /* WIDGET */
 
 int widget_activate(widget_T self, Pane_T pane)
 {
 	self->pane = pane;
 	pane->widget = self;
 	pane_setTitle(pane, self->title);
 
 	self->callback(self);
 	tb_present();
 
 	return 1;
 }
 
 int widget_deactivate(widget_T self)
 {
 	size_t i, j;
 
 	pane_setTitle(self->pane, NULL);
 	self->pane->widget = NULL;
 	self->pane = NULL;
 
 	data_T data = self->data;
 	for (i = j = 0; i < data->widget_num; i++)
 		if (data->widgets[i] != self)
 			data->widgets[j++] = data->widgets[i];
 	data->widget_num = j;
 
 	return 1;
 }
 
 void widget_setData(widget_T self, data_T data)
 {
 	self->inited = 0;
 	self->data = data;
 	data->widgets = realloc(data->widgets, (data->widget_num + 1) *
 						       sizeof(*data->widgets));
 	data->widgets[data->widget_num++] = self;
 }
 
 int pane_handle_input(Pane_T self, struct tb_event ev)
 {
 	size_t i;
 	int res;
 	widget_T widget;
 	data_T data;
 
 	if ((widget = pane_widget(self)) && (data = widget->data)) {
 		if (data->handle_input) {
 			switch ((res = data->handle_input(data, ev))) {
 			case INPUT_HANDLED: {
 				data = widget->data;
 				size_t size = data->widget_num;
 				for (i = 0; i < size; i++) {
 					widget = data->widgets[i];
 					widget->callback(widget);
 					size = data->widget_num;
 				}
 				tb_present();
 				return 1;
 			}
 			case INPUT_IGNORED:
 			case INPUT_REFORM:
 				return res;
 			}
 		}
 	}
 	return INPUT_IGNORED;
 }
 
 int pane_recursive_handle(Pane_T self, struct tb_event ev)
 {
 	size_t i;
 	int res;
 
 	if (!self)
 		return 0;
 
 	switch ((res = pane_handle_input(self, ev))) {
 	case INPUT_HANDLED:
 	case INPUT_REFORM:
 		return res;
 	}
 
 	for (i = 0; i < self->children_num; i++)
 		switch ((res = pane_recursive_handle(self->children[i], ev))) {
 		case INPUT_IGNORED:
 			continue;
 		case INPUT_HANDLED:
 		case INPUT_REFORM:
 			return res;
 		}
 
 	return INPUT_IGNORED;
 }
 
 void pane_event_loop(void)
 {
 	struct tb_event ev;
 
 	while (1) {
 		tb_poll_event(&ev);
 		switch (ev.type) {
 		case TB_EVENT_RESIZE:
 			pane_handle_resize();
 			continue;
 		case TB_EVENT_KEY: {
 			if (ev.key == TB_KEY_ESC) {
 				return;
 			}
 
 			if (ACTIVE) {
 				switch (ev.key) {
 				case TB_KEY_ARROW_UP:
 					setActive(0);
 					continue;
 				case TB_KEY_ARROW_RIGHT:
 					setActive(1);
 					continue;
 				case TB_KEY_ARROW_DOWN:
 					setActive(2);
 					continue;
 				case TB_KEY_ARROW_LEFT:
 					setActive(3);
 					continue;
 				}
 				if (!pane_handle_input(ACTIVE, ev))
 					continue;
 				break;
 			} else {
 				pane_recursive_handle(MAIN, ev);
 			}
 		}
 		}
 	}
 }