navit/navit/layout.c

/**
 * Navit, a modular navigation system.
 * Copyright (C) 2005-2009 Navit Team
 *
 * 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., 51 Franklin Street, Fifth Floor,
 * Boston, MA  02110-1301, USA.
 */

#include <glib.h>
#include <string.h>
#include "item.h"
#include "attr.h"
#include "layout.h"
#include "coord.h"
#include "debug.h"


struct layout * layout_new(struct attr *parent, struct attr **attrs)
{
        struct layout *l;
        struct color def_color = {COLOR_BACKGROUND_};
        struct attr *name_attr,*color_attr,*order_delta_attr,*font_attr,*day_attr,*night_attr,*active_attr;

        if (! (name_attr=attr_search(attrs, NULL, attr_name)))
                return NULL;
        l = g_new0(struct layout, 1);
        l->name = g_strdup(name_attr->u.str);
        if ((font_attr=attr_search(attrs, NULL, attr_font))) {
                l->font = g_strdup(font_attr->u.str);
        }
        if ((day_attr=attr_search(attrs, NULL, attr_daylayout))) {
                l->dayname = g_strdup(day_attr->u.str);
        }
        if ((night_attr=attr_search(attrs, NULL, attr_nightlayout))) {
                l->nightname = g_strdup(night_attr->u.str);
        }
        if ((color_attr=attr_search(attrs, NULL, attr_color)))
                l->color = *color_attr->u.color;
        else
                l->color = def_color;
        if ((order_delta_attr=attr_search(attrs, NULL, attr_order_delta)))
                l->order_delta=order_delta_attr->u.num;
        if ((active_attr=attr_search(attrs, NULL, attr_active)))
                l->active = active_attr->u.num;
        return l;
}

struct attr_iter {
        GList *last;
};


struct attr_iter *
layout_attr_iter_new(void)
{
        return g_new0(struct attr_iter, 1);
}

void
layout_attr_iter_destroy(struct attr_iter *iter)
{
        g_free(iter);
}

int
layout_get_attr(struct layout *layout, enum attr_type type, struct attr *attr, struct attr_iter *iter)
{
        GList *cursor,*layer;
        attr->type=type;
        switch (type) {
        case attr_cursor:
                cursor=layout->cursors;
                while (cursor) {
                        if (!iter || iter->last == g_list_previous(cursor)) {
                                attr->u.cursor=cursor->data;
                                if (iter)
                                        iter->last=cursor;
                                return 1;
                        }
                        cursor=g_list_next(cursor);
                }
                break;
        case attr_layer:
                layer=layout->layers;
                while (layer) {
                        if (!iter || iter->last == g_list_previous(layer)) {
                                attr->u.layer=layer->data;
                                if (iter)
                                        iter->last=layer;
                                return 1;
                        }
                        layer=g_list_next(layer);
                }
                break;
        case attr_active:
                attr->u.num=layout->active;
                break;
        default:
                break;
        }
        return 0;
}


int
layout_add_attr(struct layout *layout, struct attr *attr)
{
        switch (attr->type) {
        case attr_cursor:
                layout->cursors = g_list_append(layout->cursors, attr->u.cursor);
                return 1;
        case attr_layer:
                layout->layers = g_list_append(layout->layers, attr->u.layer);
                return 1;
        default:
                return 0;
        }
}

/**
 * Searchs the layout for a cursor with the given name.
 *
 * @param layout The layout
 * @param name The name
 * @returns A pointer to cursor with the given name or the name default or NULL.
 * @author Ralph Sennhauser (10/2009)
*/
struct cursor *
layout_get_cursor(struct layout *this_, char *name)
{
        GList *c;
        struct cursor *d=NULL;

        c=g_list_first(this_->cursors);
        while (c) {
                if (! strcmp(((struct cursor *)c->data)->name, name))
                        return c->data;
                if (! strcmp(((struct cursor *)c->data)->name, "default"))
                        d=c->data;
                c=g_list_next(c);
        }
        return d;
}


