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 }