osm2go/src/josm_elemstyles.c

/*
 * Copyright (C) 2008 Till Harbaum <till@harbaum.org>.
 *
 * This file is part of OSM2Go.
 *
 * OSM2Go 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.
 *
 * OSM2Go 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 OSM2Go.  If not, see <http://www.gnu.org/licenses/>.
 */

#include "appdata.h"

#include <libxml/parser.h>
#include <libxml/tree.h>

#ifndef LIBXML_TREE_ENABLED
#error "Tree not enabled in libxml"
#endif

// ratio conversions

// Scaling constants. Our "zoom" is a screenpx:canvasunit ratio, and the figure
// given by an elemstyles.xml is the denominator of a screen:real ratio.

#define N810_PX_PER_METRE (800 / 0.09)
    // XXX should probably ask the windowing system for DPI and 
    // work from that instead

inline float scaledn_to_zoom(const float scaledn) {
  return N810_PX_PER_METRE / scaledn;
}

inline float zoom_to_scaledn(const float zoom) {
  return N810_PX_PER_METRE / zoom;
}


/* --------------------- elemstyles.xml parsing ----------------------- */

gboolean parse_color(xmlNode *a_node, char *name, 
                     elemstyle_color_t *color) {
  char *color_str = (char*)xmlGetProp(a_node, BAD_CAST name);
  if(color_str) {
    GdkColor gdk_color;
    if(gdk_color_parse(color_str, &gdk_color)) {
      *color = 
        ((gdk_color.red   << 8) & 0xff0000) |
        ((gdk_color.green     ) & 0xff00) |
        ((gdk_color.blue  >> 8) & 0xff);
      
      xmlFree(color_str);
      return TRUE;
    }
    xmlFree(color_str);
  }
  return FALSE;
}

static gboolean parse_gint(xmlNode *a_node, char *name, gint *val) {
  char *num_str = (char*)xmlGetProp(a_node, BAD_CAST name);
  if(num_str) {
    *val = strtoul(num_str, NULL, 10);
    xmlFree(num_str);
    return TRUE;
  }
  return FALSE;
}

static gboolean parse_scale_max(xmlNode *a_node, float *val) {
    xmlChar *val_str = xmlNodeGetContent(a_node);
    if (val_str) {
        *val = scaledn_to_zoom(strtod((char *)val_str, NULL));
        xmlFree(val_str);
        return TRUE;
    }
    return FALSE;
}

static elemstyle_line_t *parse_line(xmlDocPtr doc, xmlNode *a_node) {
  elemstyle_line_t *line = g_new0(elemstyle_line_t, 1);

  /* these have to be present */
  g_assert(parse_color(a_node, "colour", &line->color));
  g_assert(parse_gint(a_node, "width", &line->width));

  line->real.valid = 
    parse_gint(a_node, "realwidth", &line->real.width);

  line->bg.valid = 
    parse_gint(a_node, "width_bg", &line->bg.width) &&
    parse_color(a_node, "colour_bg", &line->bg.color);

  return line;
}

static elemstyle_area_t *parse_area(xmlDocPtr doc, xmlNode *a_node) {
  elemstyle_area_t *area = g_new0(elemstyle_area_t, 1);

  /* these have to be present */
  g_assert(parse_color(a_node, "colour", &area->color));
  return area;
}

static elemstyle_icon_t *parse_icon(xmlDocPtr doc, xmlNode *a_node) {
  elemstyle_icon_t *icon = g_new0(elemstyle_icon_t, 1);

  char *annotate = (char*)xmlGetProp(a_node, BAD_CAST "annotate");
  if(annotate) {
    icon->annotate = (strcasecmp(annotate, "true")==0);
    xmlFree(annotate);
  }

  icon->filename = (char*)xmlGetProp(a_node, BAD_CAST "src");
  g_assert(icon->filename);

  icon->filename = josm_icon_name_adjust(icon->filename);

  icon->zoom_max = 0;

  return icon;
}