struct cursor *
cursor_new(struct attr *parent, struct attr **attrs)
{
        struct attr *w, *h, *name, *interval, *sequence_range;
        struct cursor *this;

        w=attr_search(attrs, NULL, attr_w);
        h=attr_search(attrs, NULL, attr_h);
        if (! w || ! h)
                return NULL;

        this=g_new0(struct cursor,1);
        this->w=w->u.num;
        this->h=h->u.num;
        name=attr_search(attrs, NULL, attr_name);
        if (name)
                this->name=g_strdup(name->u.str);
        else
                this->name=g_strdup("default");
        interval=attr_search(attrs, NULL, attr_interval);
        if (interval)
                this->interval=interval->u.num;
        sequence_range=attr_search(attrs, NULL, attr_sequence_range);
        if (sequence_range) {
                struct range *r=g_new0(struct range,1);
                r->min=sequence_range->u.range.min;
                r->max=sequence_range->u.range.max;
                this->sequence_range=r;
        }
        else {
                this->sequence_range=NULL;
        }
        dbg(2,"ret=%p\n", this);
        return this;
}

void
cursor_destroy(struct cursor *this_)
{
        if (this_->sequence_range)
                g_free(this_->sequence_range);
        if (this_->name) {
                g_free(this_->name);
        }
        g_free(this_);
}

int
cursor_add_attr(struct cursor *this_, struct attr *attr)
{
        switch (attr->type) {
        case attr_itemgra:
                this_->attrs=attr_generic_add_attr(this_->attrs, attr);
                return 1;
        default:
                break;
        }
        return 0;
}

static int
layer_set_attr_do(struct layer *l, struct attr *attr, int init)
{
        switch (attr->type) {
        case attr_active:
                l->active = attr->u.num;
                return 1;
        case attr_details:
                l->details = attr->u.num;
                return 1;
        case attr_name:
                g_free(l->name);
                l->name = g_strdup(attr->u.str);
                return 1;
        default:
                return 0;
        }
}


struct layer * layer_new(struct attr *parent, struct attr **attrs)
{
        struct layer *l;

        l = g_new0(struct layer, 1);
        l->active=1;
        for (;*attrs; attrs++) {
                layer_set_attr_do(l, *attrs, 1);
        }
        return l;
}

int
layer_get_attr(struct layer *layer, enum attr_type type, struct attr *attr, struct attr_iter *iter)
{
        attr->type=type;
        switch(type) {
        case attr_active:
                attr->u.num=layer->active;
                return 1;
        case attr_details:
                attr->u.num=layer->details;
                return 1;
        case attr_name:
                if (layer->name) {
                        attr->u.str=layer->name;
                        return 1;
                }
                break;
        default:
                return 0;
        }
        return 0;
}

int
layer_add_attr(struct layer *layer, struct attr *attr)
{
        switch (attr->type) {
        case attr_itemgra:
                layer->itemgras = g_list_append(layer->itemgras, attr->u.itemgra);
                return 1;
        default:
                return 0;
        }
}

int
layer_set_attr(struct layer *layer, struct attr *attr)
{
        return layer_set_attr_do(layer, attr, 0);
}

struct itemgra * itemgra_new(struct attr *parent, struct attr **attrs)
{
        struct itemgra *itm;
        struct attr *order, *item_types, *speed_range, *angle_range, *sequence_range;
        enum item_type *type;
        struct range defrange;
        
