]> mj.ucw.cz Git - leo.git/blob - style.c
Inline styles get better error reporting
[leo.git] / style.c
1 /*
2  *      Hic Est Leo -- Styling
3  *
4  *      (c) 2014 Martin Mares <mj@ucw.cz>
5  */
6
7 #include <ucw/lib.h>
8 #include <ucw/mempool.h>
9
10 #include <stdio.h>
11
12 #include "leo.h"
13 #include "osm.h"
14 #include "style.h"
15
16 struct dict style_prop_dict, style_layer_dict;
17
18 static const char * const style_wk_props[] = {
19   NULL,
20 #define P(x,y) [PROP_##x] = y,
21 #include "dict-props.h"
22 #undef P
23   NULL
24 };
25
26 static const char * const style_wk_layers[] = {
27   NULL,
28   "default",
29   NULL
30 };
31
32 void styles_init(void)
33 {
34   dict_init(&style_prop_dict, style_wk_props);
35   dict_init(&style_layer_dict, style_wk_layers);
36 }
37
38 #define HASH_NODE struct style_prop
39 #define HASH_PREFIX(x) style_prop_##x
40 #define HASH_KEY_ATOMIC key
41 #define HASH_WANT_FIND
42 #define HASH_WANT_LOOKUP
43 #define HASH_GIVE_ALLOC
44 // FIXME: Make <ucw/hashtable.h> accept our pool
45 #define HASH_ZERO_FILL
46 #define HASH_TABLE_DYNAMIC
47 #define HASH_TABLE_ALLOC
48 #define HASH_TABLE_VARS struct mempool *pool;
49 static void *style_prop_alloc(struct style_prop_table *table, uns size);
50 static inline void style_prop_free(struct style_prop_table *table UNUSED, void *x UNUSED) { }
51 #include <ucw/hashtable.h>
52
53 static void *style_prop_alloc(struct style_prop_table *table, uns size)
54 {
55   return mp_alloc_fast(table->pool, size);
56 }
57
58 void style_init(struct style_results *r)
59 {
60   r->pool = mp_new(4096);
61   r->num_layers = dict_size(&style_layer_dict);
62   r->layers = mp_alloc_zero(r->pool, r->num_layers * sizeof(struct style_info *));
63   r->num_active_layers = 0;
64   r->active_layers = mp_alloc_zero(r->pool, r->num_layers * sizeof(layer_t));
65 }
66
67 void style_cleanup(struct style_results *r)
68 {
69   mp_delete(r->pool);
70 }
71
72 void style_begin(struct style_results *r, struct osm_object *o)
73 {
74   ASSERT(!r->num_active_layers);
75   mp_push(r->pool);
76   r->obj = o;
77 }
78
79 void style_end(struct style_results *r)
80 {
81   for (uns i=0; i<r->num_active_layers; i++)
82     r->layers[r->active_layers[i]] = NULL;
83   r->layers[0] = NULL;
84   r->num_active_layers = 0;
85   mp_pop(r->pool);
86 }
87
88 static inline void style_assign(struct style_prop *dest, struct style_prop *src)
89 {
90   dest->type = src->type;
91   dest->val = src->val;
92 }
93
94 static struct style_info *style_get_info(struct style_results *r, layer_t layer)
95 {
96   ASSERT(layer < r->num_layers);
97   if (!r->layers[layer])
98     {
99       struct style_info *si = mp_alloc_zero(r->pool, sizeof(*si));
100       r->layers[layer] = si;
101       si->hash = mp_alloc_zero(r->pool, sizeof(struct style_prop_table));
102       si->hash->pool = r->pool;
103       style_prop_init(si->hash);
104
105       if (layer != STYLE_LAYER_ALL)
106         {
107           r->active_layers[r->num_active_layers++] = layer;
108
109           // Copy all properties which have been set for all layers
110           struct style_info *si_all = r->layers[STYLE_LAYER_ALL];
111           if (si_all)
112             {
113               /*
114                * CAVEAT: This is probably wrong. When no properties are set explicitly
115                * set for a layer, all-layer properties are not propagated. Hopefully harmless.
116                */
117               HASH_FOR_ALL_DYNAMIC(style_prop, si_all->hash, s)
118                 {
119                   style_assign(style_prop_lookup(si->hash, s->key), s);
120                 }
121               HASH_END_FOR;
122             }
123         }
124     }
125   return r->layers[layer];
126 }
127
128 void style_set_by_layer(struct style_results *r, layer_t layer, struct style_prop *p)
129 {
130   if (layer == STYLE_LAYER_ALL)
131     {
132       // Set in all existing layers
133       for (uns i=0; i < r->num_active_layers; i++)
134         style_assign(style_prop_lookup(r->layers[r->active_layers[i]]->hash, p->key), p);
135       // ... and let it propagate to STYLE_LAYER_ALL
136     }
137
138   struct style_info *si = style_get_info(r, layer);
139   style_assign(style_prop_lookup(si->hash, p->key), p);
140 }
141
142 void style_set(struct style_info *si, struct style_prop *p)
143 {
144   style_assign(style_prop_lookup(si->hash, p->key), p);
145 }
146
147 struct style_prop *style_get(struct style_info *si, prop_t key)
148 {
149   return style_prop_find(si->hash, key);
150 }
151
152 struct style_prop *style_get_and_check(struct style_info *si, prop_t key, uns allowed_types)
153 {
154   struct style_prop *p = style_prop_find(si->hash, key);
155   if (!p)
156     return NULL;
157   if (!(allowed_types & (1 << p->type)))
158     {
159       // XXX: Better diagnostics?
160       msg(L_WARN, "Style property %s set to invalid type #%u", style_prop_decode(p->key), p->type);
161       return NULL;
162     }
163   return p;
164 }
165
166 osm_val_t style_get_ident(struct style_info *si, prop_t key)
167 {
168   struct style_prop *p = style_get_and_check(si, key, 1 << PROP_TYPE_IDENT);
169   return p ? p->val.id : 0;
170 }
171
172 osm_val_t style_get_string(struct style_info *si, prop_t key)
173 {
174   struct style_prop *p = style_get_and_check(si, key, (1 << PROP_TYPE_STRING) | (1 << PROP_TYPE_IDENT));
175   return p ? p->val.id : 0;
176 }
177
178 bool style_get_number(struct style_info *si, prop_t key, double *dp)
179 {
180   struct style_prop *p = style_get_and_check(si, key, 1 << PROP_TYPE_NUMBER);
181   if (!p)
182     return 0;
183   *dp = p->val.number;
184   return 1;
185 }
186
187 bool style_get_color(struct style_info *si, prop_t key, color_t *colorp)
188 {
189   struct style_prop *p = style_get_and_check(si, key, 1 << PROP_TYPE_COLOR);
190   if (!p)
191     return 0;
192   *colorp = p->val.color;
193   return 1;
194 }
195
196 void style_dump(struct style_results *r)
197 {
198   for (uns i=0; i < r->num_active_layers; i++)
199     {
200       layer_t layer = r->active_layers[i];
201       printf("Layer %s (%u)\n", style_layer_decode(layer), layer);
202       struct style_info *si = r->layers[layer];
203       HASH_FOR_ALL_DYNAMIC(style_prop, si->hash, s)
204         {
205           printf("\t");
206           style_dump_prop(s);
207         }
208       HASH_END_FOR;
209     }
210 }
211
212 static void style_dump_val(struct style_prop *s)
213 {
214   uns cnt = 0;
215
216   switch (s->type)
217     {
218     case PROP_TYPE_STRING:
219       printf("%s [string]", osm_val_decode(s->val.id));
220       break;
221     case PROP_TYPE_IDENT:
222       printf("%s [ident]", osm_val_decode(s->val.id));
223       break;
224     case PROP_TYPE_NUMBER:
225       printf("%.6g [number]", s->val.number);
226       break;
227     case PROP_TYPE_COLOR:
228       printf("%06x [color]", s->val.color);
229       break;
230     case PROP_TYPE_LIST:
231       putchar('(');
232       CLIST_FOR_EACH(struct style_val_list_entry *, e, *s->val.list)
233         {
234           if (cnt++)
235             printf(", ");
236           style_dump_val(&e->val);
237         }
238       printf(") [list]");
239       break;
240     default:
241       printf("[unknown type %u]", s->type);
242     }
243 }
244
245 void style_dump_prop(struct style_prop *s)
246 {
247   printf("%s = ", style_prop_decode(s->key));
248   style_dump_val(s);
249   putchar('\n');
250 }
251
252 void style_scale(struct style_info *si, double *wp, double *hp, prop_t width_prop, prop_t height_prop)
253 {
254   double w, h;
255   bool got_width = style_get_number(si, width_prop, &w);
256   bool got_height = style_get_number(si, height_prop, &h);
257
258   if (got_width + got_height == 2)
259     {
260       *wp = w;
261       *hp = h;
262     }
263   else if (got_width + got_height == 1)
264     {
265       if (got_width)
266         {
267           *hp *= w / *wp;
268           *wp = w;
269         }
270       else
271         {
272           *wp *= h / *hp;
273           *hp = h;
274         }
275     }
276 }