[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
21c4e167 H	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	}