        itm = g_new0(struct itemgra, 1);
        order=attr_search(attrs, NULL, attr_order);
        item_types=attr_search(attrs, NULL, attr_item_types);
        speed_range=attr_search(attrs, NULL, attr_speed_range);
        angle_range=attr_search(attrs, NULL, attr_angle_range);
        sequence_range=attr_search(attrs, NULL, attr_sequence_range);
        defrange.min=0;
        defrange.max=32767;
        if (order) 
                itm->order=order->u.range;
        else 
                itm->order=defrange;
        if (speed_range) 
                itm->speed_range=speed_range->u.range;
        else 
                itm->speed_range=defrange;
        if (angle_range) 
                itm->angle_range=angle_range->u.range;
        else 
                itm->angle_range=defrange;
        if (sequence_range) 
                itm->sequence_range=sequence_range->u.range;
        else 
                itm->sequence_range=defrange;
        if (item_types) {
                type=item_types->u.item_types;
                while (type && *type != type_none) {
                        itm->type=g_list_append(itm->type, GINT_TO_POINTER(*type));
                        type++;
                }
        }
        return itm;
}
int
itemgra_add_attr(struct itemgra *itemgra, struct attr *attr)
{
        switch (attr->type) {
        case attr_polygon:
        case attr_polyline:
        case attr_circle:
        case attr_text:
        case attr_icon:
        case attr_image:
        case attr_arrows:
                itemgra->elements = g_list_append(itemgra->elements, attr->u.element);
                return 1;
        default:
                dbg(0,"unknown: %s\n", attr_to_name(attr->type));
                return 0;
        }
}

static void
element_set_color(struct element *e, struct attr **attrs)
{
        struct attr *color;
        color=attr_search(attrs, NULL, attr_color);
        if (color)
                e->color=*color->u.color;
}


static void
element_set_background_color(struct color *c, struct attr **attrs)
{
        struct attr *color;
        color=attr_search(attrs, NULL, attr_background_color);
        if (color)
                *c=*color->u.color;
}


static void
element_set_text_size(struct element *e, struct attr **attrs)
{
        struct attr *text_size;
        text_size=attr_search(attrs, NULL, attr_text_size);
        if (text_size)
                e->text_size=text_size->u.num;
}

static void
element_set_polyline_width(struct element *e, struct attr **attrs)
{
        struct attr *width;
        width=attr_search(attrs, NULL, attr_width);
        if (width)
                e->u.polyline.width=width->u.num;
}

static void
element_set_polyline_directed(struct element *e, struct attr **attrs)
{
        struct attr *directed;
        directed=attr_search(attrs, NULL, attr_directed);
        if (directed)
                e->u.polyline.directed=directed->u.num;
}

static void
element_set_polyline_dash(struct element *e, struct attr **attrs)
{
        struct attr *dash;
        int i;

        dash=attr_search(attrs, NULL, attr_dash);
        if (dash) {
                for (i=0; i<4; i++) {
                        if (!dash->u.dash[i])
                                break;
                        e->u.polyline.dash_table[i] = dash->u.dash[i];
                }
                e->u.polyline.dash_num=i;
        }
}

static void
element_set_polyline_offset(struct element *e, struct attr **attrs)
{
        struct attr *offset;
        offset=attr_search(attrs, NULL, attr_offset);
        if (offset)
                e->u.polyline.offset=offset->u.num;
}

static void
element_set_circle_width(struct element *e, struct attr **attrs)
{
        struct attr *width;
        width=attr_search(attrs, NULL, attr_width);
        if (width)
                e->u.circle.width=width->u.num;
}

static void
element_set_circle_radius(struct element *e, struct attr **attrs)
{
        struct attr *radius;
        radius=attr_search(attrs, NULL, attr_radius);
        if (radius)
                e->u.circle.radius=radius->u.num;
}

struct polygon *
polygon_new(struct attr *parent, struct attr **attrs)
{
        struct element *e;
        e = g_new0(struct element, 1);
        e->type=element_polygon;
        element_set_color(e, attrs);

        return (struct polygon *)e;
}

struct polyline *
polyline_new(struct attr *parent, struct attr **attrs)
{
        struct element *e;
        
        e = g_new0(struct element, 1);
        e->type=element_polyline;
        element_set_color(e, attrs);
        element_set_polyline_width(e, attrs);
        element_set_polyline_directed(e, attrs);
        element_set_polyline_dash(e, attrs);
        element_set_polyline_offset(e, attrs);
        return (struct polyline *)e;
}

