src/edje_externals/elm_map.c

   1 #include <assert.h>
   2
   3 #include "private.h"
   4
   5 typedef struct _Elm_Params_Map
   6 {
   7    Elm_Params base;
   8    const char *map_source;
   9    const char *zoom_mode;
  10    double zoom;
  11    Eina_Bool zoom_set:1;
  12 } Elm_Params_Map;
  13
  14 static const char *zoom_choices[] = {"manual",  "auto fit", "auto fill", NULL};
  15
  16 static const char *source_choices[] =
  17   {"Mapnik", "Osmarender", "Cycle Map", "Maplint",
  18    "Custom 1", "Custom 2", "Custom 3", "Custom 4",
  19    "Custom 5", "Custom 6", "Custom 7"};
  20
  21 static Elm_Map_Zoom_Mode
  22 _zoom_mode_get(const char *map_src)
  23 {
  24    unsigned int i;
  25
  26    assert(sizeof(zoom_choices)/sizeof(zoom_choices[0]) ==
  27           ELM_MAP_ZOOM_MODE_LAST + 1);
  28
  29    for (i = 0; i < sizeof(zoom_choices); i++)
  30      if (!strcmp(map_src, zoom_choices[i])) return i;
  31
  32    return ELM_MAP_ZOOM_MODE_LAST;
  33 }
  34
  35 static Elm_Map_Sources
  36 _map_source_get(const char *map_src)
  37 {
  38    unsigned int i;
  39
  40    assert(sizeof(source_choices)/sizeof(source_choices[0]) ==
  41           ELM_MAP_SOURCE_LAST);
  42
  43    for (i = 0; i < sizeof(source_choices); i++)
  44      if (!strcmp(map_src, source_choices[i])) return i;
  45
  46    return ELM_MAP_SOURCE_LAST;
  47 }
  48
  49 static void
  50 external_map_state_set(void *data __UNUSED__, Evas_Object *obj, const void *from_params, const void *to_params, float pos __UNUSED__)
  51 {
  52    const Elm_Params_Map *p;
  53
  54    if (to_params) p = to_params;
  55    else if (from_params) p = from_params;
  56    else return;
  57
  58    if (p->map_source)
  59      {
  60         Elm_Map_Sources set = _map_source_get(p->map_source);
  61         if (set == ELM_MAP_SOURCE_LAST) return;
  62         elm_map_source_set(obj, set);
  63      }
  64    if (p->zoom_mode)
  65      {
  66         Elm_Map_Zoom_Mode set = _zoom_mode_get(p->zoom_mode);
  67         if (set == ELM_MAP_ZOOM_MODE_LAST) return;
  68         elm_map_zoom_mode_set(obj, set);
  69      }
  70    if (p->zoom_set) elm_map_zoom_set(obj, p->zoom);
  71 }
  72
  73 static Eina_Bool
  74 external_map_param_set(void *data __UNUSED__, Evas_Object *obj, const Edje_External_Param *param)
  75 {
  76    if (!strcmp(param->name, "map source"))
  77      {
  78         if (param->type == EDJE_EXTERNAL_PARAM_TYPE_CHOICE)
  79           {
  80              Elm_Map_Sources set = _map_source_get(param->s);
  81              if (set == ELM_MAP_SOURCE_LAST) return EINA_FALSE;
  82              elm_map_source_set(obj, set);
  83              return EINA_TRUE;
  84           }
  85      }
  86    else if (!strcmp(param->name, "zoom mode"))
  87      {
  88         if (param->type == EDJE_EXTERNAL_PARAM_TYPE_CHOICE)
  89           {
  90              Elm_Map_Zoom_Mode set = _zoom_mode_get(param->s);
  91              if (set == ELM_MAP_ZOOM_MODE_LAST) return EINA_FALSE;
  92              elm_map_zoom_mode_set(obj, set);
  93              return EINA_TRUE;
  94           }
  95      }
  96    else if (!strcmp(param->name, "zoom level"))
  97      {
  98         if (param->type == EDJE_EXTERNAL_PARAM_TYPE_DOUBLE)
  99           {
 100              elm_map_zoom_set(obj, param->d);
 101              return EINA_TRUE;
 102           }
 103      }
 104
 105    ERR("unknown parameter '%s' of type '%s'",
 106        param->name, edje_external_param_type_str(param->type));
 107
 108    return EINA_FALSE;
 109 }
 110
 111 static Eina_Bool
 112 external_map_param_get(void *data __UNUSED__, const Evas_Object *obj, Edje_External_Param *param)
 113 {
 114    if (!strcmp(param->name, "map source"))
 115      {
 116         if (param->type == EDJE_EXTERNAL_PARAM_TYPE_CHOICE)
 117           {
 118              Elm_Map_Sources set = elm_map_source_get(obj);
 119              if (set == ELM_MAP_SOURCE_LAST) return EINA_FALSE;
 120              param->s = source_choices[set];
 121              return EINA_TRUE;
 122           }
 123      }
 124    else if (!strcmp(param->name, "zoom mode"))
 125      {
 126         if (param->type == EDJE_EXTERNAL_PARAM_TYPE_CHOICE)
 127           {
 128              Elm_Map_Zoom_Mode set = elm_map_zoom_mode_get(obj);
 129              if (set == ELM_MAP_ZOOM_MODE_LAST) return EINA_FALSE;
 130              param->s = zoom_choices[set];
 131              return EINA_TRUE;
 132           }
 133      }
 134    else if (!strcmp(param->name, "zoom level"))
 135      {
 136         if (param->type == EDJE_EXTERNAL_PARAM_TYPE_DOUBLE)
 137           {
 138              param->d = elm_map_zoom_get(obj);
 139              return EINA_TRUE;
 140           }
 141      }
 142
 143    ERR("unknown parameter '%s' of type '%s'",
 144        param->name, edje_external_param_type_str(param->type));
 145
 146    return EINA_FALSE;
 147 }
 148
 149 static void *
 150 external_map_params_parse(void *data __UNUSED__, Evas_Object *obj __UNUSED__, const Eina_List *params)
 151 {
 152    Elm_Params_Map *mem;
 153    Edje_External_Param *param;
 154    const Eina_List *l;
 155
 156    mem = calloc(1, sizeof(Elm_Params_Map));
 157    if (!mem)
 158      return NULL;
 159
 160    EINA_LIST_FOREACH(params, l, param)
 161      {
 162         if (!strcmp(param->name, "map source"))
 163           mem->map_source = eina_stringshare_add(param->s);
 164         if (!strcmp(param->name, "zoom mode"))
 165           mem->zoom_mode = eina_stringshare_add(param->s);
 166         else if (!strcmp(param->name, "zoom level"))
 167           {
 168              mem->zoom = param->d;
 169              mem->zoom_set = EINA_TRUE;
 170           }
 171      }
 172
 173    return mem;
 174 }
 175
 176 static Evas_Object *external_map_content_get(void *data __UNUSED__,
 177                 const Evas_Object *obj __UNUSED__, const char *content __UNUSED__)
 178 {
 179         ERR("No content.");
 180         return NULL;
 181 }
 182
 183 static void
 184 external_map_params_free(void *params)
 185 {
 186    Elm_Params_Map *mem = params;
 187
 188    if (mem->map_source)
 189      eina_stringshare_del(mem->map_source);
 190    if (mem->zoom_mode)
 191      eina_stringshare_del(mem->zoom_mode);
 192    free(mem);
 193 }
 194
 195 static Edje_External_Param_Info external_map_params[] =
 196   {
 197     DEFINE_EXTERNAL_COMMON_PARAMS,
 198     EDJE_EXTERNAL_PARAM_INFO_CHOICE_FULL("map source", "Mapnik",
 199                                          source_choices),
 200     EDJE_EXTERNAL_PARAM_INFO_CHOICE_FULL("zoom mode", "manual", zoom_choices),
 201     EDJE_EXTERNAL_PARAM_INFO_DOUBLE("zoom level"),
 202     EDJE_EXTERNAL_PARAM_INFO_SENTINEL
 203   };
 204
 205 DEFINE_EXTERNAL_ICON_ADD(map, "map")
 206 DEFINE_EXTERNAL_TYPE_SIMPLE(map, "Map")
 207