[mirrors/Programs.git] / bash / bbs / utils / fm / fm-1.0 / ui.c

/* Copyright (C) 2008 Ricardo Catalinas Jiménez <jimenezrick@gmail.com>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */ 

#include "fm.h"

WINDOW *tree_window, *info_window;
GList *lines, *selected_line, *first_line, *last_line;

void init_lines(void)
{
	lines = g_list_append(lines, tree_root);
	FILE(tree_root)->line = lines;
	selected_line = lines;
	first_line = lines;
	update_last_line();
}

void init_curses(void)
{
	int screen_size[2];

	initscr();
	cbreak();
	nonl();
	noecho();
	keypad(stdscr, TRUE);
	curs_set(0);
	refresh();

	getmaxyx(stdscr, screen_size[0], screen_size[1]);
	tree_window = newwin(screen_size[0] - 1, screen_size[1], 0, 0);
	info_window = newwin(1, screen_size[1], screen_size[0] - 1, 0);
	scrollok(tree_window, TRUE);
	idlok(tree_window, TRUE);
}

void init_ui(char *name)
{
	init_curses();
	init_tree(name);
	init_lines();
	print_line(FILE(tree_root)->line);
	open_directory(tree_root);
	refresh_screen();
}

void refresh_screen(void)
{
	wnoutrefresh(tree_window);
	wnoutrefresh(info_window);
	doupdate();
}

void handle_sigwinch(int signal_number)
{
	ungetch(KEY_RESIZE);
}

void print_lines(GList *start_line, GList *end_line, gboolean clear_bottom_lines)
{
	GList *line_ptr;
	int line_number;

	if (end_line == NULL)
		end_line = last_line;
	else if (start_line != NULL) {
		for (line_ptr = start_line;
				g_list_position(first_line, line_ptr) < getmaxy(tree_window);
				line_ptr = g_list_next(line_ptr)) {
			print_line(line_ptr);
			if (line_ptr == end_line)
				break;
		}
	}
	line_number = g_list_position(first_line, last_line) + 1;
	if (clear_bottom_lines && line_number < getmaxy(tree_window)) {
		wmove(tree_window, line_number, 0);
		wclrtobot(tree_window);
	}
}

void print_parents_lines(GList *line)
{
	GNode *file_ptr;
	int depth;

	for (file_ptr = NODE(line)->parent, depth = g_node_depth(file_ptr) - 1;
			!G_NODE_IS_ROOT(file_ptr); file_ptr = file_ptr->parent, depth--) {
		if (file_ptr != g_node_last_sibling(file_ptr))
			mvwaddch(tree_window, g_list_position(first_line, line),
					2 * depth - 2, ACS_VLINE);
		else
			mvwaddch(tree_window, g_list_position(first_line, line),
					2 * depth - 2, ' ');
		mvwaddch(tree_window, g_list_position(first_line, line), 2 * depth - 1, ' ');
	}
}

void print_line(GList *line)
{
	int line_number = g_list_position(first_line, line);
	GNode *file = NODE(line);
	int depth = g_node_depth(file) - 1;
	char *link_str;

	wmove(tree_window, line_number, 0);
	wclrtoeol(tree_window);

	if (line == selected_line)
		wattron(tree_window, A_REVERSE);

	if (G_NODE_IS_ROOT(file)) {
		wattron(tree_window, A_BOLD);
		waddnstr(tree_window, FILE(file)->name, getmaxx(tree_window) - 1);
		if (!g_str_has_suffix(FILE(file)->name, "/"))
			waddch(tree_window, '/');
		wattroff(tree_window, A_BOLD);
	} else {
		if (file != g_node_last_sibling(file))
			mvwaddch(tree_window, line_number, 2 * depth - 2, ACS_LTEE);
		else
			mvwaddch(tree_window, line_number, 2 * depth - 2, ACS_LLCORNER);

		waddch(tree_window, ACS_HLINE);
		if (FILE(file)->link == TRUE) {
			link_str = g_strdup_printf("%s -> %s", FILE(file)->name,
					FILE(file)->link_path);
			waddnstr(tree_window, link_str, getmaxx(tree_window) - 2 * depth - 1);
			free(link_str);
		} else
			waddnstr(tree_window, FILE(file)->name,
					getmaxx(tree_window) - 2 * depth - 1);

		if (FILE(file)->type == directory_type && ((FILE(file)->link == TRUE &&
						!g_str_has_suffix(FILE(file)->link_path, "/")) ||
					(FILE(file)->link == FALSE &&
					 !g_str_has_suffix(FILE(file)->name, "/"))))
			waddch(tree_window, '/');
		print_parents_lines(line);
	}
	wattroff(tree_window, A_REVERSE);
}