struct circle *
circle_new(struct attr *parent, struct attr **attrs)
{
        struct element *e;
        struct color color_black = {COLOR_BLACK_};
        struct color color_white = {COLOR_WHITE_};

        e = g_new0(struct element, 1);
        e->type=element_circle;
        e->color = color_black;
        e->u.circle.background_color = color_white;
        element_set_color(e, attrs);
        element_set_background_color(&e->u.circle.background_color, attrs);
        element_set_text_size(e, attrs);
        element_set_circle_width(e, attrs);
        element_set_circle_radius(e, attrs);

        return (struct circle *)e;
}

struct text *
text_new(struct attr *parent, struct attr **attrs)
{
        struct element *e;
        struct color color_black = {COLOR_BLACK_};
        struct color color_white = {COLOR_WHITE_};
        
        e = g_new0(struct element, 1);
        e->type=element_text;
        element_set_text_size(e, attrs);
        e->color = color_black;
        e->u.text.background_color = color_white;
        element_set_color(e, attrs);
        element_set_background_color(&e->u.text.background_color, attrs);

        return (struct text *)e;
}

struct icon *
icon_new(struct attr *parent, struct attr **attrs)
{
        struct element *e;
        struct attr *src,*w,*h,*rotation;
        src=attr_search(attrs, NULL, attr_src);
        if (! src)
                return NULL;

        e = g_malloc0(sizeof(*e)+strlen(src->u.str)+1);
        e->type=element_icon;
        e->u.icon.src=(char *)(e+1);
        if ((w=attr_search(attrs, NULL, attr_w)))
                e->u.icon.width=w->u.num;
        else
                e->u.icon.width=-1;
        if ((h=attr_search(attrs, NULL, attr_h)))
                e->u.icon.height=h->u.num;
        else
                e->u.icon.height=-1;
        if ((rotation=attr_search(attrs, NULL, attr_rotation)))
                e->u.icon.rotation=rotation->u.num;
        strcpy(e->u.icon.src,src->u.str);

        return (struct icon *)e;        
}

struct image *
image_new(struct attr *parent, struct attr **attrs)
{
        struct element *e;

        e = g_malloc0(sizeof(*e));
        e->type=element_image;

        return (struct image *)e;       
}

struct arrows *
arrows_new(struct attr *parent, struct attr **attrs)
{
        struct element *e;
        e = g_malloc0(sizeof(*e));
        e->type=element_arrows;
        element_set_color(e, attrs);
        return (struct arrows *)e;      
}

