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

Contents of /navit/navit/layout.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 2 - (show 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 /**
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