/*  *	HT Editor *	httree.cc * *	Copyright (C) 1999-2002 Sebastian Biallas (sb@biallas.net) * *	This program is free software; you can redistribute it and/or modify *	it under the terms of the GNU General Public License version 2 as *	published by the Free Software Foundation. * *	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, write to the Free Software *	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */#include <stdlib.h>#include "string.h"#include "htdialog.h"#include "htpal.h"#include "keyb.h"#include "strtools.h"#include "httree.h"#include "stream.h"void ht_treeview::init(Bounds *b, const char *d){	ht_view::init(b, VO_SELECTABLE | VO_BROWSABLE/* <- FIXME */ | VO_RESIZE, d);	VIEW_DEBUG_NAME("ht_treeview");	growmode = MK_GM(GMH_FIT, GMV_FIT);	foc = 0;	delta_x = delta_y = 0;	maxsize_y = 5;	selected = NULL;}void ht_treeview::done(){	ht_view::done();}void ht_treeview::adjust_focus(int Focus){	if (Focus < 0) Focus = 0; else if (Focus >= maxsize_y) Focus = maxsize_y - 1;	if (foc != Focus) has_focused(Focus);	if (Focus < delta_y) scroll_to(delta_x, Focus);		else if ((Focus - size.h) >= delta_y) scroll_to(delta_x, Focus - size.h + 1);}int  ht_treeview::create_graph(AbstractChar *s, void *node, int level, int lines, int width, int endwidth, const AbstractChar *Chars){// Chars: space, vbar, T, last L,hbar,+,-,[,]	for (int i=0; i < level; i++) {		s[i*width] = (lines&(1<<i)) ? Chars[1] : Chars[0];		for (int j=1; j<(width); j++) s[i*width+j] = Chars[0];	}	int p = level*width;	s[p] = (get_next_node(node)) ? Chars[2]: Chars[3];	if (has_children(node)) {		s[p+1] = Chars[7];		s[p+2] = (is_expanded(node)) ? Chars[6]: Chars[5];		s[p+3] = Chars[8];	} else {		s[p+1] = Chars[4];		s[p+2] = Chars[4];		s[p+3] = Chars[4];	}	s[p+4].codepage = CP_DEVICE;	s[p+4].chr = ' ';	p += 5;	char *text=get_text(node);	while (*text) {		s[p].codepage = CP_DEVICE;		s[p++].chr = *(text++);	}	s[p].codepage = CP_INVALID;	return p;}int	ht_treeview::count_children(void *node){	int i = 0;	if (!is_expanded(node)) return 0;	void *p = get_child(node, 1);	while (p) {		i+=count_children(p);		p = get_next_node(p);		i++;	}	return i;}void ht_treeview::collapse_all(void *node){	if (has_children(node)) {		adjust(node, false);		void *tmp = get_child(node, 1);		while (tmp) {			collapse_all(tmp);			tmp = get_next_node(tmp);		}	}}void ht_treeview::draw_r(void *node, int level, int *pos, uint32 lines){	vcp normal_color, sel_color, foc_color, color;	normal_color = getcolor(palidx_generic_list_unfocused_unselected);	foc_color = getcolor(palidx_generic_list_focused_selected);	sel_color = getcolor(palidx_generic_list_unfocused_selected);	AbstractChar s[1024];	while (node) {		if (*pos >= delta_y) {			if (*pos >= (delta_y+size.h)) break;			if (is_selected(*pos)) {				selected = node; // only for getdata()				if (focused) color=foc_color; else color=sel_color;				fill(0, *pos-delta_y, size.w, 1, color, ' ');			} else color = normal_color;			if (get_graph(s, node, level, lines) > delta_x)				buf->nprintW(0, *pos-delta_y, color, &s[delta_x], size.w);		}		(*pos)++;		if (has_children(node) && is_expanded(node)) {			draw_r(get_child(node, 1), level+1, pos, (get_next_node(node)) ? lines|(1<<level) : lines);		}		node = get_next_node(node);	}}void ht_treeview::draw(){	clear(getcolor(palidx_generic_list_unfocused_unselected));	int p = 0;	draw_r(get_root(), 0, &p, 0);}void ht_treeview::expand_all(void *node){	if (has_children(node)) {		adjust(node, true);		void *tmp = get_child(node, 1);		while (tmp) {			expand_all(tmp);			tmp = get_next_node(tmp);		}	}}/* *	stub */void ht_treeview::getdata(ObjectStream &s){	PUT_INT32D(s, (long)selected);}/* *	void *ht_treeview::get_child(void *node, int i) *	get i. child of node */int  ht_treeview::get_graph(AbstractChar *s, void *node, int level, int lines){	static const AbstractChar graph[10] = {		{CP_DEVICE, ' '},		{CP_GRAPHICAL, GC_1VLINE},		{CP_GRAPHICAL, GC_1RTEE},		{CP_GRAPHICAL, GC_1CORNER2},		{CP_GRAPHICAL, GC_1HLINE},		{CP_DEVICE, '+'},		{CP_DEVICE, '-'},		{CP_DEVICE, '['},		{CP_DEVICE, ']'},	};	return create_graph(s, node, level, lines, 5, 5, graph);}void *ht_treeview::get_node_r(void *node, int *i){	while ((node) && (--(*i))) {		if (has_children(node) && is_expanded(node)) {			void *tmp = get_node_r(get_child(node, 1), i);			if (!(*i)) return tmp;		}		node = get_next_node(node);	}	return node;}/* *   get i. node *	i==1 => 1. node */void *ht_treeview::get_node(int i){	if (i <= 0) return 0;	void *Node = get_root();	return get_node_r(Node, &i);}void	ht_treeview::handlemsg(htmsg *msg){	ht_view::handlemsg(msg);	if (msg->msg==msg_keypressed) {		int Foc = foc;		switch (msg->data1.integer) {		case K_Up:			Foc--;			break;		case K_Down:			Foc++;			break;		case K_Control_Right:			if (delta_x < maxsize_x-1) delta_x++;			break;		case K_Control_Left:			if (delta_x > 0) delta_x--;			break;		case K_PageUp:			Foc -= size.h-1;			break;		case K_PageDown:			Foc += size.h-1;			break;		case K_Control_PageUp:			Foc = 0;			break;		case K_Control_PageDown:			Foc = maxsize_y - 1;			break;		case '+':		case K_Right: {			void *p = get_node(Foc+1);			if (has_children(p)) adjust(p, true);			break;		}		case '-':			adjust(get_node(Foc+1), false);			break;		case K_Left: {			void *n = get_node(Foc+1);			if (is_expanded(n)) {				adjust(n, false);			} else {				if (Foc) {					do {						Foc-=count_children(n)+1;						n = get_prev_node(n);					} while (n);					adjust(get_node(Foc+1), false);				}			}			break;		}		case '*':			expand_all(get_node(Foc+1));			break;		case '/':			collapse_all(get_node(Foc+1));			break;		case K_Return: {			void *n = get_node(Foc+1);			if (has_children(n)) {				adjust(n, !is_expanded(n));			} else {				select_node(n);			}			break;		}		default:			return;		}		update();		adjust_focus(Foc);		dirtyview();		clearmsg(msg);	}}void	ht_treeview::has_focused(int i){	foc = i;}/* *	can be overwritten to handle mutiple selections */bool	ht_treeview::is_selected(int i){	return (foc == i);}void	ht_treeview::scroll_to(int x, int y){	delta_x = x;	delta_y = y;}/* *	stub */void ht_treeview::setdata(ObjectStream &s){}/* *	called whenever a node is being selected *	can be overwritten */void	ht_treeview::select_node(void *node){}void	ht_treeview::set_limit(int x, int y){	maxsize_x = x;	maxsize_y = y;}void	ht_treeview::update_r(void *node, int level, int *pos, int *x){	AbstractChar s[2048];	while (node) {		int l = get_graph(s, node, level, 0);		if (l > *x) *x = l;		(*pos)++;		if (has_children(node) && is_expanded(node)) {			update_r(get_child(node, 1), level+1, pos, x);		}		node = get_next_node(node);	}}/* *   must be called whenever the data of the tree has changed */void	ht_treeview::update(){	int count = 0, maxx = 0;	update_r(get_root(), 0, &count, &maxx);	set_limit(maxx, count);	adjust_focus(foc);}/****************************************************************************/void ht_static_treeview::init(Bounds *b, const char *desc){	ht_treeview::init(b, desc);	VIEW_DEBUG_NAME("ht_static_treeview");	root=0;}void ht_static_treeviewdone_r(static_node *node){	while (node) {		ht_static_treeviewdone_r(node->child);		free(node->text);		if (node->data) {			node->data->done();			delete node->data;		}		static_node *temp = node->next;		free(node);		node = temp;	}}void ht_static_treeview::done(){	ht_static_treeviewdone_r(root);	ht_treeview::done();}void *ht_static_treeview::add_child(void *node, const char *text, Object *Data){	if (node) {		return add_node(&((static_node *)node)->child, text, Data);	} else {		if (root) {			return add_node(&root, text, Data);		} else {			root=create_node(text, NULL, Data);			return root;		}	}}void	*ht_static_treeview::add_node(static_node **node, const char *text, Object *Data){	static_node **p = node;	static_node *prev = NULL;	if (*p) {		while (*p) {			prev = *p;			p = &(*p)->next;		}	}	*p=create_node(text, prev, Data);	return *p;}void	ht_static_treeview::adjust(void *node, bool expand){	((static_node *)node)->expanded = expand;}static_node *ht_static_treeview::create_node(const char *text, static_node *prev, Object *Data){	static_node *node = ht_malloc(sizeof(static_node));	node->text = ht_strdup(text);	node->next = NULL;	node->prev = prev;	node->child = NULL;	node->expanded = false;	node->data = Data;	return node;}void *ht_static_treeview::get_child(void *node, int i){	static_node *p;	if (node) {		p = ((static_node *)node)->child;	} else {		p = root;	}	while (p && (--i)) p = p->next;	return p;}void	*ht_static_treeview::get_next_node(void *node){	return ((static_node *)node)->next;}void	*ht_static_treeview::get_prev_node(void *node){	return ((static_node *)node)->prev;}void	*ht_static_treeview::get_root(){	return root;}char	*ht_static_treeview::get_text(void *node){	return ((static_node *)node)->text;}void	*ht_static_treeview::get_cursor_node(){// FIXME: said to be the wrong thing, works however	return selected;}void	ht_static_treeview::goto_node(void *node){}bool	ht_static_treeview::has_children(void *node){	return (((static_node *)node)->child);}bool	ht_static_treeview::is_expanded(void *node){	return (((static_node *)node)->expanded);}void	ht_static_treeview::select_node(void *node){}