int
element_add_attr(struct element *e, struct attr *attr)
{
        switch (attr->type) {
        case attr_coord:
                e->coord=g_realloc(e->coord,(e->coord_count+1)*sizeof(struct coord));
                e->coord[e->coord_count++]=*attr->u.coord;
                return 1;
        default:
                return 0;
        }
}
1	zoff99	2	/**
2			* Navit, a modular navigation system.
3			* Copyright (C) 2005-2009 Navit Team
4			*
5			* This program is free software; you can redistribute it and/or
6			* modify it under the terms of the GNU General Public License
7			* version 2 as published by the Free Software Foundation.
8			*
9			* This program is distributed in the hope that it will be useful,
10			* but WITHOUT ANY WARRANTY; without even the implied warranty of
11			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12			* GNU General Public License for more details.
13			*
14			* You should have received a copy of the GNU General Public License
15			* along with this program; if not, write to the
16			* Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
17			* Boston, MA 02110-1301, USA.
18			*/
19
20			#include <glib.h>
21			#include <string.h>
22			#include "item.h"
23			#include "attr.h"
24			#include "layout.h"
25			#include "coord.h"
26			#include "debug.h"
27
28
29			struct layout * layout_new(struct attr parent, struct attr *attrs)
30			{
31			struct layout *l;
32			struct color def_color = {COLOR_BACKGROUND_};
33			struct attr name_attr,color_attr,order_delta_attr,font_attr,day_attr,night_attr,*active_attr;
34
35			if (! (name_attr=attr_search(attrs, NULL, attr_name)))
36			return NULL;
37			l = g_new0(struct layout, 1);
38			l->name = g_strdup(name_attr->u.str);
39			if ((font_attr=attr_search(attrs, NULL, attr_font))) {
40			l->font = g_strdup(font_attr->u.str);
41			}
42			if ((day_attr=attr_search(attrs, NULL, attr_daylayout))) {
43			l->dayname = g_strdup(day_attr->u.str);
44			}
45			if ((night_attr=attr_search(attrs, NULL, attr_nightlayout))) {
46			l->nightname = g_strdup(night_attr->u.str);
47			}
48			if ((color_attr=attr_search(attrs, NULL, attr_color)))
49			l->color = *color_attr->u.color;
50			else
51			l->color = def_color;
52			if ((order_delta_attr=attr_search(attrs, NULL, attr_order_delta)))
53			l->order_delta=order_delta_attr->u.num;
54			if ((active_attr=attr_search(attrs, NULL, attr_active)))
55			l->active = active_attr->u.num;
56			return l;
57			}
58
59			struct attr_iter {
60			GList *last;
61			};
62
63
64			struct attr_iter *
65			layout_attr_iter_new(void)
66			{
67			return g_new0(struct attr_iter, 1);
68			}
69
70			void
71			layout_attr_iter_destroy(struct attr_iter *iter)
72			{
73			g_free(iter);
74			}
75
76			int
77			layout_get_attr(struct layout layout, enum attr_type type, struct attr attr, struct attr_iter *iter)
78			{
79			GList cursor,layer;
80			attr->type=type;
81			switch (type) {
82			case attr_cursor:
83			cursor=layout->cursors;
84			while (cursor) {
85			if (!iter \|\| iter->last == g_list_previous(cursor)) {
86			attr->u.cursor=cursor->data;
87			if (iter)
88			iter->last=cursor;
89			return 1;
90			}
91			cursor=g_list_next(cursor);
92			}
93			break;
94			case attr_layer:
95			layer=layout->layers;
96			while (layer) {
97			if (!iter \|\| iter->last == g_list_previous(layer)) {
98			attr->u.layer=layer->data;
99			if (iter)
100			iter->last=layer;
101			return 1;
102			}
103			layer=g_list_next(layer);
104			}
105			break;
106			case attr_active:
107			attr->u.num=layout->active;
108			break;
109			default:
110			break;
111			}
112			return 0;
113			}
114
115
116			int
117			layout_add_attr(struct layout layout, struct attr attr)
118			{
119			switch (attr->type) {
120			case attr_cursor:
121			layout->cursors = g_list_append(layout->cursors, attr->u.cursor);
122			return 1;
123			case attr_layer:
124			layout->layers = g_list_append(layout->layers, attr->u.layer);
125			return 1;
126			default:
127			return 0;
128			}
129			}
130
131			/**
132			* Searchs the layout for a cursor with the given name.
133			*
134			* @param layout The layout
135			* @param name The name
136			* @returns A pointer to cursor with the given name or the name default or NULL.
137			* @author Ralph Sennhauser (10/2009)
138			*/
139			struct cursor *
140			layout_get_cursor(struct layout this_, char name)
141			{
142			GList *c;
143			struct cursor *d=NULL;
144
145			c=g_list_first(this_->cursors);
146			while (c) {
147			if (! strcmp(((struct cursor *)c->data)->name, name))
148			return c->data;
149			if (! strcmp(((struct cursor *)c->data)->name, "default"))
150			d=c->data;
151			c=g_list_next(c);
152			}
153			return d;
154			}
155
156
157
158			struct cursor *
159			cursor_new(struct attr parent, struct attr *attrs)
160			{
161			struct attr w, h, name, interval, *sequence_range;
162			struct cursor *this;
163
164			w=attr_search(attrs, NULL, attr_w);
165			h=attr_search(attrs, NULL, attr_h);
166			if (! w \|\| ! h)
167			return NULL;
168
169			this=g_new0(struct cursor,1);
170			this->w=w->u.num;
171			this->h=h->u.num;
172			name=attr_search(attrs, NULL, attr_name);
173			if (name)
174			this->name=g_strdup(name->u.str);
175			else
176			this->name=g_strdup("default");
177			interval=attr_search(attrs, NULL, attr_interval);
178			if (interval)
179			this->interval=interval->u.num;
180			sequence_range=attr_search(attrs, NULL, attr_sequence_range);
181			if (sequence_range) {
182			struct range *r=g_new0(struct range,1);
183			r->min=sequence_range->u.range.min;
184			r->max=sequence_range->u.range.max;
185			this->sequence_range=r;
186			}
187			else {
188			this->sequence_range=NULL;
189			}
190			dbg(2,"ret=%p\n", this);
191			return this;
192			}
193
194			void
195			cursor_destroy(struct cursor *this_)
196			{
197			if (this_->sequence_range)
198			g_free(this_->sequence_range);
199			if (this_->name) {
200			g_free(this_->name);
201			}
202			g_free(this_);
203			}
204
205			int
206			cursor_add_attr(struct cursor this_, struct attr attr)
207			{
208			switch (attr->type) {
209			case attr_itemgra:
210			this_->attrs=attr_generic_add_attr(this_->attrs, attr);
211			return 1;
212			default:
213			break;
214			}
215			return 0;
216			}
217
218			static int
219			layer_set_attr_do(struct layer l, struct attr attr, int init)
220			{
221			switch (attr->type) {
222			case attr_active:
223			l->active = attr->u.num;
224			return 1;
225			case attr_details:
226			l->details = attr->u.num;
227			return 1;
228			case attr_name:
229			g_free(l->name);
230			l->name = g_strdup(attr->u.str);
231			return 1;
232			default:
233			return 0;
234			}
235			}
236
237
238
239			struct layer * layer_new(struct attr parent, struct attr *attrs)
240			{
241			struct layer *l;
242
243			l = g_new0(struct layer, 1);
244			l->active=1;
245			for (;*attrs; attrs++) {
246			layer_set_attr_do(l, *attrs, 1);
247			}
248			return l;
249			}
250
251			int
252			layer_get_attr(struct layer layer, enum attr_type type, struct attr attr, struct attr_iter *iter)
253			{
254			attr->type=type;
255			switch(type) {
256			case attr_active:
257			attr->u.num=layer->active;
258			return 1;
259			case attr_details:
260			attr->u.num=layer->details;
261			return 1;
262			case attr_name:
263			if (layer->name) {
264			attr->u.str=layer->name;
265			return 1;
266			}
267			break;
268			default:
269			return 0;
270			}
271			return 0;
272			}
273
274			int
275			layer_add_attr(struct layer layer, struct attr attr)
276			{
277			switch (attr->type) {
278			case attr_itemgra:
279			layer->itemgras = g_list_append(layer->itemgras, attr->u.itemgra);
280			return 1;
281			default:
282			return 0;
283			}
284			}
285
286			int
287			layer_set_attr(struct layer layer, struct attr attr)
288			{
289			return layer_set_attr_do(layer, attr, 0);
290			}
291
292			struct itemgra * itemgra_new(struct attr parent, struct attr *attrs)
293			{
294			struct itemgra *itm;
295			struct attr order, item_types, speed_range, angle_range, *sequence_range;
296			enum item_type *type;
297			struct range defrange;
298
299			itm = g_new0(struct itemgra, 1);
300			order=attr_search(attrs, NULL, attr_order);
301			item_types=attr_search(attrs, NULL, attr_item_types);
302			speed_range=attr_search(attrs, NULL, attr_speed_range);
303			angle_range=attr_search(attrs, NULL, attr_angle_range);
304			sequence_range=attr_search(attrs, NULL, attr_sequence_range);
305			defrange.min=0;
306			defrange.max=32767;
307			if (order)
308			itm->order=order->u.range;
309			else
310			itm->order=defrange;
311			if (speed_range)
312			itm->speed_range=speed_range->u.range;
313			else
314			itm->speed_range=defrange;
315			if (angle_range)
316			itm->angle_range=angle_range->u.range;
317			else
318			itm->angle_range=defrange;
319			if (sequence_range)
320			itm->sequence_range=sequence_range->u.range;
321			else
322			itm->sequence_range=defrange;
323			if (item_types) {
324			type=item_types->u.item_types;
325			while (type && *type != type_none) {
326			itm->type=g_list_append(itm->type, GINT_TO_POINTER(*type));
327			type++;
328			}
329			}
330			return itm;
331			}
332			int
333			itemgra_add_attr(struct itemgra itemgra, struct attr attr)
334			{
335			switch (attr->type) {
336			case attr_polygon:
337			case attr_polyline:
338			case attr_circle:
339			case attr_text:
340			case attr_icon:
341			case attr_image:
342			case attr_arrows:
343			itemgra->elements = g_list_append(itemgra->elements, attr->u.element);
344			return 1;
345			default:
346			dbg(0,"unknown: %s\n", attr_to_name(attr->type));
347			return 0;
348			}
349			}
350
351			static void
352			element_set_color(struct element e, struct attr *attrs)
353			{
354			struct attr *color;
355			color=attr_search(attrs, NULL, attr_color);
356			if (color)
357			e->color=*color->u.color;
358			}
359
360
361			static void
362			element_set_background_color(struct color c, struct attr *attrs)
363			{
364			struct attr *color;
365			color=attr_search(attrs, NULL, attr_background_color);
366			if (color)
367			c=color->u.color;
368			}
369
370
371			static void
372			element_set_text_size(struct element e, struct attr *attrs)
373			{
374			struct attr *text_size;
375			text_size=attr_search(attrs, NULL, attr_text_size);
376			if (text_size)
377			e->text_size=text_size->u.num;
378			}
379
380			static void
381			element_set_polyline_width(struct element e, struct attr *attrs)
382			{
383			struct attr *width;
384			width=attr_search(attrs, NULL, attr_width);
385			if (width)
386			e->u.polyline.width=width->u.num;
387			}
388
389			static void
390			element_set_polyline_directed(struct element e, struct attr *attrs)
391			{
392			struct attr *directed;
393			directed=attr_search(attrs, NULL, attr_directed);
394			if (directed)
395			e->u.polyline.directed=directed->u.num;
396			}
397
398			static void
399			element_set_polyline_dash(struct element e, struct attr *attrs)
400			{
401			struct attr *dash;
402			int i;
403
404			dash=attr_search(attrs, NULL, attr_dash);
405			if (dash) {
406			for (i=0; i<4; i++) {
407			if (!dash->u.dash[i])
408			break;
409			e->u.polyline.dash_table[i] = dash->u.dash[i];
410			}
411			e->u.polyline.dash_num=i;
412			}
413			}
414
415			static void
416			element_set_polyline_offset(struct element e, struct attr *attrs)
417			{
418			struct attr *offset;
419			offset=attr_search(attrs, NULL, attr_offset);
420			if (offset)
421			e->u.polyline.offset=offset->u.num;
422			}
423
424			static void
425			element_set_circle_width(struct element e, struct attr *attrs)
426			{
427			struct attr *width;
428			width=attr_search(attrs, NULL, attr_width);
429			if (width)
430			e->u.circle.width=width->u.num;
431			}
432
433			static void
434			element_set_circle_radius(struct element e, struct attr *attrs)
435			{
436			struct attr *radius;
437			radius=attr_search(attrs, NULL, attr_radius);
438			if (radius)
439			e->u.circle.radius=radius->u.num;
440			}
441
442			struct polygon *
443			polygon_new(struct attr parent, struct attr *attrs)
444			{
445			struct element *e;
446			e = g_new0(struct element, 1);
447			e->type=element_polygon;
448			element_set_color(e, attrs);
449
450			return (struct polygon *)e;
451			}
452
453			struct polyline *
454			polyline_new(struct attr parent, struct attr *attrs)
455			{
456			struct element *e;
457
458			e = g_new0(struct element, 1);
459			e->type=element_polyline;
460			element_set_color(e, attrs);
461			element_set_polyline_width(e, attrs);
462			element_set_polyline_directed(e, attrs);
463			element_set_polyline_dash(e, attrs);
464			element_set_polyline_offset(e, attrs);
465			return (struct polyline *)e;
466			}
467
468			struct circle *
469			circle_new(struct attr parent, struct attr *attrs)
470			{
471			struct element *e;
472			struct color color_black = {COLOR_BLACK_};
473			struct color color_white = {COLOR_WHITE_};
474
475			e = g_new0(struct element, 1);
476			e->type=element_circle;
477			e->color = color_black;
478			e->u.circle.background_color = color_white;
479			element_set_color(e, attrs);
480			element_set_background_color(&e->u.circle.background_color, attrs);
481			element_set_text_size(e, attrs);
482			element_set_circle_width(e, attrs);
483			element_set_circle_radius(e, attrs);
484
485			return (struct circle *)e;
486			}
487
488			struct text *
489			text_new(struct attr parent, struct attr *attrs)
490			{
491			struct element *e;
492			struct color color_black = {COLOR_BLACK_};
493			struct color color_white = {COLOR_WHITE_};
494
495			e = g_new0(struct element, 1);
496			e->type=element_text;
497			element_set_text_size(e, attrs);
498			e->color = color_black;
499			e->u.text.background_color = color_white;
500			element_set_color(e, attrs);
501			element_set_background_color(&e->u.text.background_color, attrs);
502
503			return (struct text *)e;
504			}
505
506			struct icon *
507			icon_new(struct attr parent, struct attr *attrs)
508			{
509			struct element *e;
510			struct attr src,w,h,rotation;
511			src=attr_search(attrs, NULL, attr_src);
512			if (! src)
513			return NULL;
514
515			e = g_malloc0(sizeof(*e)+strlen(src->u.str)+1);
516			e->type=element_icon;
517			e->u.icon.src=(char *)(e+1);
518			if ((w=attr_search(attrs, NULL, attr_w)))
519			e->u.icon.width=w->u.num;
520			else
521			e->u.icon.width=-1;
522			if ((h=attr_search(attrs, NULL, attr_h)))
523			e->u.icon.height=h->u.num;
524			else
525			e->u.icon.height=-1;
526			if ((rotation=attr_search(attrs, NULL, attr_rotation)))
527			e->u.icon.rotation=rotation->u.num;
528			strcpy(e->u.icon.src,src->u.str);
529
530			return (struct icon *)e;
531			}
532
533			struct image *
534			image_new(struct attr parent, struct attr *attrs)
535			{
536			struct element *e;
537
538			e = g_malloc0(sizeof(*e));
539			e->type=element_image;
540
541			return (struct image *)e;
542			}
543
544			struct arrows *
545			arrows_new(struct attr parent, struct attr *attrs)
546			{
547			struct element *e;
548			e = g_malloc0(sizeof(*e));
549			e->type=element_arrows;
550			element_set_color(e, attrs);
551			return (struct arrows *)e;
552			}
553
554			int
555			element_add_attr(struct element e, struct attr attr)
556			{
557			switch (attr->type) {
558			case attr_coord:
559			e->coord=g_realloc(e->coord,(e->coord_count+1)*sizeof(struct coord));
560			e->coord[e->coord_count++]=*attr->u.coord;
561			return 1;
562			default:
563			return 0;
564			}
565			}