void clear_info(void)
{
	werase(info_window);
}

void print_info(char *message, gboolean bold)
{
	static char *last_message = NULL;
	static gboolean last_bold = FALSE;

	if (message != NULL) {
		if (last_message != NULL)
			free(last_message);
		last_message = strdup(message);
	}
	if (bold == TRUE || bold == FALSE)
		last_bold = bold;
	if (last_bold == TRUE)
		wattron(info_window, A_BOLD);
	werase(info_window);
	if (last_message != NULL)
		waddnstr(info_window, last_message, getmaxx(info_window));
	wattroff(info_window, A_BOLD);
}

void print_error_info(int last_errno, char *file, int line, char *message)
{
	char *message_format = "Error (%s:%i): %s";
	char *message_str;

	if (message != NULL)
		message_str = g_strdup_printf(message_format, file, line, message);
	else
		message_str = g_strdup_printf(message_format, file, line, strerror(last_errno));
	print_info(message_str, TRUE);
	free(message_str);
}

void update_last_line(void)
{
	if (g_list_length(first_line) > getmaxy(tree_window))
		last_line = g_list_nth(first_line, getmaxy(tree_window) - 1);
	else
		last_line = g_list_last(lines);
}

void add_directory_content(GNode *directory)
{
	GNode *file_ptr, *directory_sibling;
	int position;

	directory_sibling = get_next_file_not_deepper(directory);

	for (position = g_list_position(lines, FILE(directory)->line) + 1,
			file_ptr = g_node_first_child(directory);
			file_ptr != NULL && file_ptr != directory_sibling;
			position++, file_ptr = get_next_file(file_ptr)) {
		lines = g_list_insert(lines, file_ptr, position);
		FILE(file_ptr)->line = g_list_nth(lines, position);
	}
}

void open_directory(GNode *directory)
{
	if (FILE(directory)->read == FALSE && read_directory(directory) == FALSE)
		return;

	FILE(directory)->open = TRUE;
	add_directory_content(directory);
	update_last_line();
	print_lines(g_list_next(FILE(directory)->line), last_line, TRUE);
}

void close_directory(GNode *directory)
{
	GNode *directory_sibling;
	GList *line_ptr;

	directory_sibling = get_next_file_not_deepper(directory);

	for (line_ptr = g_list_next(FILE(directory)->line); line_ptr != NULL &&
			NODE(line_ptr) != directory_sibling; line_ptr = g_list_next(FILE(directory)->line))
		lines = g_list_delete_link(lines, line_ptr);

	FILE(directory)->open = FALSE;
	update_last_line();
	print_lines(g_list_next(FILE(directory)->line), last_line, TRUE);
}

void update_directory(GNode *directory)
{
	close_directory(directory);
	destroy_directory_content(directory);
	open_directory(directory);

	if (FILE(directory)->show_dotfiles == TRUE)
		show_dotfiles(directory);
}

void show_dotfiles(GNode *directory)
{
	add_dotfiles(directory);
	update_last_line();
	print_lines(g_list_next(FILE(directory)->line), last_line, TRUE);
}

void hide_dotfiles(GNode *directory)
{
	remove_dotfiles(directory);
	update_last_line();
	print_lines(g_list_next(FILE(directory)->line), last_line, TRUE);
}

void select_line(GList *line)
{
	select_nth_line(g_list_position(lines, line) - g_list_position(lines, selected_line));
}

void select_file(GNode *file)
{
	select_line(FILE(file)->line);
}