static elemstyle_t *parse_rule(xmlDocPtr doc, xmlNode *a_node) {
  xmlNode *cur_node = NULL;
  elemstyle_t *elemstyle = g_new0(elemstyle_t, 1);

  for (cur_node = a_node->children; cur_node; cur_node = cur_node->next) {
    if (cur_node->type == XML_ELEMENT_NODE) {
      if(strcasecmp((char*)cur_node->name, "condition") == 0) {
        /* ------ parse condition ------ */
        elemstyle->condition.key   = (char*)xmlGetProp(cur_node, BAD_CAST "k");
        elemstyle->condition.value = (char*)xmlGetProp(cur_node, BAD_CAST "v");
      } else if(strcasecmp((char*)cur_node->name, "line") == 0) {
        /* ------ parse line ------ */
        g_assert(elemstyle->type == ES_TYPE_NONE);
        elemstyle->type = ES_TYPE_LINE;
        elemstyle->line = parse_line(doc, cur_node);
      } else if(strcasecmp((char*)cur_node->name, "area") == 0) { 
        /* ------ parse area ------ */
        g_assert(elemstyle->type == ES_TYPE_NONE);
        elemstyle->type = ES_TYPE_AREA;
        elemstyle->area = parse_area(doc, cur_node);
      } else if(strcasecmp((char*)cur_node->name, "icon") == 0) { 
        elemstyle->icon = parse_icon(doc, cur_node);
      } else if(strcasecmp((char*)cur_node->name, "scale_min") == 0) { 
        /* scale_min is currently ignored */
      } else if(strcasecmp((char*)cur_node->name, "scale_max") == 0) {
        switch (elemstyle->type) {
        case ES_TYPE_LINE:
          parse_scale_max(cur_node, &elemstyle->line->zoom_max);
          break;
        case ES_TYPE_AREA:
          parse_scale_max(cur_node, &elemstyle->area->zoom_max);
          break;
        default:
          if (elemstyle->icon) {
            parse_scale_max(cur_node, &elemstyle->icon->zoom_max);
          }
          else {
            printf("scale_max for unhandled elemstyletype=0x02%x\n", elemstyle->type);
          }
          break;
        }
      } else {
        printf("found unhandled rules/rule/%s\n", cur_node->name);
      }
    }
  }  

  return elemstyle;
}

static elemstyle_t *parse_rules(xmlDocPtr doc, xmlNode *a_node) {
  xmlNode *cur_node = NULL;
  elemstyle_t *elemstyles = NULL, **elemstyle = &elemstyles;

  for (cur_node = a_node->children; cur_node; cur_node = cur_node->next) {
    if (cur_node->type == XML_ELEMENT_NODE) {
      if(strcasecmp((char*)cur_node->name, "rule") == 0) {
        *elemstyle = parse_rule(doc, cur_node);
        if(*elemstyle) elemstyle = &((*elemstyle)->next);
      } else
        printf("found unhandled rules/%s\n", cur_node->name);
    }
  }  
  return elemstyles;
}

static elemstyle_t *parse_doc(xmlDocPtr doc) {
  /* Get the root element node */
  xmlNode *cur_node = NULL;
  elemstyle_t *elemstyles = NULL; 

  for(cur_node = xmlDocGetRootElement(doc); 
      cur_node; cur_node = cur_node->next) {
    if (cur_node->type == XML_ELEMENT_NODE) {
      if(strcasecmp((char*)cur_node->name, "rules") == 0) {
        elemstyles = parse_rules(doc, cur_node);
      } else 
        printf("found unhandled %s\n", cur_node->name);
    }
  }
    
  xmlFreeDoc(doc);
  xmlCleanupParser();
  return elemstyles;
}

elemstyle_t *josm_elemstyles_load(char *name) {
  elemstyle_t *elemstyles = NULL;

  printf("Loading JOSM elemstyles ...\n");

  char *filename = find_file(name);
  if(!filename) {
    printf("elemstyle file not found\n");
    return NULL;
  }
    
  LIBXML_TEST_VERSION;

  /* parse the file and get the DOM */
  xmlDoc *doc = NULL;
  if((doc = xmlReadFile(filename, NULL, 0)) == NULL) {
    xmlErrorPtr errP = xmlGetLastError();
    printf("elemstyles download failed: "
           "XML error while parsing:\n"
           "%s\n", errP->message);
  } else {
    printf("ok, parse doc tree\n");
    elemstyles = parse_doc(doc);
  }

  g_free(filename);
  return elemstyles;
}

/* ----------------------- cleaning up --------------------- */

static void free_line(elemstyle_line_t *line) {
  g_free(line);
}

