src/edje_externals/elm_map.c

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