void select_nth_line(int n_lines)
{
	GList *old_selected_line;
	int min_n_lines, max_n_lines;

	if ((max_n_lines = g_list_length(selected_line) - 1) < n_lines)
		n_lines = max_n_lines;
	else if((min_n_lines = (int) g_list_length(selected_line) -
				(int) g_list_length(lines)) > n_lines)
		n_lines = min_n_lines;

	old_selected_line = selected_line;
	if (n_lines < 0)
		selected_line = g_list_nth(lines, g_list_position(lines, selected_line) + n_lines);
	else if (n_lines > 0)
		selected_line = g_list_nth(selected_line, n_lines);

	if (g_list_position(lines, selected_line) < g_list_position(lines, first_line))
		scroll_tree(g_list_position(lines, selected_line) -
				g_list_position(lines, first_line));
	else if (g_list_position(lines, selected_line) > g_list_position(lines, last_line))
		scroll_tree(g_list_position(lines, selected_line) -
				g_list_position(lines, last_line));

	if (n_lines != 0) {
		print_line(selected_line);
		if (g_list_position(lines, first_line) <= g_list_position(lines, old_selected_line) &&
				g_list_position(lines, old_selected_line) <=
				g_list_position(lines, last_line))
			print_line(old_selected_line);
	}
}

void scroll_tree(int n_lines)
{
	int min_n_lines, max_n_lines;

	if ((min_n_lines = -g_list_position(lines, first_line)) > n_lines)
		n_lines = min_n_lines;
	else if ((max_n_lines = g_list_length(last_line) - 1) < n_lines)
		n_lines = max_n_lines;

	wscrl(tree_window, n_lines);
	if (n_lines < 0) {
		first_line = g_list_nth(lines, g_list_position(lines, first_line) + n_lines);
		update_last_line();
		print_lines(first_line, g_list_nth(first_line, -n_lines), FALSE);
	} else if (n_lines > 0) {
		first_line = g_list_nth(first_line, n_lines);
		update_last_line();
		print_lines(g_list_nth(lines, g_list_position(lines, last_line) - n_lines),
				last_line, TRUE);
	}
}

void select_line_inside_window(void)
{
	if (g_list_position(lines, selected_line) < g_list_position(lines, first_line))
		select_line(first_line);
	else if (g_list_position(lines, selected_line) > g_list_position(lines, last_line))
		select_line(last_line);
}

void select_next_line_by_first_letter(char letter)
{
	GList *line_ptr;

	for (line_ptr = g_list_next(selected_line); line_ptr != NULL;
			line_ptr = g_list_next(line_ptr)) {
		if (FILE(NODE(line_ptr))->name[0] == letter) {
			select_line(line_ptr);
			return;
		}
	}
}