static void free_area(elemstyle_area_t *area) {
  g_free(area);
}

static void free_icon(elemstyle_icon_t *icon) {
  if(icon->filename) xmlFree(icon->filename);
  g_free(icon);
}

static void elemstyle_free(elemstyle_t *elemstyle) {
  if(elemstyle->condition.key)   xmlFree(elemstyle->condition.key);
  if(elemstyle->condition.value) xmlFree(elemstyle->condition.value);

  switch(elemstyle->type) {
  case ES_TYPE_NONE:
    break;
  case ES_TYPE_LINE:
    free_line(elemstyle->line);
    break;
  case ES_TYPE_AREA:
    free_area(elemstyle->area);
    break;
  }
  if(elemstyle->icon) free_icon(elemstyle->icon);
  g_free(elemstyle);
}

void josm_elemstyles_free(elemstyle_t *elemstyles) {
  while(elemstyles) {
    elemstyle_t *next = elemstyles->next;
    elemstyle_free(elemstyles);
    elemstyles = next;
  }
}

#define WIDTH_SCALE (1.0)

void josm_elemstyles_colorize_node(style_t *style, node_t *node) {
  node->zoom_max = style->node.zoom_max;
  elemstyle_t *elemstyle = style->elemstyles;

  while(elemstyle) {
    gboolean match = FALSE;
    
    if(elemstyle->condition.key) {
      char *value = osm_node_get_value(node, elemstyle->condition.key);
      if(value) {
        if(elemstyle->condition.value) {
          if(strcasecmp(value, elemstyle->condition.value) == 0)
            match = TRUE;
        } else
          match = TRUE;
      }
    } else
      if(osm_node_has_value(node, elemstyle->condition.value)) 
        match = TRUE;
    

    if(match && elemstyle->icon) {
      char *name = g_strdup_printf("styles/%s/%s",
                   style->icon.path_prefix,
                                   elemstyle->icon->filename);

      /* free old icon if there's one present */
      if(node->icon_buf)
        icon_free(style->iconP, node->icon_buf);

      node->icon_buf = icon_load(style->iconP, name);
      g_free(name);

      if (elemstyle->icon->zoom_max > 0) {
        node->zoom_max = elemstyle->icon->zoom_max;
      }
    }
    
    elemstyle = elemstyle->next;
  }
}

