/[zanavi_public1]/navit/navit/layout.c
ZANavi

Contents of /navit/navit/layout.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 2 - (hide annotations) (download)
Fri Oct 28 21:19:04 2011 UTC (11 years, 3 months ago) by zoff99
File MIME type: text/plain
File size: 12601 byte(s)
import files
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     }

   
Visit the ZANavi Wiki