void select_previous_line_by_first_letter(char letter)
{
	GList *line_ptr;

	for (line_ptr = g_list_previous(selected_line); line_ptr != NULL;
			line_ptr = g_list_previous(line_ptr)) {
		if (FILE(NODE(line_ptr))->name[0] == letter) {
			select_line(line_ptr);
			return;
		}
	}
}
Commit	Line	Data
	1	/* Copyright (C) 2008 Ricardo Catalinas Jiménez <jimenezrick@gmail.com>
	2	*
	3	* This program is free software: you can redistribute it and/or modify
	4	* it under the terms of the GNU General Public License as published by
	5	* the Free Software Foundation, either version 3 of the License, or
	6	* (at your option) any later version.
	7	*
	8	* This program is distributed in the hope that it will be useful,
	9	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	10	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	11	* GNU General Public License for more details.
	12	*
	13	* You should have received a copy of the GNU General Public License
	14	* along with this program. If not, see <http://www.gnu.org/licenses/>.
	15	*/
	16
	17	#include "fm.h"
	18
	19	WINDOW tree_window, info_window;
	20	GList lines, selected_line, first_line, last_line;
	21
	22	void init_lines(void)
	23	{
	24	lines = g_list_append(lines, tree_root);
	25	FILE(tree_root)->line = lines;
	26	selected_line = lines;
	27	first_line = lines;
	28	update_last_line();
	29	}
	30
	31	void init_curses(void)
	32	{
	33	int screen_size[2];
	34
	35	initscr();
	36	cbreak();
	37	nonl();
	38	noecho();
	39	keypad(stdscr, TRUE);
	40	curs_set(0);
	41	refresh();
	42
	43	getmaxyx(stdscr, screen_size[0], screen_size[1]);
	44	tree_window = newwin(screen_size[0] - 1, screen_size[1], 0, 0);
	45	info_window = newwin(1, screen_size[1], screen_size[0] - 1, 0);
	46	scrollok(tree_window, TRUE);
	47	idlok(tree_window, TRUE);
	48	}
	49
	50	void init_ui(char *name)
	51	{
	52	init_curses();
	53	init_tree(name);
	54	init_lines();
	55	print_line(FILE(tree_root)->line);
	56	open_directory(tree_root);
	57	refresh_screen();
	58	}
	59
	60	void refresh_screen(void)
	61	{
	62	wnoutrefresh(tree_window);
	63	wnoutrefresh(info_window);
	64	doupdate();
	65	}
	66
	67	void handle_sigwinch(int signal_number)
	68	{
	69	ungetch(KEY_RESIZE);
	70	}
	71
	72	void print_lines(GList start_line, GList end_line, gboolean clear_bottom_lines)
	73	{
	74	GList *line_ptr;
	75	int line_number;
	76
	77	if (end_line == NULL)
	78	end_line = last_line;
	79	else if (start_line != NULL) {
	80	for (line_ptr = start_line;
	81	g_list_position(first_line, line_ptr) < getmaxy(tree_window);
	82	line_ptr = g_list_next(line_ptr)) {
	83	print_line(line_ptr);
	84	if (line_ptr == end_line)
	85	break;
	86	}
	87	}
	88	line_number = g_list_position(first_line, last_line) + 1;
	89	if (clear_bottom_lines && line_number < getmaxy(tree_window)) {
	90	wmove(tree_window, line_number, 0);
	91	wclrtobot(tree_window);
	92	}
	93	}
	94
	95	void print_parents_lines(GList *line)
	96	{
	97	GNode *file_ptr;
	98	int depth;
	99
	100	for (file_ptr = NODE(line)->parent, depth = g_node_depth(file_ptr) - 1;
	101	!G_NODE_IS_ROOT(file_ptr); file_ptr = file_ptr->parent, depth--) {
	102	if (file_ptr != g_node_last_sibling(file_ptr))
	103	mvwaddch(tree_window, g_list_position(first_line, line),
	104	2 * depth - 2, ACS_VLINE);
	105	else
	106	mvwaddch(tree_window, g_list_position(first_line, line),
	107	2 * depth - 2, ' ');
	108	mvwaddch(tree_window, g_list_position(first_line, line), 2 * depth - 1, ' ');
	109	}
	110	}
	111
	112	void print_line(GList *line)
	113	{
	114	int line_number = g_list_position(first_line, line);
	115	GNode *file = NODE(line);
	116	int depth = g_node_depth(file) - 1;
	117	char *link_str;
	118
	119	wmove(tree_window, line_number, 0);
	120	wclrtoeol(tree_window);
	121
	122	if (line == selected_line)
	123	wattron(tree_window, A_REVERSE);
	124
	125	if (G_NODE_IS_ROOT(file)) {
	126	wattron(tree_window, A_BOLD);
	127	waddnstr(tree_window, FILE(file)->name, getmaxx(tree_window) - 1);
	128	if (!g_str_has_suffix(FILE(file)->name, "/"))
	129	waddch(tree_window, '/');
	130	wattroff(tree_window, A_BOLD);
	131	} else {
	132	if (file != g_node_last_sibling(file))
	133	mvwaddch(tree_window, line_number, 2 * depth - 2, ACS_LTEE);
	134	else
	135	mvwaddch(tree_window, line_number, 2 * depth - 2, ACS_LLCORNER);
	136
	137	waddch(tree_window, ACS_HLINE);
	138	if (FILE(file)->link == TRUE) {
	139	link_str = g_strdup_printf("%s -> %s", FILE(file)->name,
	140	FILE(file)->link_path);
	141	waddnstr(tree_window, link_str, getmaxx(tree_window) - 2 * depth - 1);
	142	free(link_str);
	143	} else
	144	waddnstr(tree_window, FILE(file)->name,
	145	getmaxx(tree_window) - 2 * depth - 1);
	146
	147	if (FILE(file)->type == directory_type && ((FILE(file)->link == TRUE &&
	148	!g_str_has_suffix(FILE(file)->link_path, "/")) \|\|
	149	(FILE(file)->link == FALSE &&
	150	!g_str_has_suffix(FILE(file)->name, "/"))))
	151	waddch(tree_window, '/');
	152	print_parents_lines(line);
	153	}
	154	wattroff(tree_window, A_REVERSE);
	155	}
	156
	157	void clear_info(void)
	158	{
	159	werase(info_window);
	160	}
	161
	162	void print_info(char *message, gboolean bold)
	163	{
	164	static char *last_message = NULL;
	165	static gboolean last_bold = FALSE;
	166
	167	if (message != NULL) {
	168	if (last_message != NULL)
	169	free(last_message);
	170	last_message = strdup(message);
	171	}
	172	if (bold == TRUE \|\| bold == FALSE)
	173	last_bold = bold;
	174	if (last_bold == TRUE)
	175	wattron(info_window, A_BOLD);
	176	werase(info_window);
	177	if (last_message != NULL)
	178	waddnstr(info_window, last_message, getmaxx(info_window));
	179	wattroff(info_window, A_BOLD);
	180	}
	181
	182	void print_error_info(int last_errno, char file, int line, char message)
	183	{
	184	char *message_format = "Error (%s:%i): %s";
	185	char *message_str;
	186
	187	if (message != NULL)
	188	message_str = g_strdup_printf(message_format, file, line, message);
	189	else
	190	message_str = g_strdup_printf(message_format, file, line, strerror(last_errno));
	191	print_info(message_str, TRUE);
	192	free(message_str);
	193	}
	194
	195	void update_last_line(void)
	196	{
	197	if (g_list_length(first_line) > getmaxy(tree_window))
	198	last_line = g_list_nth(first_line, getmaxy(tree_window) - 1);
	199	else
	200	last_line = g_list_last(lines);
	201	}
	202
	203	void add_directory_content(GNode *directory)
	204	{
	205	GNode file_ptr, directory_sibling;
	206	int position;
	207
	208	directory_sibling = get_next_file_not_deepper(directory);
	209
	210	for (position = g_list_position(lines, FILE(directory)->line) + 1,
	211	file_ptr = g_node_first_child(directory);
	212	file_ptr != NULL && file_ptr != directory_sibling;
	213	position++, file_ptr = get_next_file(file_ptr)) {
	214	lines = g_list_insert(lines, file_ptr, position);
	215	FILE(file_ptr)->line = g_list_nth(lines, position);
	216	}
	217	}
	218
	219	void open_directory(GNode *directory)
	220	{
	221	if (FILE(directory)->read == FALSE && read_directory(directory) == FALSE)
	222	return;
	223
	224	FILE(directory)->open = TRUE;
	225	add_directory_content(directory);
	226	update_last_line();
	227	print_lines(g_list_next(FILE(directory)->line), last_line, TRUE);
	228	}
	229
	230	void close_directory(GNode *directory)
	231	{
	232	GNode *directory_sibling;
	233	GList *line_ptr;
	234
	235	directory_sibling = get_next_file_not_deepper(directory);
	236
	237	for (line_ptr = g_list_next(FILE(directory)->line); line_ptr != NULL &&
	238	NODE(line_ptr) != directory_sibling; line_ptr = g_list_next(FILE(directory)->line))
	239	lines = g_list_delete_link(lines, line_ptr);
	240
	241	FILE(directory)->open = FALSE;
	242	update_last_line();
	243	print_lines(g_list_next(FILE(directory)->line), last_line, TRUE);
	244	}
	245
	246	void update_directory(GNode *directory)
	247	{
	248	close_directory(directory);
	249	destroy_directory_content(directory);
	250	open_directory(directory);
	251
	252	if (FILE(directory)->show_dotfiles == TRUE)
	253	show_dotfiles(directory);
	254	}
	255
	256	void show_dotfiles(GNode *directory)
	257	{
	258	add_dotfiles(directory);
	259	update_last_line();
	260	print_lines(g_list_next(FILE(directory)->line), last_line, TRUE);
	261	}
	262
	263	void hide_dotfiles(GNode *directory)
	264	{
	265	remove_dotfiles(directory);
	266	update_last_line();
	267	print_lines(g_list_next(FILE(directory)->line), last_line, TRUE);
	268	}
	269
	270	void select_line(GList *line)
	271	{
	272	select_nth_line(g_list_position(lines, line) - g_list_position(lines, selected_line));
	273	}
	274
	275	void select_file(GNode *file)
	276	{
	277	select_line(FILE(file)->line);
	278	}
	279
	280	void select_nth_line(int n_lines)
	281	{
	282	GList *old_selected_line;
	283	int min_n_lines, max_n_lines;
	284
	285	if ((max_n_lines = g_list_length(selected_line) - 1) < n_lines)
	286	n_lines = max_n_lines;
	287	else if((min_n_lines = (int) g_list_length(selected_line) -
	288	(int) g_list_length(lines)) > n_lines)
	289	n_lines = min_n_lines;
	290
	291	old_selected_line = selected_line;
	292	if (n_lines < 0)
	293	selected_line = g_list_nth(lines, g_list_position(lines, selected_line) + n_lines);
	294	else if (n_lines > 0)
	295	selected_line = g_list_nth(selected_line, n_lines);
	296
	297	if (g_list_position(lines, selected_line) < g_list_position(lines, first_line))
	298	scroll_tree(g_list_position(lines, selected_line) -
	299	g_list_position(lines, first_line));
	300	else if (g_list_position(lines, selected_line) > g_list_position(lines, last_line))
	301	scroll_tree(g_list_position(lines, selected_line) -
	302	g_list_position(lines, last_line));
	303
	304	if (n_lines != 0) {
	305	print_line(selected_line);
	306	if (g_list_position(lines, first_line) <= g_list_position(lines, old_selected_line) &&
	307	g_list_position(lines, old_selected_line) <=
	308	g_list_position(lines, last_line))
	309	print_line(old_selected_line);
	310	}
	311	}
	312
	313	void scroll_tree(int n_lines)
	314	{
	315	int min_n_lines, max_n_lines;
	316
	317	if ((min_n_lines = -g_list_position(lines, first_line)) > n_lines)
	318	n_lines = min_n_lines;
	319	else if ((max_n_lines = g_list_length(last_line) - 1) < n_lines)
	320	n_lines = max_n_lines;
	321
	322	wscrl(tree_window, n_lines);
	323	if (n_lines < 0) {
	324	first_line = g_list_nth(lines, g_list_position(lines, first_line) + n_lines);
	325	update_last_line();
	326	print_lines(first_line, g_list_nth(first_line, -n_lines), FALSE);
	327	} else if (n_lines > 0) {
	328	first_line = g_list_nth(first_line, n_lines);
	329	update_last_line();
	330	print_lines(g_list_nth(lines, g_list_position(lines, last_line) - n_lines),
	331	last_line, TRUE);
	332	}
	333	}
	334
	335	void select_line_inside_window(void)
	336	{
	337	if (g_list_position(lines, selected_line) < g_list_position(lines, first_line))
	338	select_line(first_line);
	339	else if (g_list_position(lines, selected_line) > g_list_position(lines, last_line))
	340	select_line(last_line);
	341	}
	342
	343	void select_next_line_by_first_letter(char letter)
	344	{
	345	GList *line_ptr;
	346
	347	for (line_ptr = g_list_next(selected_line); line_ptr != NULL;
	348	line_ptr = g_list_next(line_ptr)) {
	349	if (FILE(NODE(line_ptr))->name[0] == letter) {
	350	select_line(line_ptr);
	351	return;
	352	}
	353	}
	354	}
	355
	356	void select_previous_line_by_first_letter(char letter)
	357	{
	358	GList *line_ptr;
	359
	360	for (line_ptr = g_list_previous(selected_line); line_ptr != NULL;
	361	line_ptr = g_list_previous(line_ptr)) {
	362	if (FILE(NODE(line_ptr))->name[0] == letter) {
	363	select_line(line_ptr);
	364	return;
	365	}
	366	}
	367	}