void josm_elemstyles_colorize_way(style_t *style, way_t *way) {
  elemstyle_t *elemstyle = style->elemstyles;

  /* use dark grey/no stroke/not filled for everything unknown */
  way->draw.color = RGB2CANVAS(style->way.color);
  way->draw.width = style->way.width;
  way->draw.flags = 0;
  way->draw.zoom_max = 0;   // draw at all zoom levels

  gboolean way_is_closed = 
    (osm_way_get_last_node(way) == osm_way_get_first_node(way));

  while(elemstyle) {
    //  printf("a %s %s\n", elemstyle->condition.key, 
    //                        elemstyle->condition.value);

    gboolean match = FALSE;

    if(elemstyle->condition.key) {
      char *value = osm_way_get_value(way, elemstyle->condition.key);
      if(value) {
        if(elemstyle->condition.value) {
          if(strcasecmp(value, elemstyle->condition.value) == 0)
            match = TRUE;
        } else
          match = TRUE;
      }
    } else
      if(osm_way_has_value(way, elemstyle->condition.value)) 
        match = TRUE;

    if(match) {
      switch(elemstyle->type) {
      case ES_TYPE_NONE:
        /* this entry does not contain line or area descriptions and is */
        /* likely just an icon. ignore this as it doesn't make much sense */
        /* for a way */
        break;

      case ES_TYPE_LINE:
        way->draw.color = (elemstyle->line->color << 8) | 0xff;
        way->draw.width =  WIDTH_SCALE * elemstyle->line->width;
        if(elemstyle->line->bg.valid) {
          way->draw.flags |= OSM_DRAW_FLAG_BG;
          way->draw.bg.color = (elemstyle->line->bg.color << 8) | 0xff;
          way->draw.bg.width =  WIDTH_SCALE * elemstyle->line->bg.width;
        }
        if (elemstyle->line->zoom_max > 0) {
          way->draw.zoom_max = elemstyle->line->zoom_max;
        }
        else {
          way->draw.zoom_max = style->way.zoom_max;
        }
        return;
        break;

      case ES_TYPE_AREA:
        if(way_is_closed) {
          way->draw.flags |= OSM_DRAW_FLAG_AREA;
          /* comment the following line for grey border around all areas */
          /* (potlatch style) */

          if(style->area.has_border_color)
            way->draw.color =  (style->area.border_color << 8) | 0xff;
          else
            way->draw.color =  (elemstyle->area->color << 8) | 0xff;

          way->draw.width =  WIDTH_SCALE * style->area.border_width;
          way->draw.area.color = (elemstyle->area->color << 8) | 
                                style->area.opaque;
          if (elemstyle->area->zoom_max > 0) {
            way->draw.zoom_max = elemstyle->area->zoom_max;
          }
          else {
            way->draw.zoom_max = style->area.zoom_max;
          }
          return;
        }
        break;
      }
    }
    elemstyle = elemstyle->next;
  }
}

 void josm_elemstyles_colorize_world(style_t *styles, osm_t *osm) {

  printf("preparing colors\n");

  /* colorize ways */
  way_t *way = osm->way;
  while(way) {
    josm_elemstyles_colorize_way(styles, way);
    way = way->next;
  }

  /* icons */
  node_t *node = osm->node;
  while(node) {
    josm_elemstyles_colorize_node(styles, node);
    node = node->next;
  }
}
1	/*
2	* Copyright (C) 2008 Till Harbaum <till@harbaum.org>.
3	*
4	* This file is part of OSM2Go.
5	*
6	* OSM2Go is free software: you can redistribute it and/or modify
7	* it under the terms of the GNU General Public License as published by
8	* the Free Software Foundation, either version 3 of the License, or
9	* (at your option) any later version.
10	*
11	* OSM2Go is distributed in the hope that it will be useful,
12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14	* GNU General Public License for more details.
15	*
16	* You should have received a copy of the GNU General Public License
17	* along with OSM2Go. If not, see <http://www.gnu.org/licenses/>.
18	*/
19
20	#include "appdata.h"
21
22	#include <libxml/parser.h>
23	#include <libxml/tree.h>
24
25	#ifndef LIBXML_TREE_ENABLED
26	#error "Tree not enabled in libxml"
27	#endif
28
29	// ratio conversions
30
31	// Scaling constants. Our "zoom" is a screenpx:canvasunit ratio, and the figure
32	// given by an elemstyles.xml is the denominator of a screen:real ratio.
33
34	#define N810_PX_PER_METRE (800 / 0.09)
35	// XXX should probably ask the windowing system for DPI and
36	// work from that instead
37
38	inline float scaledn_to_zoom(const float scaledn) {
39	return N810_PX_PER_METRE / scaledn;
40	}
41
42	inline float zoom_to_scaledn(const float zoom) {
43	return N810_PX_PER_METRE / zoom;
44	}
45
46
47	/* --------------------- elemstyles.xml parsing ----------------------- */
48
49	gboolean parse_color(xmlNode a_node, char name,
50	elemstyle_color_t *color) {
51	char color_str = (char)xmlGetProp(a_node, BAD_CAST name);
52	if(color_str) {
53	GdkColor gdk_color;
54	if(gdk_color_parse(color_str, &gdk_color)) {
55	*color =
56	((gdk_color.red << 8) & 0xff0000) \|
57	((gdk_color.green ) & 0xff00) \|
58	((gdk_color.blue >> 8) & 0xff);
59
60	xmlFree(color_str);
61	return TRUE;
62	}
63	xmlFree(color_str);
64	}
65	return FALSE;
66	}
67
68	static gboolean parse_gint(xmlNode a_node, char name, gint *val) {
69	char num_str = (char)xmlGetProp(a_node, BAD_CAST name);
70	if(num_str) {
71	*val = strtoul(num_str, NULL, 10);
72	xmlFree(num_str);
73	return TRUE;
74	}
75	return FALSE;
76	}
77
78	static gboolean parse_scale_max(xmlNode a_node, float val) {
79	xmlChar *val_str = xmlNodeGetContent(a_node);
80	if (val_str) {
81	val = scaledn_to_zoom(strtod((char )val_str, NULL));
82	xmlFree(val_str);
83	return TRUE;
84	}
85	return FALSE;
86	}
87
88	static elemstyle_line_t parse_line(xmlDocPtr doc, xmlNode a_node) {
89	elemstyle_line_t *line = g_new0(elemstyle_line_t, 1);
90
91	/* these have to be present */
92	g_assert(parse_color(a_node, "colour", &line->color));
93	g_assert(parse_gint(a_node, "width", &line->width));
94
95	line->real.valid =
96	parse_gint(a_node, "realwidth", &line->real.width);
97
98	line->bg.valid =
99	parse_gint(a_node, "width_bg", &line->bg.width) &&
100	parse_color(a_node, "colour_bg", &line->bg.color);
101
102	return line;
103	}
104
105	static elemstyle_area_t parse_area(xmlDocPtr doc, xmlNode a_node) {
106	elemstyle_area_t *area = g_new0(elemstyle_area_t, 1);
107
108	/* these have to be present */
109	g_assert(parse_color(a_node, "colour", &area->color));
110	return area;
111	}
112
113	static elemstyle_icon_t parse_icon(xmlDocPtr doc, xmlNode a_node) {
114	elemstyle_icon_t *icon = g_new0(elemstyle_icon_t, 1);
115
116	char annotate = (char)xmlGetProp(a_node, BAD_CAST "annotate");
117	if(annotate) {
118	icon->annotate = (strcasecmp(annotate, "true")==0);
119	xmlFree(annotate);
120	}
121
122	icon->filename = (char*)xmlGetProp(a_node, BAD_CAST "src");
123	g_assert(icon->filename);
124
125	icon->filename = josm_icon_name_adjust(icon->filename);
126
127	icon->zoom_max = 0;
128
129	return icon;
130	}
131
132	static elemstyle_t parse_rule(xmlDocPtr doc, xmlNode a_node) {
133	xmlNode *cur_node = NULL;
134	elemstyle_t *elemstyle = g_new0(elemstyle_t, 1);
135
136	for (cur_node = a_node->children; cur_node; cur_node = cur_node->next) {
137	if (cur_node->type == XML_ELEMENT_NODE) {
138	if(strcasecmp((char*)cur_node->name, "condition") == 0) {
139	/* ------ parse condition ------ */
140	elemstyle->condition.key = (char*)xmlGetProp(cur_node, BAD_CAST "k");
141	elemstyle->condition.value = (char*)xmlGetProp(cur_node, BAD_CAST "v");
142	} else if(strcasecmp((char*)cur_node->name, "line") == 0) {
143	/* ------ parse line ------ */
144	g_assert(elemstyle->type == ES_TYPE_NONE);
145	elemstyle->type = ES_TYPE_LINE;
146	elemstyle->line = parse_line(doc, cur_node);
147	} else if(strcasecmp((char*)cur_node->name, "area") == 0) {
148	/* ------ parse area ------ */
149	g_assert(elemstyle->type == ES_TYPE_NONE);
150	elemstyle->type = ES_TYPE_AREA;
151	elemstyle->area = parse_area(doc, cur_node);
152	} else if(strcasecmp((char*)cur_node->name, "icon") == 0) {
153	elemstyle->icon = parse_icon(doc, cur_node);
154	} else if(strcasecmp((char*)cur_node->name, "scale_min") == 0) {
155	/* scale_min is currently ignored */
156	} else if(strcasecmp((char*)cur_node->name, "scale_max") == 0) {
157	switch (elemstyle->type) {
158	case ES_TYPE_LINE:
159	parse_scale_max(cur_node, &elemstyle->line->zoom_max);
160	break;
161	case ES_TYPE_AREA:
162	parse_scale_max(cur_node, &elemstyle->area->zoom_max);
163	break;
164	default:
165	if (elemstyle->icon) {
166	parse_scale_max(cur_node, &elemstyle->icon->zoom_max);
167	}
168	else {
169	printf("scale_max for unhandled elemstyletype=0x02%x\n", elemstyle->type);
170	}
171	break;
172	}
173	} else {
174	printf("found unhandled rules/rule/%s\n", cur_node->name);
175	}
176	}
177	}
178
179	return elemstyle;
180	}
181
182	static elemstyle_t parse_rules(xmlDocPtr doc, xmlNode a_node) {
183	xmlNode *cur_node = NULL;
184	elemstyle_t elemstyles = NULL, *elemstyle = &elemstyles;
185
186	for (cur_node = a_node->children; cur_node; cur_node = cur_node->next) {
187	if (cur_node->type == XML_ELEMENT_NODE) {
188	if(strcasecmp((char*)cur_node->name, "rule") == 0) {
189	*elemstyle = parse_rule(doc, cur_node);
190	if(elemstyle) elemstyle = &((elemstyle)->next);
191	} else
192	printf("found unhandled rules/%s\n", cur_node->name);
193	}
194	}
195	return elemstyles;
196	}
197
198	static elemstyle_t *parse_doc(xmlDocPtr doc) {
199	/* Get the root element node */
200	xmlNode *cur_node = NULL;
201	elemstyle_t *elemstyles = NULL;
202
203	for(cur_node = xmlDocGetRootElement(doc);
204	cur_node; cur_node = cur_node->next) {
205	if (cur_node->type == XML_ELEMENT_NODE) {
206	if(strcasecmp((char*)cur_node->name, "rules") == 0) {
207	elemstyles = parse_rules(doc, cur_node);
208	} else
209	printf("found unhandled %s\n", cur_node->name);
210	}
211	}
212
213	xmlFreeDoc(doc);
214	xmlCleanupParser();
215	return elemstyles;
216	}
217
218	elemstyle_t josm_elemstyles_load(char name) {
219	elemstyle_t *elemstyles = NULL;
220
221	printf("Loading JOSM elemstyles ...\n");
222
223	char *filename = find_file(name);
224	if(!filename) {
225	printf("elemstyle file not found\n");
226	return NULL;
227	}
228
229	LIBXML_TEST_VERSION;
230
231	/* parse the file and get the DOM */
232	xmlDoc *doc = NULL;
233	if((doc = xmlReadFile(filename, NULL, 0)) == NULL) {
234	xmlErrorPtr errP = xmlGetLastError();
235	printf("elemstyles download failed: "
236	"XML error while parsing:\n"
237	"%s\n", errP->message);
238	} else {
239	printf("ok, parse doc tree\n");
240	elemstyles = parse_doc(doc);
241	}
242
243	g_free(filename);
244	return elemstyles;
245	}
246
247	/* ----------------------- cleaning up --------------------- */
248
249	static void free_line(elemstyle_line_t *line) {
250	g_free(line);
251	}
252
253	static void free_area(elemstyle_area_t *area) {
254	g_free(area);
255	}
256
257	static void free_icon(elemstyle_icon_t *icon) {
258	if(icon->filename) xmlFree(icon->filename);
259	g_free(icon);
260	}
261
262	static void elemstyle_free(elemstyle_t *elemstyle) {
263	if(elemstyle->condition.key) xmlFree(elemstyle->condition.key);
264	if(elemstyle->condition.value) xmlFree(elemstyle->condition.value);
265
266	switch(elemstyle->type) {
267	case ES_TYPE_NONE:
268	break;
269	case ES_TYPE_LINE:
270	free_line(elemstyle->line);
271	break;
272	case ES_TYPE_AREA:
273	free_area(elemstyle->area);
274	break;
275	}
276	if(elemstyle->icon) free_icon(elemstyle->icon);
277	g_free(elemstyle);
278	}
279
280	void josm_elemstyles_free(elemstyle_t *elemstyles) {
281	while(elemstyles) {
282	elemstyle_t *next = elemstyles->next;
283	elemstyle_free(elemstyles);
284	elemstyles = next;
285	}
286	}
287
288	#define WIDTH_SCALE (1.0)
289
290	void josm_elemstyles_colorize_node(style_t style, node_t node) {
291	node->zoom_max = style->node.zoom_max;
292	elemstyle_t *elemstyle = style->elemstyles;
293
294	while(elemstyle) {
295	gboolean match = FALSE;
296
297	if(elemstyle->condition.key) {
298	char *value = osm_node_get_value(node, elemstyle->condition.key);
299	if(value) {
300	if(elemstyle->condition.value) {
301	if(strcasecmp(value, elemstyle->condition.value) == 0)
302	match = TRUE;
303	} else
304	match = TRUE;
305	}
306	} else
307	if(osm_node_has_value(node, elemstyle->condition.value))
308	match = TRUE;
309
310
311	if(match && elemstyle->icon) {
312	char *name = g_strdup_printf("styles/%s/%s",
313	style->icon.path_prefix,
314	elemstyle->icon->filename);
315
316	/* free old icon if there's one present */
317	if(node->icon_buf)
318	icon_free(style->iconP, node->icon_buf);
319
320	node->icon_buf = icon_load(style->iconP, name);
321	g_free(name);
322
323	if (elemstyle->icon->zoom_max > 0) {
324	node->zoom_max = elemstyle->icon->zoom_max;
325	}
326	}
327
328	elemstyle = elemstyle->next;
329	}
330	}
331
332	void josm_elemstyles_colorize_way(style_t style, way_t way) {
333	elemstyle_t *elemstyle = style->elemstyles;
334
335	/* use dark grey/no stroke/not filled for everything unknown */
336	way->draw.color = RGB2CANVAS(style->way.color);
337	way->draw.width = style->way.width;
338	way->draw.flags = 0;
339	way->draw.zoom_max = 0; // draw at all zoom levels
340
341	gboolean way_is_closed =
342	(osm_way_get_last_node(way) == osm_way_get_first_node(way));
343
344	while(elemstyle) {
345	// printf("a %s %s\n", elemstyle->condition.key,
346	// elemstyle->condition.value);
347
348	gboolean match = FALSE;
349
350	if(elemstyle->condition.key) {
351	char *value = osm_way_get_value(way, elemstyle->condition.key);
352	if(value) {
353	if(elemstyle->condition.value) {
354	if(strcasecmp(value, elemstyle->condition.value) == 0)
355	match = TRUE;
356	} else
357	match = TRUE;
358	}
359	} else
360	if(osm_way_has_value(way, elemstyle->condition.value))
361	match = TRUE;
362
363	if(match) {
364	switch(elemstyle->type) {
365	case ES_TYPE_NONE:
366	/* this entry does not contain line or area descriptions and is */
367	/* likely just an icon. ignore this as it doesn't make much sense */
368	/* for a way */
369	break;
370
371	case ES_TYPE_LINE:
372	way->draw.color = (elemstyle->line->color << 8) \| 0xff;
373	way->draw.width = WIDTH_SCALE * elemstyle->line->width;
374	if(elemstyle->line->bg.valid) {
375	way->draw.flags \|= OSM_DRAW_FLAG_BG;
376	way->draw.bg.color = (elemstyle->line->bg.color << 8) \| 0xff;
377	way->draw.bg.width = WIDTH_SCALE * elemstyle->line->bg.width;
378	}
379	if (elemstyle->line->zoom_max > 0) {
380	way->draw.zoom_max = elemstyle->line->zoom_max;
381	}
382	else {
383	way->draw.zoom_max = style->way.zoom_max;
384	}
385	return;
386	break;
387
388	case ES_TYPE_AREA:
389	if(way_is_closed) {
390	way->draw.flags \|= OSM_DRAW_FLAG_AREA;
391	/* comment the following line for grey border around all areas */
392	/* (potlatch style) */
393
394	if(style->area.has_border_color)
395	way->draw.color = (style->area.border_color << 8) \| 0xff;
396	else
397	way->draw.color = (elemstyle->area->color << 8) \| 0xff;
398
399	way->draw.width = WIDTH_SCALE * style->area.border_width;
400	way->draw.area.color = (elemstyle->area->color << 8) \|
401	style->area.opaque;
402	if (elemstyle->area->zoom_max > 0) {
403	way->draw.zoom_max = elemstyle->area->zoom_max;
404	}
405	else {
406	way->draw.zoom_max = style->area.zoom_max;
407	}
408	return;
409	}
410	break;
411	}
412	}
413	elemstyle = elemstyle->next;
414	}
415	}
416
417	void josm_elemstyles_colorize_world(style_t styles, osm_t osm) {
418
419	printf("preparing colors\n");
420
421	/* colorize ways */
422	way_t *way = osm->way;
423	while(way) {
424	josm_elemstyles_colorize_way(styles, way);
425	way = way->next;
426	}
427
428	/* icons */
429	node_t *node = osm->node;
430	while(node) {
431	josm_elemstyles_colorize_node(styles, node);
432	node = node->next;
433	}
434	}