src/lib/elm_map.c

   1 #include <Elementary.h>
   2 #include "elm_priv.h"
   3 #include "elm_widget_map.h"
   4
   5 EAPI const char ELM_MAP_SMART_NAME[] = "elm_map";
   6 EAPI const char ELM_MAP_PAN_SMART_NAME[] = "elm_map_pan";
   7
   8 #define INTERNAL_ENGINE_NAME    "Elm_Map_Tile"
   9 #define OVERLAY_CLASS_ZOOM_MAX  255
  10 #define MAX_CONCURRENT_DOWNLOAD 10
  11
  12 #define ROUND(z) (((z) < 0) ? (int)ceil((z) - 0.005) : (int)floor((z) + 0.005))
  13 #define EVAS_MAP_POINT         4
  14 #define DEFAULT_TILE_SIZE      256
  15 #define MARER_MAX_NUMBER       30
  16 #define OVERLAY_GROUPING_SCALE 2
  17
  18 #define CACHE_ROOT             "/elm_map"
  19 #define CACHE_TILE_ROOT        CACHE_ROOT "/%d/%d/%d"
  20 #define CACHE_TILE_PATH        "%s/%d.png"
  21 #define CACHE_ROUTE_ROOT       CACHE_ROOT "/route"
  22 #define CACHE_NAME_ROOT        CACHE_ROOT "/name"
  23
  24 #define ROUTE_YOURS_URL        "http://www.yournavigation.org/api/dev/route.php"
  25 #define ROUTE_TYPE_MOTORCAR    "motocar"
  26 #define ROUTE_TYPE_BICYCLE     "bicycle"
  27 #define ROUTE_TYPE_FOOT        "foot"
  28 #define YOURS_DISTANCE         "distance"
  29 #define YOURS_DESCRIPTION      "description"
  30 #define YOURS_COORDINATES      "coordinates"
  31
  32 #define NAME_NOMINATIM_URL     "http://nominatim.openstreetmap.org"
  33 #define NOMINATIM_RESULT       "result"
  34 #define NOMINATIM_PLACE        "place"
  35 #define NOMINATIM_ATTR_LON     "lon"
  36 #define NOMINATIM_ATTR_LAT     "lat"
  37 #define NOMINATIM_ATTR_ADDRESS "display_name"
  38
  39 #ifdef HAVE_ELEMENTARY_ECORE_CON
  40
  41 static void _overlay_place(Elm_Map_Smart_Data *sd);
  42
  43 static char *
  44 _mapnik_url_cb(const Evas_Object *obj __UNUSED__,
  45                int x,
  46                int y,
  47                int zoom)
  48 {
  49    char buf[PATH_MAX];
  50
  51    // ((x+y+zoom)%3)+'a' is requesting map images from distributed
  52    // tile servers (eg., a, b, c)
  53    snprintf(buf, sizeof(buf), "http://%c.tile.openstreetmap.org/%d/%d/%d.png",
  54             ((x + y + zoom) % 3) + 'a', zoom, x, y);
  55    return strdup(buf);
  56 }
  57
  58 static char *
  59 _osmarender_url_cb(const Evas_Object *obj __UNUSED__,
  60                    int x,
  61                    int y,
  62                    int zoom)
  63 {
  64    char buf[PATH_MAX];
  65
  66    snprintf(buf, sizeof(buf),
  67             "http://%c.tah.openstreetmap.org/Tiles/tile/%d/%d/%d.png",
  68             ((x + y + zoom) % 3) + 'a', zoom, x, y);
  69
  70    return strdup(buf);
  71 }
  72
  73 static char *
  74 _cyclemap_url_cb(const Evas_Object *obj __UNUSED__,
  75                  int x,
  76                  int y,
  77                  int zoom)
  78 {
  79    char buf[PATH_MAX];
  80
  81    snprintf(buf, sizeof(buf),
  82             "http://%c.tile.opencyclemap.org/cycle/%d/%d/%d.png",
  83             ((x + y + zoom) % 3) + 'a', zoom, x, y);
  84
  85    return strdup(buf);
  86 }
  87
  88 static char *
  89 _mapquest_url_cb(const Evas_Object *obj __UNUSED__,
  90                  int x,
  91                  int y,
  92                  int zoom)
  93 {
  94    char buf[PATH_MAX];
  95
  96    snprintf(buf, sizeof(buf),
  97             "http://otile%d.mqcdn.com/tiles/1.0.0/osm/%d/%d/%d.png",
  98             ((x + y + zoom) % 4) + 1, zoom, x, y);
  99
 100    return strdup(buf);
 101 }
 102
 103 static char *
 104 _mapquest_aerial_url_cb(const Evas_Object *obj __UNUSED__,
 105                         int x,
 106                         int y,
 107                         int zoom)
 108 {
 109    char buf[PATH_MAX];
 110
 111    snprintf(buf, sizeof(buf), "http://oatile%d.mqcdn.com/naip/%d/%d/%d.png",
 112             ((x + y + zoom) % 4) + 1, zoom, x, y);
 113
 114    return strdup(buf);
 115 }
 116
 117 static char *
 118 _yours_url_cb(const Evas_Object *obj __UNUSED__,
 119               const char *type_name,
 120               int method,
 121               double flon,
 122               double flat,
 123               double tlon,
 124               double tlat)
 125 {
 126    char buf[PATH_MAX];
 127
 128    snprintf
 129      (buf, sizeof(buf),
 130      "%s?flat=%lf&flon=%lf&tlat=%lf&tlon=%lf&v=%s&fast=%d&instructions=1",
 131      ROUTE_YOURS_URL, flat, flon, tlat, tlon, type_name, method);
 132
 133    return strdup(buf);
 134 }
 135
 136 // TODO: fix monav api
 137 /*
 138    static char *
 139    _monav_url_cb(const Evas_Object *obj __UNUSED__,
 140               char *type_name,
 141               int method,
 142               double flon,
 143               double flat,
 144               double tlon,
 145               double tlat)
 146    {
 147    char buf[PATH_MAX];
 148
 149    snprintf(buf, sizeof(buf),
 150             "%s?flat=%f&flon=%f&tlat=%f&tlon=%f&v=%s&fast=%d&instructions=1",
 151             ROUTE_MONAV_URL, flat, flon, tlat, tlon, type_name, method);
 152
 153    return strdup(buf);
 154    }
 155
 156    //TODO: fix ors api
 157
 158    static char *
 159    _ors_url_cb(const Evas_Object *obj __UNUSED__,
 160             char *type_name,
 161             int method,
 162             double flon,
 163             double flat,
 164             double tlon,
 165             double tlat)
 166    {
 167    char buf[PATH_MAX];
 168
 169    snprintf(buf, sizeof(buf),
 170             "%s?flat=%f&flon=%f&tlat=%f&tlon=%f&v=%s&fast=%d&instructions=1",
 171             ROUTE_ORS_URL, flat, flon, tlat, tlon, type_name, method);
 172
 173    return strdup(buf);
 174    }
 175  */
 176
 177 static char *
 178 _nominatim_url_cb(const Evas_Object *obj,
 179                   int method,
 180                   const char *name,
 181                   double lon,
 182                   double lat)
 183 {
 184    char **str;
 185    char buf[PATH_MAX];
 186    unsigned int ele, idx;
 187    char search_url[PATH_MAX];
 188
 189    ELM_MAP_DATA_GET(obj, sd);
 190
 191    if (method == ELM_MAP_NAME_METHOD_SEARCH)
 192      {
 193         search_url[0] = '\0';
 194         str = eina_str_split_full(name, " ", 0, &ele);
 195         for (idx = 0; idx < ele; idx++)
 196           {
 197              eina_strlcat(search_url, str[idx], sizeof(search_url));
 198              if (!(idx == (ele - 1)))
 199                eina_strlcat(search_url, "+", sizeof(search_url));
 200           }
 201         snprintf(buf, sizeof(buf),
 202                  "%s/search?q=%s&format=xml&polygon=0&addressdetails=0",
 203                  NAME_NOMINATIM_URL, search_url);
 204
 205         if (str)
 206           {
 207              if (str[0]) free(str[0]);
 208              free(str);
 209           }
 210      }
 211    else if (method == ELM_MAP_NAME_METHOD_REVERSE)
 212      snprintf(buf, sizeof(buf),
 213               "%s/reverse?format=xml&lat=%lf&lon=%lf&zoom=%d&addressdetails=0",
 214               NAME_NOMINATIM_URL, lat, lon, (int)sd->zoom);
 215    else strcpy(buf, "");
 216
 217    return strdup(buf);
 218 }
 219
 220 // Refer : http://wiki.openstreetmap.org/wiki/FAQ
 221 // meters per pixel when latitude is 0 (equator)
 222 // meters per pixel  = _osm_scale_meter[zoom] * cos (latitude)
 223 const double _osm_scale_meter[] =
 224 {
 225    78206, 39135.758482, 19567.879241, 9783.939621, 4891.969810,
 226    2445.984905, 1222.992453, 611.496226, 305.748113, 152.874057, 76.437028,
 227    38.218514, 19.109257, 9.554629, 4.777314, 2.388657, 1.194329, 0.597164,
 228    0.29858
 229 };
 230
 231 static double
 232 _scale_cb(const Evas_Object *obj __UNUSED__,
 233           double lon __UNUSED__,
 234           double lat,
 235           int zoom)
 236 {
 237    if (zoom < 0 || zoom >= (int)(sizeof(_osm_scale_meter)/sizeof(_osm_scale_meter[0]))) return 0;
 238    return _osm_scale_meter[zoom] / cos(lat * ELM_PI / 180.0);
 239 }
 240
 241 const Source_Tile src_tiles[] =
 242 {
 243    {"Mapnik", 0, 18, _mapnik_url_cb, NULL, NULL, _scale_cb},
 244    {"Osmarender", 0, 17, _osmarender_url_cb, NULL, NULL, _scale_cb},
 245    {"CycleMap", 0, 16, _cyclemap_url_cb, NULL, NULL, _scale_cb},
 246    {"MapQuest", 0, 18, _mapquest_url_cb, NULL, NULL, _scale_cb},
 247    {"MapQuest Open Aerial", 0, 11, _mapquest_aerial_url_cb, NULL, NULL,
 248     _scale_cb}
 249 };
 250
 251 // FIXME: Fix more open sources
 252 const Source_Route src_routes[] =
 253 {
 254    {"Yours", _yours_url_cb}    // http://www.yournavigation.org/
 255    //{"Monav", _monav_url_cb},
 256    //{"ORS", _ors_url_cb},     // http://www.openrouteservice.org
 257 };
 258
 259 // Scale in meters
 260 const double _scale_tb[] =
 261 {
 262    10000000, 5000000, 2000000, 1000000, 500000, 200000, 100000, 50000,
 263    20000, 10000, 5000, 2000, 1000, 500, 500, 200, 100, 50, 20, 10, 5, 2, 1
 264 };
 265
 266 // FIXME: Add more open sources
 267 const Source_Name src_names[] =
 268 {
 269    {"Nominatim", _nominatim_url_cb}
 270 };
 271
 272 static int id_num = 1;
 273
 274 static const char SIG_CLICKED[] = "clicked";
 275 static const char SIG_CLICKED_DOUBLE[] = "clicked,double";
 276 static const char SIG_PRESS[] = "press";
 277 static const char SIG_LONGPRESSED[] = "longpressed";
 278 static const char SIG_SCROLL[] = "scroll";
 279 static const char SIG_SCROLL_DRAG_START[] = "scroll,drag,start";
 280 static const char SIG_SCROLL_DRAG_STOP[] = "scroll,drag,stop";
 281 static const char SIG_SCROLL_ANIM_START[] = "scroll,anim,start";
 282 static const char SIG_SCROLL_ANIM_STOP[] = "scroll,anim,stop";
 283 static const char SIG_ZOOM_START[] = "zoom,start";
 284 static const char SIG_ZOOM_STOP[] = "zoom,stop";
 285 static const char SIG_ZOOM_CHANGE[] = "zoom,change";
 286 static const char SIG_LOADED[] = "loaded";
 287 static const char SIG_TILE_LOAD[] = "tile,load";
 288 static const char SIG_TILE_LOADED[] = "tile,loaded";
 289 static const char SIG_TILE_LOADED_FAIL[] = "tile,loaded,fail";
 290 static const char SIG_ROUTE_LOAD[] = "route,load";
 291 static const char SIG_ROUTE_LOADED[] = "route,loaded";
 292 static const char SIG_ROUTE_LOADED_FAIL[] = "route,loaded,fail";
 293 static const char SIG_NAME_LOAD[] = "name,load";
 294 static const char SIG_NAME_LOADED[] = "name,loaded";
 295 static const char SIG_NAME_LOADED_FAIL[] = "name,loaded,fail";
 296 static const char SIG_OVERLAY_CLICKED[] = "overlay,clicked";
 297 static const char SIG_OVERLAY_DEL[] = "overlay,del";
 298 static const char SIG_LANG_CHANGED[] = "language,changed";
 299
 300 static const Evas_Smart_Cb_Description _smart_callbacks[] = {
 301    {SIG_CLICKED, ""},
 302    {SIG_CLICKED_DOUBLE, ""},
 303    {SIG_PRESS, ""},
 304    {SIG_LONGPRESSED, ""},
 305    {SIG_SCROLL, ""},
 306    {SIG_SCROLL_DRAG_START, ""},
 307    {SIG_SCROLL_DRAG_STOP, ""},
 308    {SIG_SCROLL_ANIM_START, ""},
 309    {SIG_SCROLL_ANIM_STOP, ""},
 310    {SIG_ZOOM_START, ""},
 311    {SIG_ZOOM_STOP, ""},
 312    {SIG_ZOOM_CHANGE, ""},
 313    {SIG_LOADED, ""},
 314    {SIG_TILE_LOAD, ""},
 315    {SIG_TILE_LOADED, ""},
 316    {SIG_TILE_LOADED_FAIL, ""},
 317    {SIG_ROUTE_LOAD, ""},
 318    {SIG_ROUTE_LOADED, ""},
 319    {SIG_ROUTE_LOADED_FAIL, ""},
 320    {SIG_NAME_LOAD, ""},
 321    {SIG_NAME_LOADED, ""},
 322    {SIG_NAME_LOADED_FAIL, ""},
 323    {SIG_OVERLAY_CLICKED, ""},
 324    {SIG_OVERLAY_DEL, ""},
 325    {SIG_LANG_CHANGED, ""},
 326    {NULL, NULL}
 327 };
 328
 329 static const Evas_Smart_Interface *_smart_interfaces[] =
 330 {
 331    (Evas_Smart_Interface *)&ELM_SCROLLABLE_IFACE, NULL
 332 };
 333
 334 EVAS_SMART_SUBCLASS_IFACE_NEW
 335   (ELM_MAP_SMART_NAME, _elm_map, Elm_Map_Smart_Class,
 336   Elm_Widget_Smart_Class, elm_widget_smart_class_get, _smart_callbacks,
 337   _smart_interfaces);
 338
 339 ELM_INTERNAL_SMART_SUBCLASS_NEW
 340   (ELM_MAP_PAN_SMART_NAME, _elm_map_pan, Elm_Map_Pan_Smart_Class,
 341   Elm_Pan_Smart_Class, elm_pan_smart_class_get, NULL);
 342
 343 static Eina_Bool
 344 _elm_map_smart_translate(Evas_Object *obj)
 345 {
 346    evas_object_smart_callback_call(obj, SIG_LANG_CHANGED, NULL);
 347    return EINA_TRUE;
 348 }
 349
 350 static void
 351 _edj_overlay_size_get(Elm_Map_Smart_Data *sd,
 352                       Evas_Coord *w,
 353                       Evas_Coord *h)
 354 {
 355    Evas_Object *edj;
 356    const char *s;
 357
 358    EINA_SAFETY_ON_NULL_RETURN(w);
 359    EINA_SAFETY_ON_NULL_RETURN(h);
 360
 361    edj = edje_object_add(evas_object_evas_get(ELM_WIDGET_DATA(sd)->obj));
 362    elm_widget_theme_object_set
 363      (ELM_WIDGET_DATA(sd)->obj, edj, "map/marker", "radio",
 364      elm_widget_style_get(ELM_WIDGET_DATA(sd)->obj));
 365
 366    s = edje_object_data_get(edj, "size_w");
 367    if (s) *w = atoi(s);
 368    else *w = 0;
 369
 370    s = edje_object_data_get(edj, "size_h");
 371    if (s) *h = atoi(s);
 372    else *h = 0;
 373
 374    evas_object_del(edj);
 375 }
 376
 377 static void
 378 _rotate_do(Evas_Coord x,
 379            Evas_Coord y,
 380            Evas_Coord cx,
 381            Evas_Coord cy,
 382            double degree,
 383            Evas_Coord *xx,
 384            Evas_Coord *yy)
 385 {
 386    double r = (degree * M_PI) / 180.0;
 387
 388    if (xx) *xx = ((x - cx) * cos(r)) + ((y - cy) * cos(r + M_PI_2)) + cx;
 389    if (yy) *yy = ((x - cx) * sin(r)) + ((y - cy) * sin(r + M_PI_2)) + cy;
 390 }
 391
 392 static void
 393 _obj_rotate(Elm_Map_Smart_Data *sd,
 394             Evas_Object *obj)
 395 {
 396    Evas_Coord w, h, ow, oh;
 397
 398    evas_map_util_points_populate_from_object(sd->map, obj);
 399
 400    evas_object_geometry_get(obj, NULL, NULL, &ow, &oh);
 401    evas_object_image_size_get(obj, &w, &h);
 402    if ((w > ow) || (h > oh))
 403      {
 404         evas_map_point_image_uv_set(sd->map, 0, 0, 0);
 405         evas_map_point_image_uv_set(sd->map, 1, w, 0);
 406         evas_map_point_image_uv_set(sd->map, 2, w, h);
 407         evas_map_point_image_uv_set(sd->map, 3, 0, h);
 408      }
 409    evas_map_util_rotate(sd->map, sd->pan_rotate.d, sd->pan_rotate.cx,
 410                         sd->pan_rotate.cy);
 411
 412    evas_object_map_set(obj, sd->map);
 413    evas_object_map_enable_set(obj, EINA_TRUE);
 414 }
 415
 416 static void
 417 _obj_place(Evas_Object *obj,
 418            Evas_Coord x,
 419            Evas_Coord y,
 420            Evas_Coord w,
 421            Evas_Coord h)
 422 {
 423    EINA_SAFETY_ON_NULL_RETURN(obj);
 424
 425    evas_object_move(obj, x, y);
 426    evas_object_resize(obj, w, h);
 427    evas_object_show(obj);
 428 }
 429
 430 static void
 431 _coord_to_region_convert(Elm_Map_Smart_Data *sd,
 432                          Evas_Coord x,
 433                          Evas_Coord y,
 434                          Evas_Coord size,
 435                          double *lon,
 436                          double *lat)
 437 {
 438    int zoom;
 439
 440    EINA_SAFETY_ON_NULL_RETURN(sd);
 441
 442    zoom = floor(log(size / sd->size.tile) / log(2));
 443    if ((sd->src_tile) && (sd->src_tile->coord_to_geo))
 444      {
 445         if (sd->src_tile->coord_to_geo
 446               (ELM_WIDGET_DATA(sd)->obj, zoom, x, y, size, lon, lat))
 447           return;
 448      }
 449
 450    if (lon) *lon = (x / (double)size * 360.0) - 180;
 451    if (lat)
 452      {
 453         double n = ELM_PI - (2.0 * ELM_PI * y / size);
 454         *lat = 180.0 / ELM_PI *atan(0.5 * (exp(n) - exp(-n)));
 455      }
 456 }
 457
 458 static void
 459 _region_to_coord_convert(Elm_Map_Smart_Data *sd,
 460                          double lon,
 461                          double lat,
 462                          Evas_Coord size,
 463                          Evas_Coord *x,
 464                          Evas_Coord *y)
 465 {
 466    int zoom;
 467
 468    EINA_SAFETY_ON_NULL_RETURN(sd);
 469
 470    zoom = floor(log(size / 256) / log(2));
 471
 472    if (strcmp(sd->engine->name, INTERNAL_ENGINE_NAME))
 473      {
 474         sd->engine->region_to_canvas
 475               (ELM_WIDGET_DATA(sd)->obj, lon, lat, x, y);
 476         return;
 477      }
 478
 479    if ((sd->src_tile) && (sd->src_tile->geo_to_coord))
 480      {
 481         if (sd->src_tile->geo_to_coord
 482               (ELM_WIDGET_DATA(sd)->obj, zoom, lon, lat, size, x, y)) return;
 483      }
 484
 485    if (x) *x = floor((lon + 180.0) / 360.0 * size);
 486    if (y)
 487      *y = floor((1.0 - log(tan(lat * ELM_PI / 180.0) +
 488                            (1.0 / cos(lat * ELM_PI / 180.0)))
 489                  / ELM_PI) / 2.0 * size);
 490 }
 491
 492 static void
 493 _viewport_coord_get(Elm_Map_Smart_Data *sd,
 494                     Evas_Coord *vx,
 495                     Evas_Coord *vy,
 496                     Evas_Coord *vw,
 497                     Evas_Coord *vh)
 498 {
 499    Evas_Coord x, y, w, h;
 500
 501    EINA_SAFETY_ON_NULL_RETURN(sd);
 502
 503    sd->s_iface->content_pos_get(ELM_WIDGET_DATA(sd)->obj, &x, &y);
 504    sd->s_iface->content_viewport_size_get(ELM_WIDGET_DATA(sd)->obj, &w, &h);
 505
 506    if (w > sd->size.w) x -= ((w - sd->size.w) / 2);
 507    if (h > sd->size.h) y -= ((h - sd->size.h) / 2);
 508    if (vx) *vx = x;
 509    if (vy) *vy = y;
 510    if (vw) *vw = w;
 511    if (vh) *vh = h;
 512 }
 513
 514 // Map coordinates to canvas geometry without rotate
 515 static void
 516 _coord_to_canvas_no_rotation(Elm_Map_Smart_Data *sd,
 517                              Evas_Coord x,
 518                              Evas_Coord y,
 519                              Evas_Coord *xx,
 520                              Evas_Coord *yy)
 521 {
 522    Evas_Coord vx, vy, sx, sy;
 523
 524    if (!strcmp(sd->engine->name, INTERNAL_ENGINE_NAME))
 525      {
 526         _viewport_coord_get(sd, &vx, &vy, NULL, NULL);
 527         evas_object_geometry_get(sd->pan_obj, &sx, &sy, NULL, NULL);
 528         if (xx) *xx = x - vx + sx;
 529         if (yy) *yy = y - vy + sy;
 530    }
 531    else
 532      {
 533         if (xx) *xx = x;
 534         if (yy) *yy = y;
 535      }
 536 }
 537
 538 // Map coordinates to canvas geometry
 539 static void
 540 _coord_to_canvas(Elm_Map_Smart_Data *sd,
 541                  Evas_Coord x,
 542                  Evas_Coord y,
 543                  Evas_Coord *xx,
 544                  Evas_Coord *yy)
 545 {
 546    _coord_to_canvas_no_rotation(sd, x, y, &x, &y);
 547    if (!strcmp(sd->engine->name, INTERNAL_ENGINE_NAME))
 548      {
 549         _rotate_do(x, y, sd->pan_rotate.cx, sd->pan_rotate.cy, sd->pan_rotate.d, &x, &y);
 550      }
 551    if (xx) *xx = x;
 552    if (yy) *yy = y;
 553 }
 554
 555 // Canvas geometry to map coordinates
 556 static void
 557 _canvas_to_coord(Elm_Map_Smart_Data *sd,
 558                  Evas_Coord x,
 559                  Evas_Coord y,
 560                  Evas_Coord *xx,
 561                  Evas_Coord *yy)
 562 {
 563    Evas_Coord vx, vy, sx, sy;
 564
 565    _viewport_coord_get(sd, &vx, &vy, NULL, NULL);
 566    evas_object_geometry_get(sd->pan_obj, &sx, &sy, NULL, NULL);
 567    _rotate_do(x - sx + vx, y - sy + vy, sd->pan_rotate.cx - sx + vx,
 568               sd->pan_rotate.cy - sy + vy, -sd->pan_rotate.d, &x, &y);
 569    if (xx) *xx = x;
 570    if (yy) *yy = y;
 571 }
 572
 573 static void
 574 _grid_item_coord_get(Grid_Item *gi,
 575                      int *x,
 576                      int *y,
 577                      int *w,
 578                      int *h)
 579 {
 580    EINA_SAFETY_ON_NULL_RETURN(gi);
 581
 582    if (x) *x = gi->x * gi->wsd->size.tile;
 583    if (y) *y = gi->y * gi->wsd->size.tile;
 584    if (w) *w = gi->wsd->size.tile;
 585    if (h) *h = gi->wsd->size.tile;
 586 }
 587
 588 static Eina_Bool
 589 _grid_item_in_viewport(Grid_Item *gi)
 590 {
 591    Evas_Coord vx, vy, vw, vh;
 592    Evas_Coord x, y, w, h;
 593
 594    EINA_SAFETY_ON_NULL_RETURN_VAL(gi, EINA_FALSE);
 595
 596    _viewport_coord_get(gi->wsd, &vx, &vy, &vw, &vh);
 597    _grid_item_coord_get(gi, &x, &y, &w, &h);
 598
 599    return ELM_RECTS_INTERSECT(x, y, w, h, vx, vy, vw, vh);
 600 }
 601
 602 static Eina_Bool
 603 _loaded_timeout_cb(void *data)
 604 {
 605    Elm_Map_Smart_Data *sd = data;
 606
 607    EINA_SAFETY_ON_NULL_RETURN_VAL(data, EINA_FALSE);
 608
 609    sd->loaded_timer = NULL;
 610    if (!(sd->download_num) && !(sd->download_idler))
 611      evas_object_smart_callback_call
 612        (ELM_WIDGET_DATA(sd)->obj, SIG_LOADED, NULL);
 613    return ECORE_CALLBACK_CANCEL;
 614 }
 615
 616 static void
 617 _grid_item_update(Grid_Item *gi)
 618 {
 619    Evas_Load_Error err;
 620
 621    EINA_SAFETY_ON_NULL_RETURN(gi);
 622
 623    evas_object_image_file_set(gi->img, gi->file, NULL);
 624    if (!gi->wsd->zoom_timer && !gi->wsd->scr_timer)
 625      evas_object_image_smooth_scale_set(gi->img, EINA_TRUE);
 626    else evas_object_image_smooth_scale_set(gi->img, EINA_FALSE);
 627
 628    err = evas_object_image_load_error_get(gi->img);
 629    if (err != EVAS_LOAD_ERROR_NONE)
 630      {
 631         ERR("Image loading error (%s): %s", gi->file, evas_load_error_str(err));
 632         ecore_file_remove(gi->file);
 633         gi->file_have = EINA_FALSE;
 634      }
 635    else
 636      {
 637         Evas_Coord x, y, w, h;
 638
 639         _grid_item_coord_get(gi, &x, &y, &w, &h);
 640         _coord_to_canvas_no_rotation(gi->wsd, x, y, &x, &y);
 641         _obj_place(gi->img, x, y, w, h);
 642         _obj_rotate(gi->wsd, gi->img);
 643         gi->file_have = EINA_TRUE;
 644      }
 645
 646    if (gi->wsd->loaded_timer) ecore_timer_del(gi->wsd->loaded_timer);
 647    gi->wsd->loaded_timer = ecore_timer_add(0.25, _loaded_timeout_cb, gi->wsd);
 648 }
 649
 650 static void
 651 _grid_item_load(Grid_Item *gi)
 652 {
 653    EINA_SAFETY_ON_NULL_RETURN(gi);
 654
 655    if (gi->file_have) _grid_item_update(gi);
 656    else if (!gi->job)
 657      {
 658         gi->wsd->download_list = eina_list_remove(gi->wsd->download_list, gi);
 659         gi->wsd->download_list = eina_list_append(gi->wsd->download_list, gi);
 660      }
 661 }
 662
 663 static void
 664 _grid_item_unload(Grid_Item *gi)
 665 {
 666    EINA_SAFETY_ON_NULL_RETURN(gi);
 667
 668    if (gi->file_have)
 669      {
 670         evas_object_hide(gi->img);
 671         evas_object_image_file_set(gi->img, NULL, NULL);
 672      }
 673    else if (gi->job)
 674      {
 675         ecore_file_download_abort(gi->job);
 676         ecore_file_remove(gi->file);
 677         gi->job = NULL;
 678         gi->wsd->try_num--;
 679      }
 680    else gi->wsd->download_list = eina_list_remove(gi->wsd->download_list, gi);
 681 }
 682
 683 static Grid_Item *
 684 _grid_item_create(Grid *g,
 685                   Evas_Coord x,
 686                   Evas_Coord y)
 687 {
 688    char buf[PATH_MAX];
 689    char buf2[PATH_MAX];
 690    Grid_Item *gi;
 691    char *url;
 692
 693    EINA_SAFETY_ON_NULL_RETURN_VAL(g, NULL);
 694
 695    gi = ELM_NEW(Grid_Item);
 696    gi->wsd = g->wsd;
 697    gi->g = g;
 698    gi->x = x;
 699    gi->y = y;
 700
 701    gi->file_have = EINA_FALSE;
 702    gi->job = NULL;
 703
 704    gi->img = evas_object_image_add
 705        (evas_object_evas_get(ELM_WIDGET_DATA(g->wsd)->obj));
 706    evas_object_image_smooth_scale_set(gi->img, EINA_FALSE);
 707    evas_object_image_scale_hint_set(gi->img, EVAS_IMAGE_SCALE_HINT_DYNAMIC);
 708    evas_object_image_filled_set(gi->img, EINA_TRUE);
 709    evas_object_smart_member_add(gi->img, g->wsd->pan_obj);
 710    evas_object_pass_events_set(gi->img, EINA_TRUE);
 711    evas_object_stack_below(gi->img, g->wsd->sep_maps_overlays);
 712
 713    {
 714       const char *cachedir;
 715
 716 #ifdef ELM_EFREET
 717       snprintf(buf, sizeof(buf), "%s" CACHE_TILE_ROOT, efreet_cache_home_get(),
 718                g->wsd->id, g->zoom, x);
 719       (void)cachedir;
 720 #else
 721       cachedir = getenv("XDG_CACHE_HOME");
 722       snprintf(buf, sizeof(buf), "%s/%s" CACHE_TILE_ROOT, getenv("HOME"),
 723                cachedir ? : "/.config", g->wsd->id, g->zoom, x);
 724 #endif
 725    }
 726
 727    snprintf(buf2, sizeof(buf2), CACHE_TILE_PATH, buf, y);
 728    if (!ecore_file_exists(buf)) ecore_file_mkpath(buf);
 729
 730    eina_stringshare_replace(&gi->file, buf2);
 731    url = g->wsd->src_tile->url_cb(ELM_WIDGET_DATA(g->wsd)->obj, x, y, g->zoom);
 732    if ((!url) || (!strlen(url)))
 733      {
 734         eina_stringshare_replace(&gi->url, NULL);
 735         ERR("Getting source url failed: %s", gi->file);
 736      }
 737    else eina_stringshare_replace(&gi->url, url);
 738
 739    if (url) free(url);
 740    eina_matrixsparse_data_idx_set(g->grid, y, x, gi);
 741
 742    return gi;
 743 }
 744
 745 static void
 746 _grid_item_free(Grid_Item *gi)
 747 {
 748    EINA_SAFETY_ON_NULL_RETURN(gi);
 749
 750    _grid_item_unload(gi);
 751    if (gi->g && gi->g->grid)
 752      eina_matrixsparse_data_idx_set(gi->g->grid, gi->y, gi->x, NULL);
 753    if (gi->url) eina_stringshare_del(gi->url);
 754    if (gi->file_have) ecore_file_remove(gi->file);
 755    if (gi->file) eina_stringshare_del(gi->file);
 756    if (gi->img) evas_object_del(gi->img);
 757
 758    free(gi);
 759 }
 760
 761 static void
 762 _downloaded_cb(void *data,
 763                const char *file __UNUSED__,
 764                int status)
 765 {
 766    Grid_Item *gi = data;
 767
 768    if (status == 200)
 769      {
 770         DBG("Download success from %s to %s", gi->url, gi->file);
 771
 772         _grid_item_update(gi);
 773         gi->wsd->finish_num++;
 774         evas_object_smart_callback_call
 775           (ELM_WIDGET_DATA(gi->wsd)->obj, SIG_TILE_LOADED, NULL);
 776      }
 777    else
 778      {
 779         WRN("Download failed from %s to %s (%d) ", gi->url, gi->file, status);
 780
 781         ecore_file_remove(gi->file);
 782         gi->file_have = EINA_FALSE;
 783         evas_object_smart_callback_call
 784           (ELM_WIDGET_DATA(gi->wsd)->obj, SIG_TILE_LOADED_FAIL, NULL);
 785      }
 786
 787    gi->job = NULL;
 788    gi->wsd->download_num--;
 789    if (!gi->wsd->download_num)
 790      edje_object_signal_emit(ELM_WIDGET_DATA(gi->wsd)->resize_obj,
 791                              "elm,state,busy,stop", "elm");
 792 }
 793
 794 static Eina_Bool
 795 _download_job(void *data)
 796 {
 797    Elm_Map_Smart_Data *sd = data;
 798    Eina_List *l, *ll;
 799    Grid_Item *gi;
 800
 801    if (!eina_list_count(sd->download_list))
 802      {
 803         sd->download_idler = NULL;
 804         return ECORE_CALLBACK_CANCEL;
 805      }
 806
 807    EINA_LIST_REVERSE_FOREACH_SAFE(sd->download_list, l, ll, gi)
 808    {
 809       Eina_Bool ret;
 810
 811       if ((gi->g->zoom != sd->zoom) || !(_grid_item_in_viewport(gi)))
 812         {
 813            sd->download_list = eina_list_remove(sd->download_list, gi);
 814            continue;
 815         }
 816       if (sd->download_num >= MAX_CONCURRENT_DOWNLOAD)
 817         return ECORE_CALLBACK_RENEW;
 818
 819       ret = ecore_file_download_full
 820           (gi->url, gi->file, _downloaded_cb, NULL, gi, &(gi->job), sd->ua);
 821
 822       if ((!ret) || (!gi->job))
 823         ERR("Can't start to download from %s to %s", gi->url, gi->file);
 824       else
 825         {
 826            sd->download_list = eina_list_remove(sd->download_list, gi);
 827            sd->try_num++;
 828            sd->download_num++;
 829            evas_object_smart_callback_call
 830              (ELM_WIDGET_DATA(sd)->obj, SIG_TILE_LOAD, NULL);
 831            if (sd->download_num == 1)
 832              edje_object_signal_emit(ELM_WIDGET_DATA(sd)->resize_obj,
 833                                      "elm,state,busy,start", "elm");
 834         }
 835    }
 836
 837    return ECORE_CALLBACK_RENEW;
 838 }
 839
 840 static void
 841 _grid_viewport_get(Grid *g,
 842                    int *x,
 843                    int *y,
 844                    int *w,
 845                    int *h)
 846 {
 847    int xx, yy, ww, hh;
 848    Evas_Coord vx, vy, vw, vh;
 849
 850    EINA_SAFETY_ON_NULL_RETURN(g);
 851
 852    _viewport_coord_get(g->wsd, &vx, &vy, &vw, &vh);
 853    if (vx < 0) vx = 0;
 854    if (vy < 0) vy = 0;
 855
 856    xx = (vx / g->wsd->size.tile) - 1;
 857    if (xx < 0) xx = 0;
 858
 859    yy = (vy / g->wsd->size.tile) - 1;
 860    if (yy < 0) yy = 0;
 861
 862    ww = (vw / g->wsd->size.tile) + 3;
 863    if (xx + ww >= g->tw) ww = g->tw - xx;
 864
 865    hh = (vh / g->wsd->size.tile) + 3;
 866    if (yy + hh >= g->th) hh = g->th - yy;
 867
 868    if (x) *x = xx;
 869    if (y) *y = yy;
 870    if (w) *w = ww;
 871    if (h) *h = hh;
 872 }
 873
 874 static void
 875 _grid_unload(Grid *g)
 876 {
 877    Eina_Matrixsparse_Cell *cell;
 878    Eina_Iterator *it;
 879    Grid_Item *gi;
 880
 881    EINA_SAFETY_ON_NULL_RETURN(g);
 882
 883    it = eina_matrixsparse_iterator_new(g->grid);
 884    EINA_ITERATOR_FOREACH(it, cell)
 885      {
 886         gi = eina_matrixsparse_cell_data_get(cell);
 887         _grid_item_unload(gi);
 888      }
 889    eina_iterator_free(it);
 890 }
 891
 892 static void
 893 _grid_load(Grid *g)
 894 {
 895    Eina_Matrixsparse_Cell *cell;
 896    int x, y, xx, yy, ww, hh;
 897    Eina_Iterator *it;
 898    Grid_Item *gi;
 899
 900    EINA_SAFETY_ON_NULL_RETURN(g);
 901
 902    it = eina_matrixsparse_iterator_new(g->grid);
 903    EINA_ITERATOR_FOREACH(it, cell)
 904      {
 905         gi = eina_matrixsparse_cell_data_get(cell);
 906         if (!_grid_item_in_viewport(gi)) _grid_item_unload(gi);
 907      }
 908    eina_iterator_free(it);
 909
 910    _grid_viewport_get(g, &xx, &yy, &ww, &hh);
 911    for (y = yy; y < yy + hh; y++)
 912      {
 913         for (x = xx; x < xx + ww; x++)
 914           {
 915              gi = eina_matrixsparse_data_idx_get(g->grid, y, x);
 916              if (!gi) gi = _grid_item_create(g, x, y);
 917              _grid_item_load(gi);
 918           }
 919      }
 920 }
 921
 922 static void
 923 _grid_place(Elm_Map_Smart_Data *sd)
 924 {
 925    Eina_List *l;
 926    Grid *g;
 927
 928    EINA_SAFETY_ON_NULL_RETURN(sd);
 929
 930    EINA_LIST_FOREACH(sd->grids, l, g)
 931      {
 932         if (sd->zoom == g->zoom) _grid_load(g);
 933         else _grid_unload(g);
 934      }
 935    if (!sd->download_idler)
 936      sd->download_idler = ecore_idler_add(_download_job, sd);
 937 }
 938
 939 static void
 940 _grid_all_create(Elm_Map_Smart_Data *sd)
 941 {
 942    int zoom;
 943
 944    EINA_SAFETY_ON_NULL_RETURN(sd->src_tile);
 945
 946    for (zoom = sd->src_tile->zoom_min; zoom <= sd->src_tile->zoom_max; zoom++)
 947      {
 948         Grid *g;
 949         int tnum;
 950
 951         g = ELM_NEW(Grid);
 952         g->wsd = sd;
 953         g->zoom = zoom;
 954         tnum = pow(2.0, g->zoom);
 955         g->tw = tnum;
 956         g->th = tnum;
 957         g->grid = eina_matrixsparse_new(g->th, g->tw, NULL, NULL);
 958         sd->grids = eina_list_append(sd->grids, g);
 959      }
 960 }
 961
 962 static void
 963 _grid_all_clear(Elm_Map_Smart_Data *sd)
 964 {
 965    Grid *g;
 966
 967    EINA_SAFETY_ON_NULL_RETURN(sd);
 968
 969    EINA_LIST_FREE (sd->grids, g)
 970      {
 971         Eina_Matrixsparse_Cell *cell;
 972         Eina_Iterator *it = eina_matrixsparse_iterator_new(g->grid);
 973
 974         EINA_ITERATOR_FOREACH(it, cell)
 975           {
 976              Grid_Item *gi;
 977
 978              gi = eina_matrixsparse_cell_data_get(cell);
 979              if (gi) _grid_item_free(gi);
 980           }
 981         eina_iterator_free(it);
 982
 983         eina_matrixsparse_free(g->grid);
 984         free(g);
 985      }
 986 }
 987
 988 static void
 989 _track_place(Elm_Map_Smart_Data *sd)
 990 {
 991 #ifdef ELM_EMAP
 992    Eina_List *l;
 993    Evas_Coord size;
 994    Evas_Object *route;
 995    Evas_Coord px, py, ow, oh;
 996    int xmin, xmax, ymin, ymax;
 997
 998    px = sd->pan_x;
 999    py = sd->pan_y;
1000    _viewport_coord_get(sd, NULL, NULL, &ow, &oh);
1001
1002    size = sd->size.w;
1003
1004    EINA_LIST_FOREACH(sd->track, l, route)
1005      {
1006         double lon_min, lon_max;
1007         double lat_min, lat_max;
1008
1009         elm_route_longitude_min_max_get(route, &lon_min, &lon_max);
1010         elm_route_latitude_min_max_get(route, &lat_min, &lat_max);
1011         _region_to_coord_convert(sd, lon_min, lat_max, size, &xmin, &ymin);
1012         _region_to_coord_convert(sd, lon_max, lat_min, size, &xmax, &ymax);
1013
1014         if ( !(xmin < px && xmax < px) && !(xmin > px + ow && xmax > px + ow))
1015           {
1016              if ((ymin < py && ymax < py) ||
1017                  (ymin > py + oh && ymax > py + oh))
1018                {
1019                   //display the route
1020                   evas_object_move(route, xmin - px, ymin - py);
1021                   evas_object_resize(route, xmax - xmin, ymax - ymin);
1022
1023                   evas_object_raise(route);
1024                   _obj_rotate(sd, route);
1025                   evas_object_show(route);
1026
1027                   continue;
1028                }
1029           }
1030         //the route is not display
1031         evas_object_hide(route);
1032      }
1033 #else
1034    (void)sd;
1035 #endif
1036 }
1037
1038 static void
1039 _smooth_update(Elm_Map_Smart_Data *sd)
1040 {
1041    Eina_List *l;
1042    Grid *g;
1043
1044    EINA_LIST_FOREACH(sd->grids, l, g)
1045      {
1046         Eina_Iterator *it = eina_matrixsparse_iterator_new(g->grid);
1047         Eina_Matrixsparse_Cell *cell;
1048
1049         EINA_ITERATOR_FOREACH(it, cell)
1050           {
1051              Grid_Item *gi = eina_matrixsparse_cell_data_get(cell);
1052              if (_grid_item_in_viewport(gi))
1053                evas_object_image_smooth_scale_set(gi->img, EINA_TRUE);
1054           }
1055         eina_iterator_free(it);
1056      }
1057 }
1058
1059 static Eina_Bool
1060 _zoom_timeout_cb(void *data)
1061 {
1062    Elm_Map_Smart_Data *sd = data;
1063
1064    _smooth_update(sd);
1065    sd->zoom_timer = NULL;
1066    evas_object_smart_callback_call
1067      (ELM_WIDGET_DATA(sd)->obj, SIG_ZOOM_STOP, NULL);
1068
1069    return ECORE_CALLBACK_CANCEL;
1070 }
1071
1072 static void
1073 _zoom(Elm_Map_Smart_Data *sd, double zoom, int animation)
1074 {
1075    if (zoom > sd->zoom_max) zoom = sd->zoom_max;
1076    else if (zoom < sd->zoom_min) zoom = sd->zoom_min;
1077
1078    sd->engine->zoom(ELM_WIDGET_DATA(sd)->obj, zoom, animation);
1079    sd->zoom_detail = zoom;
1080    sd->zoom = ROUND(sd->zoom_detail);
1081
1082    if (strcmp(sd->engine->name, INTERNAL_ENGINE_NAME))
1083      _overlay_place(sd);
1084
1085    if (sd->zoom_timer) ecore_timer_del(sd->zoom_timer);
1086    else
1087      evas_object_smart_callback_call
1088        (ELM_WIDGET_DATA(sd)->obj, SIG_ZOOM_START, NULL);
1089
1090    sd->zoom_timer = ecore_timer_add(0.25, _zoom_timeout_cb, sd);
1091    evas_object_smart_callback_call
1092      (ELM_WIDGET_DATA(sd)->obj, SIG_ZOOM_CHANGE, NULL);
1093 }
1094
1095 static void
1096 _sizing_eval(Elm_Map_Smart_Data *sd)
1097 {
1098    Evas_Coord maxw = -1, maxh = -1;
1099
1100    evas_object_size_hint_max_get(ELM_WIDGET_DATA(sd)->obj, &maxw, &maxh);
1101    evas_object_size_hint_max_set(ELM_WIDGET_DATA(sd)->obj, maxw, maxh);
1102 }
1103
1104 static void
1105 _changed_size_hints_cb(void *data,
1106                        Evas *e __UNUSED__,
1107                        Evas_Object *obj __UNUSED__,
1108                        void *event_info __UNUSED__)
1109 {
1110    _sizing_eval(data);
1111 }
1112
1113 static Eina_Bool
1114 _scr_timeout_cb(void *data)
1115 {
1116    Elm_Map_Smart_Data *sd = data;
1117
1118    _smooth_update(sd);
1119    sd->scr_timer = NULL;
1120    evas_object_smart_callback_call
1121      (ELM_WIDGET_DATA(sd)->obj, SIG_SCROLL_DRAG_STOP, NULL);
1122
1123    return ECORE_CALLBACK_CANCEL;
1124 }
1125
1126 static void
1127 _scroll_cb(Evas_Object *obj,
1128            void *data __UNUSED__)
1129 {
1130    ELM_MAP_DATA_GET(obj, sd);
1131
1132    if (sd->scr_timer) ecore_timer_del(sd->scr_timer);
1133    else
1134      evas_object_smart_callback_call
1135        (ELM_WIDGET_DATA(sd)->obj, SIG_SCROLL_DRAG_START, NULL);
1136    sd->scr_timer = ecore_timer_add(0.25, _scr_timeout_cb, sd);
1137    evas_object_smart_callback_call(ELM_WIDGET_DATA(sd)->obj, SIG_SCROLL, NULL);
1138 }
1139
1140 static void
1141 _scroll_animate_start_cb(Evas_Object *obj,
1142                          void *data __UNUSED__)
1143 {
1144    ELM_MAP_DATA_GET(obj, sd);
1145
1146    evas_object_smart_callback_call
1147      (ELM_WIDGET_DATA(sd)->obj, SIG_SCROLL_ANIM_START, NULL);
1148 }
1149
1150 static void
1151 _scroll_animate_stop_cb(Evas_Object *obj,
1152                         void *data __UNUSED__)
1153 {
1154    ELM_MAP_DATA_GET(obj, sd);
1155
1156    evas_object_smart_callback_call
1157      (ELM_WIDGET_DATA(sd)->obj, SIG_SCROLL_ANIM_STOP, NULL);
1158 }
1159
1160 static Eina_Bool
1161 _long_press_cb(void *data)
1162 {
1163    Elm_Map_Smart_Data *sd = data;
1164
1165    sd->long_timer = NULL;
1166    evas_object_smart_callback_call
1167      (ELM_WIDGET_DATA(sd)->obj, SIG_LONGPRESSED, &sd->ev);
1168
1169    return ECORE_CALLBACK_CANCEL;
1170 }
1171
1172 static void
1173 _mouse_down_cb(void *data,
1174                Evas *evas __UNUSED__,
1175                Evas_Object *obj __UNUSED__,
1176                void *event_info)
1177 {
1178    Elm_Map_Smart_Data *sd = data;
1179    Evas_Event_Mouse_Down *ev = event_info;
1180
1181    if (ev->button != 1) return;
1182    if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD) sd->on_hold = EINA_TRUE;
1183    else sd->on_hold = EINA_FALSE;
1184
1185    if (ev->flags & EVAS_BUTTON_DOUBLE_CLICK)
1186      evas_object_smart_callback_call
1187        (ELM_WIDGET_DATA(sd)->obj, SIG_CLICKED_DOUBLE, ev);
1188    else
1189      evas_object_smart_callback_call
1190        (ELM_WIDGET_DATA(sd)->obj, SIG_PRESS, ev);
1191
1192    if (sd->long_timer) ecore_timer_del(sd->long_timer);
1193    sd->ev = *ev;
1194    sd->long_timer =
1195      ecore_timer_add(_elm_config->longpress_timeout, _long_press_cb, sd);
1196 }
1197
1198 static void
1199 _mouse_up_cb(void *data,
1200              Evas *evas __UNUSED__,
1201              Evas_Object *obj __UNUSED__,
1202              void *event_info)
1203 {
1204    Elm_Map_Smart_Data *sd = data;
1205    Evas_Event_Mouse_Up *ev = event_info;
1206
1207    EINA_SAFETY_ON_NULL_RETURN(ev);
1208
1209    if (ev->button != 1) return;
1210
1211    if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD) sd->on_hold = EINA_TRUE;
1212    else sd->on_hold = EINA_FALSE;
1213
1214    if (sd->long_timer)
1215      {
1216         ecore_timer_del(sd->long_timer);
1217         sd->long_timer = NULL;
1218      }
1219
1220    if (!sd->on_hold)
1221      evas_object_smart_callback_call
1222        (ELM_WIDGET_DATA(sd)->obj, SIG_CLICKED, ev);
1223    sd->on_hold = EINA_FALSE;
1224 }
1225
1226 static void
1227 _mouse_wheel_cb(void *data,
1228                 Evas *e __UNUSED__,
1229                 Evas_Object *obj __UNUSED__,
1230                 void *event_info)
1231 {
1232    Elm_Map_Smart_Data *sd = data;
1233
1234    if (!sd->paused)
1235      {
1236         Evas_Event_Mouse_Wheel *ev = event_info;
1237
1238         _zoom(sd, sd->zoom_detail - ((double)ev->z /10), 0);
1239      }
1240 }
1241
1242 static void
1243 _region_max_min_get(Eina_List *overlays,
1244                     double *max_longitude,
1245                     double *min_longitude,
1246                     double *max_latitude,
1247                     double *min_latitude)
1248 {
1249    double max_lon = -180, min_lon = 180;
1250    double max_lat = -90, min_lat = 90;
1251    Elm_Map_Overlay *overlay;
1252
1253    EINA_LIST_FREE (overlays, overlay)
1254      {
1255         double lon, lat;
1256
1257         if (overlay->type == ELM_MAP_OVERLAY_TYPE_DEFAULT)
1258           {
1259              Overlay_Default *ovl = overlay->ovl;
1260
1261              lon = ovl->lon;
1262              lat = ovl->lat;
1263           }
1264         else if (overlay->type == ELM_MAP_OVERLAY_TYPE_CLASS)
1265           {
1266              // FIXME: class center coord is alright??
1267              Overlay_Class *ovl = overlay->ovl;
1268              double max_lo, min_lo, max_la, min_la;
1269
1270              _region_max_min_get
1271                (ovl->members, &max_lo, &min_lo, &max_la, &min_la);
1272              lon = (max_lo + min_lo) / 2;
1273              lat = (max_la + min_la) / 2;
1274           }
1275         else if (overlay->type == ELM_MAP_OVERLAY_TYPE_BUBBLE)
1276           {
1277              Overlay_Bubble *ovl = overlay->ovl;
1278
1279              lon = ovl->lon;
1280              lat = ovl->lat;
1281           }
1282         else
1283           {
1284              WRN("Not supported overlay type: %d", overlay->type);
1285              continue;
1286           }
1287         if (lon > max_lon) max_lon = lon;
1288         if (lon < min_lon) min_lon = lon;
1289         if (lat > max_lat) max_lat = lat;
1290         if (lat < min_lat) min_lat = lat;
1291      }
1292
1293    if (max_longitude) *max_longitude = max_lon;
1294    if (min_longitude) *min_longitude = min_lon;
1295    if (max_latitude) *max_latitude = max_lat;
1296    if (min_latitude) *min_latitude = min_lat;
1297 }
1298
1299 static Evas_Object *
1300 _icon_dup(Evas_Object *icon,
1301           Evas_Object *parent)
1302 {
1303    Evas_Object *dupp;
1304    Evas_Coord w, h;
1305
1306    if (!icon || !parent) return NULL;
1307    dupp = evas_object_image_filled_add(evas_object_evas_get(parent));
1308    evas_object_image_source_set(dupp, icon);
1309    // Set size as origin' sizse for proxy
1310    evas_object_geometry_get(icon, NULL, NULL, &w, &h);
1311    if (w <= 0 || h <= 0)
1312      {
1313         evas_object_size_hint_min_get(icon, &w, &h);
1314         evas_object_size_hint_min_set(dupp, w, h);
1315      }
1316    else evas_object_resize(dupp, w, h);
1317    // Original should have size for proxy
1318    evas_object_resize(icon, w, h);
1319
1320    return dupp;
1321 }
1322
1323 static void
1324 _overlay_clicked_cb(void *data,
1325                     Evas *e __UNUSED__,
1326                     Evas_Object *obj __UNUSED__,
1327                     void *ev __UNUSED__)
1328 {
1329    Elm_Map_Overlay *overlay = data;
1330
1331    EINA_SAFETY_ON_NULL_RETURN(data);
1332
1333    evas_object_smart_callback_call
1334      (ELM_WIDGET_DATA(overlay->wsd)->obj, SIG_OVERLAY_CLICKED, overlay);
1335    if (overlay->cb)
1336      overlay->cb(overlay->cb_data, ELM_WIDGET_DATA(overlay->wsd)->obj, overlay);
1337 }
1338
1339 static void
1340 _overlay_default_hide(Overlay_Default *ovl)
1341 {
1342    EINA_SAFETY_ON_NULL_RETURN(ovl);
1343
1344    if (ovl->content) evas_object_hide(ovl->content);
1345    if (ovl->icon) evas_object_hide(ovl->icon);
1346    if (ovl->clas_content) evas_object_hide(ovl->clas_content);
1347    if (ovl->clas_icon) evas_object_hide(ovl->clas_icon);
1348    if (ovl->layout) evas_object_hide(ovl->layout);
1349 }
1350
1351 static void
1352 _overlay_default_show(Overlay_Default *ovl)
1353 {
1354    Evas_Object *disp;
1355    Evas_Coord x, y, w, h;
1356
1357    EINA_SAFETY_ON_NULL_RETURN(ovl);
1358
1359    evas_object_hide(ovl->layout);
1360    if (ovl->content)
1361      {
1362         disp = ovl->content;
1363         evas_object_geometry_get(disp, NULL, NULL, &w, &h);
1364         if (w <= 0 || h <= 0) evas_object_size_hint_min_get(disp, &w, &h);
1365                 ovl->w = w;
1366                 ovl->h = h;
1367      }
1368    else if (!(ovl->icon) && ovl->clas_content)
1369      {
1370         disp = ovl->clas_content;
1371
1372         evas_object_geometry_get(disp, NULL, NULL, &w, &h);
1373         if (w <= 0 || h <= 0) evas_object_size_hint_min_get(disp, &w, &h);
1374      }
1375    else
1376      {
1377         if (ovl->icon) evas_object_show(ovl->icon);
1378         else if (ovl->clas_icon)
1379           evas_object_show(ovl->clas_icon);
1380         disp = ovl->layout;
1381         w = ovl->w;
1382         h = ovl->h;
1383      }
1384    _coord_to_canvas(ovl->wsd, ovl->x, ovl->y, &x, &y);
1385    _obj_place(disp, x - (w / 2), y - (h / 2), w, h);
1386 }
1387
1388 static void
1389 _overlay_default_coord_get(Overlay_Default *ovl,
1390                            Evas_Coord *x,
1391                            Evas_Coord *y,
1392                            Evas_Coord *w,
1393                            Evas_Coord *h)
1394 {
1395    EINA_SAFETY_ON_NULL_RETURN(ovl);
1396
1397    if (x) *x = ovl->x;
1398    if (y) *y = ovl->y;
1399    if (w) *w = ovl->w;
1400    if (h) *h = ovl->h;
1401 }
1402
1403 static void
1404 _overlay_default_coord_set(Overlay_Default *ovl,
1405                            Evas_Coord x,
1406                            Evas_Coord y)
1407 {
1408    EINA_SAFETY_ON_NULL_RETURN(ovl);
1409
1410    ovl->x = x;
1411    ovl->y = y;
1412 }
1413
1414 static void
1415 _overlay_default_coord_update(Overlay_Default *ovl)
1416 {
1417    EINA_SAFETY_ON_NULL_RETURN(ovl);
1418
1419    _region_to_coord_convert
1420      (ovl->wsd, ovl->lon, ovl->lat, ovl->wsd->size.w, &ovl->x, &ovl->y);
1421 }
1422
1423 static void
1424 _overlay_default_layout_text_update(Overlay_Default *ovl,
1425                                     const char *text)
1426 {
1427    if (!ovl->content && !ovl->icon && !ovl->clas_content && !ovl->clas_icon)
1428      elm_layout_text_set(ovl->layout, "elm.text", text);
1429 }
1430
1431 static void
1432 _overlay_default_content_update(Overlay_Default *ovl,
1433                                 Evas_Object *content,
1434                                 Elm_Map_Overlay *overlay)
1435 {
1436    EINA_SAFETY_ON_NULL_RETURN(ovl);
1437
1438    if (ovl->content == content) return;
1439    if (ovl->content) evas_object_del(ovl->content);
1440    ovl->content = content;
1441    if (!strcmp(ovl->wsd->engine->name, INTERNAL_ENGINE_NAME))
1442      evas_object_smart_member_add(ovl->content, ovl->wsd->pan_obj);
1443    else
1444      evas_object_smart_member_add(ovl->content, ELM_WIDGET_DATA(ovl->wsd)->obj);
1445    evas_object_stack_above(ovl->content, ovl->wsd->sep_maps_overlays);
1446
1447    if (ovl->content)
1448      evas_object_event_callback_add(ovl->content, EVAS_CALLBACK_MOUSE_DOWN,
1449                                     _overlay_clicked_cb, overlay);
1450 }
1451
1452 static void
1453 _overlay_default_layout_update(Overlay_Default *ovl)
1454 {
1455    EINA_SAFETY_ON_NULL_RETURN(ovl);
1456
1457    if (ovl->icon)
1458      {
1459         evas_object_color_set(ovl->layout, 255, 255, 255, 255);
1460         elm_layout_theme_set
1461           (ovl->layout, "map/marker", "empty",
1462           elm_widget_style_get(ELM_WIDGET_DATA(ovl->wsd)->obj));
1463         elm_object_part_content_set(ovl->layout, "elm.icon", ovl->icon);
1464      }
1465    else if (!ovl->icon && ovl->clas_icon)
1466      {
1467         evas_object_color_set(ovl->layout, 255, 255, 255, 255);
1468         elm_layout_theme_set
1469           (ovl->layout, "map/marker", "empty",
1470           elm_widget_style_get(ELM_WIDGET_DATA(ovl->wsd)->obj));
1471         elm_object_part_content_set(ovl->layout, "elm.icon", ovl->clas_icon);
1472      }
1473    else
1474      {
1475         evas_object_color_set
1476           (ovl->layout, ovl->c.r, ovl->c.g, ovl->c.b, ovl->c.a);
1477         elm_layout_theme_set
1478           (ovl->layout, "map/marker", "radio",
1479           elm_widget_style_get(ELM_WIDGET_DATA(ovl->wsd)->obj));
1480      }
1481 }
1482
1483 static void
1484 _overlay_default_class_content_update(Overlay_Default *ovl,
1485                                       Evas_Object *content)
1486 {
1487    EINA_SAFETY_ON_NULL_RETURN(ovl);
1488
1489    if (ovl->clas_content) evas_object_del(ovl->clas_content);
1490    ovl->clas_content = _icon_dup(content, ovl->layout);
1491    if (!strcmp(ovl->wsd->engine->name, INTERNAL_ENGINE_NAME))
1492      evas_object_smart_member_add(ovl->clas_content, ovl->wsd->pan_obj);
1493    else
1494      evas_object_smart_member_add(ovl->clas_content, ELM_WIDGET_DATA(ovl->wsd)->obj);
1495    evas_object_stack_above(ovl->clas_content, ovl->wsd->sep_maps_overlays);
1496    _overlay_default_layout_update(ovl);
1497 }
1498
1499 static void
1500 _overlay_default_icon_update(Overlay_Default *ovl,
1501                              Evas_Object *icon)
1502 {
1503    EINA_SAFETY_ON_NULL_RETURN(ovl);
1504
1505    if (ovl->icon == icon) return;
1506
1507    if (ovl->icon) evas_object_del(ovl->icon);
1508    ovl->icon = icon;
1509    _overlay_default_layout_update(ovl);
1510 }
1511
1512 static void
1513 _overlay_default_class_icon_update(Overlay_Default *ovl,
1514                                    Evas_Object *icon)
1515 {
1516    EINA_SAFETY_ON_NULL_RETURN(ovl);
1517
1518    if (ovl->clas_icon) evas_object_del(ovl->clas_icon);
1519    ovl->clas_icon = _icon_dup(icon, ovl->layout);
1520    _overlay_default_layout_update(ovl);
1521 }
1522
1523 static void
1524 _overlay_default_color_update(Overlay_Default *ovl,
1525                               Color c)
1526 {
1527    EINA_SAFETY_ON_NULL_RETURN(ovl);
1528
1529    ovl->c = c;
1530    _overlay_default_layout_update(ovl);
1531 }
1532
1533 static void
1534 _overlay_default_free(Overlay_Default *ovl)
1535 {
1536    EINA_SAFETY_ON_NULL_RETURN(ovl);
1537
1538    if (ovl->content) evas_object_del(ovl->content);
1539    if (ovl->icon) evas_object_del(ovl->icon);
1540    if (ovl->clas_content) evas_object_del(ovl->clas_content);
1541    if (ovl->clas_icon) evas_object_del(ovl->clas_icon);
1542    if (ovl->layout) evas_object_del(ovl->layout);
1543
1544    free(ovl);
1545 }
1546
1547 static Overlay_Default *
1548 _overlay_default_new(Elm_Map_Overlay *overlay,
1549                      double lon,
1550                      double lat,
1551                      Color c,
1552                      double scale)
1553 {
1554    Overlay_Default *ovl;
1555
1556    EINA_SAFETY_ON_NULL_RETURN_VAL(overlay, NULL);
1557
1558    ovl = ELM_NEW(Overlay_Default);
1559    ovl->wsd = overlay->wsd;
1560    _edj_overlay_size_get(ovl->wsd, &(ovl->w), &(ovl->h));
1561    ovl->w *= scale;
1562    ovl->h *= scale;
1563    ovl->layout = elm_layout_add(ELM_WIDGET_DATA(ovl->wsd)->obj);
1564    if (!strcmp(ovl->wsd->engine->name, INTERNAL_ENGINE_NAME))
1565      evas_object_smart_member_add(ovl->layout, ovl->wsd->pan_obj);
1566    else
1567      evas_object_smart_member_add(ovl->layout, ELM_WIDGET_DATA(ovl->wsd)->obj);
1568    evas_object_stack_above(ovl->layout, ovl->wsd->sep_maps_overlays);
1569    elm_layout_theme_set(ovl->layout, "map/marker", "radio",
1570                         elm_widget_style_get(ELM_WIDGET_DATA(ovl->wsd)->obj));
1571    evas_object_event_callback_add(ovl->layout, EVAS_CALLBACK_MOUSE_DOWN,
1572                                   _overlay_clicked_cb, overlay);
1573    ovl->lon = lon;
1574    ovl->lat = lat;
1575    _overlay_default_color_update(ovl, c);
1576
1577    return ovl;
1578 }
1579
1580 static void
1581 _overlay_group_hide(Overlay_Group *grp)
1582 {
1583    EINA_SAFETY_ON_NULL_RETURN(grp);
1584
1585    if (grp->ovl) _overlay_default_hide(grp->ovl);
1586 }
1587
1588 static void
1589 _overlay_group_show(Overlay_Group *grp)
1590 {
1591    EINA_SAFETY_ON_NULL_RETURN(grp);
1592
1593    if (grp->ovl) _overlay_default_show(grp->ovl);
1594 }
1595
1596 static void
1597 _overlay_group_coord_member_update(Overlay_Group *grp,
1598                                    Evas_Coord x,
1599                                    Evas_Coord y,
1600                                    Eina_List *members)
1601 {
1602    char text[32];
1603
1604    EINA_SAFETY_ON_NULL_RETURN(grp);
1605
1606    if (!grp->ovl) return;
1607
1608    _overlay_default_coord_set(grp->ovl, x, y);
1609    _coord_to_region_convert
1610      (grp->wsd, x, y, grp->wsd->size.w, &grp->lon, &grp->lat);
1611
1612    if (grp->members) eina_list_free(grp->members);
1613    grp->members = members;
1614    snprintf(text, sizeof(text), "%d", eina_list_count(members));
1615
1616    _overlay_default_layout_text_update(grp->ovl, text);
1617 }
1618
1619 static void
1620 _overlay_group_icon_update(Overlay_Group *grp,
1621                            Evas_Object *icon)
1622 {
1623    EINA_SAFETY_ON_NULL_RETURN(grp);
1624
1625    if (grp->ovl)
1626      _overlay_default_icon_update
1627        (grp->ovl, _icon_dup(icon, ELM_WIDGET_DATA(grp->wsd)->obj));
1628 }
1629
1630 static void
1631 _overlay_group_content_update(Overlay_Group *grp,
1632                               Evas_Object *content,
1633                               Elm_Map_Overlay *overlay)
1634 {
1635    EINA_SAFETY_ON_NULL_RETURN(grp);
1636
1637    _overlay_default_content_update
1638       (grp->ovl, _icon_dup(content, ELM_WIDGET_DATA(grp->wsd)->obj), overlay);
1639
1640    return;
1641 }
1642
1643 static void
1644 _overlay_group_color_update(Overlay_Group *grp,
1645                             Color c)
1646 {
1647    EINA_SAFETY_ON_NULL_RETURN(grp);
1648
1649    _overlay_default_color_update(grp->ovl, c);
1650 }
1651
1652 static void
1653 _overlay_group_cb_set(Overlay_Group *grp,
1654                       Elm_Map_Overlay_Get_Cb cb,
1655                       void *data)
1656 {
1657    EINA_SAFETY_ON_NULL_RETURN(grp);
1658
1659    grp->overlay->cb = cb;
1660    grp->overlay->data = data;
1661 }
1662
1663 static void
1664 _overlay_group_free(Overlay_Group *grp)
1665 {
1666    EINA_SAFETY_ON_NULL_RETURN(grp);
1667
1668    if (grp->overlay) free(grp->overlay);
1669    if (grp->ovl) _overlay_default_free(grp->ovl);
1670    if (grp->members) eina_list_free(grp->members);
1671
1672    free(grp);
1673 }
1674
1675 static Overlay_Group *
1676 _overlay_group_new(Elm_Map_Smart_Data *sd)
1677 {
1678    Overlay_Group *grp;
1679    Color c = {0x90, 0xee, 0x90, 0xff};
1680
1681    grp = ELM_NEW(Overlay_Group);
1682    grp->wsd = sd;
1683    grp->overlay = ELM_NEW(Elm_Map_Overlay);  // this is a virtual overlay
1684    grp->overlay->wsd = sd;
1685    grp->overlay->type = ELM_MAP_OVERLAY_TYPE_GROUP;
1686    grp->overlay->ovl = grp;
1687    grp->ovl = _overlay_default_new(grp->overlay, -1, -1, c, 1);
1688
1689    return grp;
1690 }
1691
1692 static void
1693 _overlay_class_cb_set(Overlay_Class *ovl,
1694                       Elm_Map_Overlay_Get_Cb cb,
1695                       void *data)
1696 {
1697    Eina_List *l;
1698    Elm_Map_Overlay *overlay;
1699
1700    EINA_SAFETY_ON_NULL_RETURN(ovl);
1701
1702    // Update class members' callbacks
1703    EINA_LIST_FOREACH(ovl->members, l, overlay)
1704      _overlay_group_cb_set(overlay->grp, cb, data);
1705 }
1706
1707 static void
1708 _overlay_class_icon_update(Overlay_Class *ovl,
1709                            Evas_Object *icon)
1710 {
1711    Eina_List *l;
1712    Elm_Map_Overlay *overlay;
1713
1714    EINA_SAFETY_ON_NULL_RETURN(ovl);
1715
1716    if (ovl->icon == icon) return;
1717    if (ovl->icon) evas_object_del(ovl->icon);
1718    ovl->icon = icon;
1719    // For using proxy, it should have size and be shown but moved away to hide.
1720    evas_object_resize(icon, 32, 32);
1721    evas_object_move(icon, -9999, -9999);
1722    evas_object_show(icon);
1723
1724    // Update class members' class icons
1725    EINA_LIST_FOREACH(ovl->members, l, overlay)
1726      {
1727         _overlay_group_icon_update(overlay->grp, icon);
1728
1729         if (overlay->type == ELM_MAP_OVERLAY_TYPE_DEFAULT)
1730           _overlay_default_class_icon_update(overlay->ovl, icon);
1731      }
1732 }
1733
1734 static void
1735 _overlay_class_content_update(Overlay_Class *ovl,
1736                               Evas_Object *content)
1737 {
1738    Eina_List *l;
1739    Elm_Map_Overlay *overlay;
1740
1741    EINA_SAFETY_ON_NULL_RETURN(ovl);
1742
1743    if (ovl->content == content) return;
1744    if (ovl->content) evas_object_del(ovl->content);
1745    ovl->content = content;
1746    // For using proxy, it should have size and be shown but moved away to hide.
1747    // content should have it's own size
1748    evas_object_move(content, -9999, -9999);
1749
1750    // Update class members' class contents
1751    EINA_LIST_FOREACH(ovl->members, l, overlay)
1752      {
1753         _overlay_group_content_update(overlay->grp, content, overlay);
1754
1755         if (overlay->type == ELM_MAP_OVERLAY_TYPE_DEFAULT)
1756           _overlay_default_class_content_update(overlay->ovl, content);
1757      }
1758 }
1759
1760 static void
1761 _overlay_class_color_update(Overlay_Class *ovl,
1762                             Color c)
1763 {
1764    Eina_List *l;
1765    Elm_Map_Overlay *overlay;
1766
1767    EINA_SAFETY_ON_NULL_RETURN(ovl);
1768
1769    // Update class members' class contents
1770    EINA_LIST_FOREACH(ovl->members, l, overlay)
1771      _overlay_group_color_update(overlay->grp, c);
1772 }
1773
1774 static void
1775 _overlay_class_free(Overlay_Class *clas)
1776 {
1777    Eina_List *l;
1778    Elm_Map_Overlay *overlay;
1779
1780    EINA_SAFETY_ON_NULL_RETURN(clas);
1781
1782    // Update class members' class contents
1783    EINA_LIST_FOREACH(clas->members, l, overlay)
1784      {
1785         overlay->grp->klass = NULL;
1786         _overlay_group_content_update(overlay->grp, NULL, NULL);
1787         _overlay_group_icon_update(overlay->grp, NULL);
1788
1789         if (overlay->type == ELM_MAP_OVERLAY_TYPE_DEFAULT)
1790           {
1791              _overlay_default_class_content_update(overlay->ovl, NULL);
1792              _overlay_default_class_icon_update(overlay->ovl, NULL);
1793           }
1794      }
1795    if (clas->icon) evas_object_del(clas->icon);
1796    if (clas->members) eina_list_free(clas->members);
1797
1798    free(clas);
1799 }
1800
1801 static Overlay_Class *
1802 _overlay_class_new(Elm_Map_Smart_Data *sd)
1803 {
1804    Overlay_Class *ovl;
1805
1806    ovl = ELM_NEW(Overlay_Class);
1807    ovl->wsd = sd;
1808    ovl->icon = NULL;
1809    ovl->zoom_max = OVERLAY_CLASS_ZOOM_MAX;
1810
1811    return ovl;
1812 }
1813
1814 static void
1815 _overlay_bubble_coord_update(Overlay_Bubble *bubble)
1816 {
1817    EINA_SAFETY_ON_NULL_RETURN(bubble);
1818
1819    if (bubble->pobj)
1820      {
1821         Evas_Coord x, y, w, h;
1822
1823         evas_object_geometry_get(bubble->pobj, &x, &y, &w, &h);
1824         bubble->x = x + (w / 2);
1825         bubble->y = y - (bubble->h / 2);
1826         _canvas_to_coord
1827           (bubble->wsd, bubble->x, bubble->y, &(bubble->x), &(bubble->y));
1828         _coord_to_region_convert
1829           (bubble->wsd, bubble->x, bubble->y, bubble->wsd->size.w,
1830           &(bubble->lon), &(bubble->lat));
1831      }
1832    else
1833      {
1834         _region_to_coord_convert(bubble->wsd, bubble->lon, bubble->lat,
1835                                  bubble->wsd->size.w, &bubble->x, &bubble->y);
1836      }
1837 }
1838
1839 static void
1840 _overlay_bubble_coord_get(Overlay_Bubble *bubble,
1841                           Evas_Coord *x,
1842                           Evas_Coord *y,
1843                           Evas_Coord *w,
1844                           Evas_Coord *h)
1845 {
1846    EINA_SAFETY_ON_NULL_RETURN(bubble);
1847
1848    if (!(bubble->pobj))
1849      {
1850         if (x) *x = bubble->x;
1851         if (y) *y = bubble->y;
1852         if (w) *w = bubble->w;
1853         if (h) *h = bubble->h;
1854      }
1855    else
1856      {
1857         if (x) *x = 0;
1858         if (y) *y = 0;
1859         if (w) *w = 0;
1860         if (h) *h = 0;
1861      }
1862 }
1863
1864 static Eina_Bool
1865 _overlay_bubble_show_hide(Overlay_Bubble *bubble,
1866                           Eina_Bool visible)
1867 {
1868    EINA_SAFETY_ON_NULL_RETURN_VAL(bubble, EINA_FALSE);
1869    EINA_SAFETY_ON_NULL_RETURN_VAL(bubble->obj, EINA_FALSE);
1870
1871    if (!visible) evas_object_hide(bubble->obj);
1872    else if (bubble->pobj && !evas_object_visible_get(bubble->pobj))
1873      {
1874         evas_object_hide(bubble->obj);
1875         visible = EINA_FALSE;
1876      }
1877    else
1878      {
1879         _coord_to_canvas
1880           (bubble->wsd, bubble->x, bubble->y, &(bubble->x), &(bubble->y));
1881         _obj_place(bubble->obj, bubble->x - (bubble->w / 2),
1882                    bubble->y - (bubble->h / 2), bubble->w, bubble->h);
1883         evas_object_raise(bubble->obj);
1884      }
1885    return visible;
1886 }
1887
1888 static void
1889 _overlay_bubble_free(Overlay_Bubble *bubble)
1890 {
1891    EINA_SAFETY_ON_NULL_RETURN(bubble);
1892
1893    evas_object_del(bubble->bx);
1894    evas_object_del(bubble->sc);
1895    evas_object_del(bubble->obj);
1896
1897    free(bubble);
1898 }
1899
1900 static Overlay_Bubble *
1901 _overlay_bubble_new(Elm_Map_Overlay *overlay)
1902 {
1903    Evas_Coord h;
1904    const char *s;
1905    Overlay_Bubble *bubble;
1906
1907    EINA_SAFETY_ON_NULL_RETURN_VAL(overlay, NULL);
1908
1909    bubble = ELM_NEW(Overlay_Bubble);
1910    bubble->wsd = overlay->wsd;
1911
1912    bubble->obj =
1913      edje_object_add(evas_object_evas_get(ELM_WIDGET_DATA(overlay->wsd)->obj));
1914    elm_widget_theme_object_set
1915      (ELM_WIDGET_DATA(overlay->wsd)->obj, bubble->obj, "map", "marker_bubble",
1916      elm_widget_style_get(ELM_WIDGET_DATA(overlay->wsd)->obj));
1917
1918    evas_object_event_callback_add(bubble->obj, EVAS_CALLBACK_MOUSE_DOWN,
1919                                   _overlay_clicked_cb, overlay);
1920
1921    bubble->sc = elm_scroller_add(bubble->obj);
1922    elm_widget_style_set(bubble->sc, "map_bubble");
1923    elm_scroller_content_min_limit(bubble->sc, EINA_FALSE, EINA_TRUE);
1924    elm_scroller_policy_set
1925      (bubble->sc, ELM_SCROLLER_POLICY_AUTO, ELM_SCROLLER_POLICY_OFF);
1926    elm_scroller_bounce_set
1927      (bubble->sc, _elm_config->thumbscroll_bounce_enable, EINA_FALSE);
1928    edje_object_part_swallow(bubble->obj, "elm.swallow.content", bubble->sc);
1929
1930    bubble->bx = elm_box_add(bubble->sc);
1931    evas_object_size_hint_align_set(bubble->bx, EVAS_HINT_FILL, EVAS_HINT_FILL);
1932    evas_object_size_hint_weight_set
1933      (bubble->bx, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1934    elm_box_horizontal_set(bubble->bx, EINA_TRUE);
1935    elm_object_content_set(bubble->sc, bubble->bx);
1936
1937    s = edje_object_data_get(bubble->obj, "size_w");
1938    if (s) bubble->w = atoi(s);
1939    else bubble->w = 0;
1940
1941    edje_object_size_min_calc(bubble->obj, NULL, &(bubble->h));
1942    s = edje_object_data_get(bubble->obj, "size_h");
1943    if (s) h = atoi(s);
1944    else h = 0;
1945
1946    if (bubble->h < h) bubble->h = h;
1947
1948    bubble->lon = -1;
1949    bubble->lat = -1;
1950    bubble->x = -1;
1951    bubble->y = -1;
1952
1953    return bubble;
1954 }
1955
1956 static void
1957 _overlay_route_color_update(Overlay_Route *ovl,
1958                             Color c)
1959 {
1960    EINA_SAFETY_ON_NULL_RETURN(ovl);
1961
1962    evas_object_color_set(ovl->obj, c.r, c.g, c.b, c.a);
1963 }
1964
1965 static void
1966 _overlay_route_hide(Overlay_Route *ovl)
1967 {
1968    EINA_SAFETY_ON_NULL_RETURN(ovl);
1969
1970    evas_object_hide(ovl->obj);
1971 }
1972
1973 static void
1974 _overlay_route_show(Overlay_Route *r)
1975 {
1976    Path *p;
1977    Eina_List *l;
1978    Path_Node *n;
1979
1980    EINA_SAFETY_ON_NULL_RETURN(r);
1981    EINA_SAFETY_ON_NULL_RETURN(r->wsd);
1982
1983    evas_object_polygon_points_clear(r->obj);
1984    EINA_LIST_FOREACH(r->nodes, l, n)
1985      {
1986         p = eina_list_nth(r->paths, n->idx);
1987         if (!p) continue;
1988
1989         _region_to_coord_convert
1990           (r->wsd, n->pos.lon, n->pos.lat, r->wsd->size.w, &p->x, &p->y);
1991         _coord_to_canvas(r->wsd, p->x, p->y, &p->x, &p->y);
1992      }
1993    EINA_LIST_FOREACH(r->paths, l, p)
1994      evas_object_polygon_point_add(r->obj, p->x - 3, p->y - 3);
1995
1996    EINA_LIST_REVERSE_FOREACH(r->paths, l, p)
1997      evas_object_polygon_point_add(r->obj, p->x + 3, p->y + 3);
1998
1999    evas_object_show(r->obj);
2000 }
2001
2002 static void
2003 _overlay_route_free(Overlay_Route *route)
2004 {
2005    Path *p;
2006    Path_Node *n;
2007
2008    EINA_SAFETY_ON_NULL_RETURN(route);
2009
2010    evas_object_del(route->obj);
2011
2012    EINA_LIST_FREE (route->paths, p)
2013      free(p);
2014
2015    EINA_LIST_FREE (route->nodes, n)
2016      {
2017         if (n->pos.address) eina_stringshare_del(n->pos.address);
2018         free(n);
2019      }
2020
2021    free(route);
2022 }
2023
2024 static Overlay_Route *
2025 _overlay_route_new(Elm_Map_Smart_Data *sd,
2026                    const Elm_Map_Route *route,
2027                    Color c)
2028 {
2029    Eina_List *l;
2030    Path_Node *n;
2031    Overlay_Route *ovl;
2032
2033    EINA_SAFETY_ON_NULL_RETURN_VAL(route, NULL);
2034
2035    ovl = ELM_NEW(Overlay_Route);
2036    ovl->wsd = sd;
2037    ovl->obj =
2038      evas_object_polygon_add(evas_object_evas_get(ELM_WIDGET_DATA(sd)->obj));
2039    if (!strcmp(ovl->wsd->engine->name, INTERNAL_ENGINE_NAME))
2040      evas_object_smart_member_add(ovl->obj, sd->pan_obj);
2041    else
2042      evas_object_smart_member_add(ovl->obj, ELM_WIDGET_DATA(ovl->wsd)->obj);
2043
2044    _overlay_route_color_update(ovl, c);
2045
2046    EINA_LIST_FOREACH(route->nodes, l, n)
2047      {
2048         Path *path;
2049         Path_Node *node;
2050
2051         node = ELM_NEW(Path_Node);
2052         node->idx = n->idx;
2053         node->pos.lon = n->pos.lon;
2054         node->pos.lat = n->pos.lat;
2055         if (n->pos.address) node->pos.address = strdup(n->pos.address);
2056         ovl->nodes = eina_list_append(ovl->nodes, node);
2057
2058         path = ELM_NEW(Path);
2059         ovl->paths = eina_list_append(ovl->paths, path);
2060      }
2061
2062    return ovl;
2063 }
2064
2065 static void
2066 _overlay_line_color_update(Overlay_Line *ovl,
2067                            Color c)
2068 {
2069    EINA_SAFETY_ON_NULL_RETURN(ovl);
2070
2071    evas_object_color_set(ovl->obj, c.r, c.g, c.b, c.a);
2072 }
2073
2074 static void
2075 _overlay_line_hide(Overlay_Line *ovl)
2076 {
2077    EINA_SAFETY_ON_NULL_RETURN(ovl);
2078
2079    if (ovl->obj) evas_object_hide(ovl->obj);
2080 }
2081
2082 static void
2083 _overlay_line_show(Overlay_Line *ovl)
2084 {
2085    Evas_Coord fx, fy, tx, ty;
2086    Elm_Map_Smart_Data *sd = ovl->wsd;
2087
2088    _region_to_coord_convert(sd, ovl->flon, ovl->flat, sd->size.w, &fx, &fy);
2089    _region_to_coord_convert(sd, ovl->tlon, ovl->tlat, sd->size.w, &tx, &ty);
2090    _coord_to_canvas(sd, fx, fy, &fx, &fy);
2091    _coord_to_canvas(sd, tx, ty, &tx, &ty);
2092    evas_object_line_xy_set(ovl->obj, fx, fy, tx, ty);
2093    evas_object_show(ovl->obj);
2094 }
2095
2096 static void
2097 _overlay_line_free(Overlay_Line *ovl)
2098 {
2099    EINA_SAFETY_ON_NULL_RETURN(ovl);
2100
2101    evas_object_del(ovl->obj);
2102    free(ovl);
2103 }
2104
2105 static Overlay_Line *
2106 _overlay_line_new(Elm_Map_Smart_Data *sd,
2107                   double flon,
2108                   double flat,
2109                   double tlon,
2110                   double tlat,
2111                   Color c)
2112 {
2113    Overlay_Line *ovl;
2114
2115    ovl = ELM_NEW(Overlay_Line);
2116    ovl->wsd = sd;
2117    ovl->flon = flon;
2118    ovl->flat = flat;
2119    ovl->tlon = tlon;
2120    ovl->tlat = tlat;
2121    ovl->obj =
2122      evas_object_line_add(evas_object_evas_get(ELM_WIDGET_DATA(sd)->obj));
2123    evas_object_smart_member_add(ovl->obj, sd->pan_obj);
2124    _overlay_line_color_update(ovl, c);
2125
2126    return ovl;
2127 }
2128
2129 static void
2130 _overlay_polygon_color_update(Overlay_Polygon *ovl,
2131                               Color c)
2132 {
2133    EINA_SAFETY_ON_NULL_RETURN(ovl);
2134
2135    evas_object_color_set(ovl->obj, c.r, c.g, c.b, c.a);
2136 }
2137
2138 static void
2139 _overlay_polygon_hide(Overlay_Polygon *ovl)
2140 {
2141    EINA_SAFETY_ON_NULL_RETURN(ovl);
2142
2143    if (ovl->obj) evas_object_hide(ovl->obj);
2144 }
2145
2146 static void
2147 _overlay_polygon_show(Overlay_Polygon *ovl)
2148 {
2149    Eina_List *l;
2150    Region *r;
2151    Elm_Map_Smart_Data *sd;
2152
2153    EINA_SAFETY_ON_NULL_RETURN(ovl);
2154
2155    sd = ovl->wsd;
2156
2157    evas_object_polygon_points_clear(ovl->obj);
2158    EINA_LIST_FOREACH(ovl->regions, l, r)
2159      {
2160         Evas_Coord x, y;
2161
2162         _region_to_coord_convert(sd, r->lon, r->lat, sd->size.w, &x, &y);
2163         _coord_to_canvas(sd, x, y, &x, &y);
2164         evas_object_polygon_point_add(ovl->obj, x, y);
2165      }
2166    evas_object_show(ovl->obj);
2167 }
2168
2169 static void
2170 _overlay_polygon_free(Overlay_Polygon *ovl)
2171 {
2172    Region *r;
2173
2174    EINA_SAFETY_ON_NULL_RETURN(ovl);
2175
2176    evas_object_del(ovl->obj);
2177
2178    EINA_LIST_FREE (ovl->regions, r)
2179      free(r);
2180
2181    free(ovl);
2182 }
2183
2184 static Overlay_Polygon *
2185 _overlay_polygon_new(Elm_Map_Smart_Data *sd, Color c)
2186 {
2187    Overlay_Polygon *ovl;
2188
2189    ovl = ELM_NEW(Overlay_Polygon);
2190    ovl->wsd = sd;
2191    ovl->obj =
2192      evas_object_polygon_add(evas_object_evas_get(ELM_WIDGET_DATA(sd)->obj));
2193    evas_object_smart_member_add(ovl->obj, sd->pan_obj);
2194    _overlay_polygon_color_update(ovl, c);
2195
2196    return ovl;
2197 }
2198
2199 static void
2200 _overlay_circle_color_update(Overlay_Circle *ovl,
2201                              Color c)
2202 {
2203    Evas_Object *obj;
2204
2205    EINA_SAFETY_ON_NULL_RETURN(ovl);
2206
2207    obj = elm_layout_edje_get(ovl->obj);
2208    evas_object_color_set(obj, c.r, c.g, c.b, c.a);
2209 }
2210
2211 static void
2212 _overlay_circle_hide(Overlay_Circle *ovl)
2213 {
2214    EINA_SAFETY_ON_NULL_RETURN(ovl);
2215
2216    if (ovl->obj) evas_object_hide(ovl->obj);
2217 }
2218
2219 static void
2220 _overlay_circle_show(Overlay_Circle *ovl)
2221 {
2222    double r;
2223    Evas_Coord x, y;
2224    Elm_Map_Smart_Data *sd;
2225
2226    EINA_SAFETY_ON_NULL_RETURN(ovl);
2227
2228    sd = ovl->wsd;
2229
2230    r = (ovl->ratio) * sd->size.w;
2231    _region_to_coord_convert(sd, ovl->lon, ovl->lat, sd->size.w, &x, &y);
2232    _coord_to_canvas(sd, x, y, &x, &y);
2233    _obj_place(ovl->obj, x - r, y - r, r * 2, r * 2);
2234 }
2235
2236 static void
2237 _overlay_circle_free(Overlay_Circle *ovl)
2238 {
2239    EINA_SAFETY_ON_NULL_RETURN(ovl);
2240
2241    evas_object_del(ovl->obj);
2242    free(ovl);
2243 }
2244
2245 static Overlay_Circle *
2246 _overlay_circle_new(Elm_Map_Smart_Data *sd,
2247                     double lon,
2248                     double lat,
2249                     double radius,
2250                     Color c)
2251 {
2252    Overlay_Circle *ovl;
2253
2254    ovl = ELM_NEW(Overlay_Circle);
2255    ovl->wsd = sd;
2256    ovl->lon = lon;
2257    ovl->lat = lat;
2258    ovl->radius = radius;
2259    ovl->ratio = radius / sd->size.w;
2260
2261    ovl->obj = elm_layout_add(ELM_WIDGET_DATA(sd)->obj);
2262    evas_object_smart_member_add(ovl->obj, sd->pan_obj);
2263    evas_object_stack_above(ovl->obj, sd->sep_maps_overlays);
2264    elm_layout_theme_set(ovl->obj, "map/circle", "base",
2265                         elm_widget_style_get(ELM_WIDGET_DATA(sd)->obj));
2266    _overlay_circle_color_update(ovl, c);
2267
2268    return ovl;
2269 }
2270
2271 static void
2272 _overlay_scale_color_update(Overlay_Scale *ovl,
2273                             Color c)
2274 {
2275    EINA_SAFETY_ON_NULL_RETURN(ovl);
2276
2277    evas_object_color_set(ovl->obj, c.r, c.g, c.b, c.a);
2278 }
2279
2280 static void
2281 _overlay_scale_hide(Overlay_Scale *ovl)
2282 {
2283    EINA_SAFETY_ON_NULL_RETURN(ovl);
2284
2285    if (ovl->obj) evas_object_hide(ovl->obj);
2286 }
2287
2288 static void
2289 _overlay_scale_show(Overlay_Scale *ovl)
2290 {
2291    double text;
2292    Evas_Coord w;
2293    char buf[32];
2294    double meter;
2295    double lon, lat;
2296    Elm_Map_Smart_Data *sd;
2297
2298    EINA_SAFETY_ON_NULL_RETURN(ovl);
2299
2300    sd = ovl->wsd;
2301
2302    if ((int)(sizeof(_scale_tb)/sizeof(double)) <= sd->zoom)
2303      {
2304         ERR("Zoom level is too high");
2305         return;
2306      }
2307
2308    elm_map_region_get(ELM_WIDGET_DATA(sd)->obj, &lon, &lat);
2309    meter =
2310      sd->src_tile->scale_cb(ELM_WIDGET_DATA(sd)->obj, lon, lat, sd->zoom);
2311
2312    if (meter == 0)
2313      {
2314         ERR("Scale callback returns a value below zero");
2315         return;
2316      }
2317
2318    w = (_scale_tb[sd->zoom] / meter) * (sd->zoom_detail - sd->zoom + 1);
2319
2320    text = _scale_tb[sd->zoom] / 1000;
2321    if (text < 1) snprintf(buf, sizeof(buf), "%d m", (int)(text * 1000));
2322    else snprintf(buf, sizeof(buf), "%d km", (int)text);
2323
2324    elm_layout_text_set(ovl->obj, "elm.text", buf);
2325    _obj_place(ovl->obj, ovl->x, ovl->y, w, ovl->h);
2326 }
2327
2328 static void
2329 _overlay_scale_free(Overlay_Scale *ovl)
2330 {
2331    EINA_SAFETY_ON_NULL_RETURN(ovl);
2332
2333    evas_object_del(ovl->obj);
2334    free(ovl);
2335 }
2336
2337 static Overlay_Scale *
2338 _overlay_scale_new(Elm_Map_Smart_Data *sd,
2339                    Evas_Coord x,
2340                    Evas_Coord y,
2341                    Color c)
2342 {
2343    const char *s;
2344    Overlay_Scale *ovl;
2345
2346    ovl = ELM_NEW(Overlay_Scale);
2347    ovl->wsd = sd;
2348    ovl->x = x;
2349    ovl->y = y;
2350
2351    ovl->obj = elm_layout_add(ELM_WIDGET_DATA(sd)->obj);
2352    evas_object_smart_member_add(ovl->obj, sd->pan_obj);
2353    evas_object_stack_above(ovl->obj, sd->sep_maps_overlays);
2354    elm_layout_theme_set(ovl->obj, "map/scale", "base",
2355                         elm_widget_style_get(ELM_WIDGET_DATA(sd)->obj));
2356    s = edje_object_data_get(elm_layout_edje_get(ovl->obj), "size_w");
2357
2358    if (s) ovl->w = atoi(s);
2359    else ovl->w = 100;
2360
2361    s = edje_object_data_get(elm_layout_edje_get(ovl->obj), "size_h");
2362    if (s) ovl->h = atoi(s);
2363    else ovl->h = 60;
2364
2365    _overlay_scale_color_update(ovl, c);
2366
2367    return ovl;
2368 }
2369
2370 static void
2371 _overlay_grouping(Eina_List *clas_membs,
2372                   Elm_Map_Overlay *boss)
2373 {
2374    Eina_List *l;
2375    Elm_Map_Overlay *memb;
2376    Eina_List *grp_membs = NULL;
2377    int sum_x = 0, sum_y = 0, cnt = 0;
2378    Evas_Coord bx = 0, by = 0, bw = 0, bh = 0;
2379
2380    EINA_SAFETY_ON_NULL_RETURN(clas_membs);
2381    EINA_SAFETY_ON_NULL_RETURN(boss);
2382
2383    if (boss->type == ELM_MAP_OVERLAY_TYPE_DEFAULT)
2384      _overlay_default_coord_get(boss->ovl, &bx, &by, &bw, &bh);
2385    else if (boss->type == ELM_MAP_OVERLAY_TYPE_BUBBLE)
2386      _overlay_bubble_coord_get(boss->ovl, &bx, &by, &bw, &bh);
2387
2388    EINA_LIST_FOREACH(clas_membs, l, memb)
2389      {
2390         Evas_Coord x = 0, y = 0, w = 0, h = 0;
2391
2392         if (boss == memb || memb->grp->in) continue;
2393         if ((memb->hide) || (memb->zoom_min > memb->wsd->zoom)) continue;
2394
2395         if (memb->type == ELM_MAP_OVERLAY_TYPE_DEFAULT)
2396           _overlay_default_coord_get(memb->ovl, &x, &y, &w, &h);
2397         else if (memb->type == ELM_MAP_OVERLAY_TYPE_BUBBLE)
2398           _overlay_bubble_coord_get(memb->ovl, &x, &y, &w, &h);
2399
2400         if (bw <= 0 || bh <= 0 || w <= 0 || h <= 0) continue;
2401         if (ELM_RECTS_INTERSECT(x, y, w, h, bx, by,
2402                                 bw * OVERLAY_GROUPING_SCALE,
2403                                 bh * OVERLAY_GROUPING_SCALE))
2404           {
2405              // Join group.
2406              memb->grp->boss = EINA_FALSE;
2407              memb->grp->in = EINA_TRUE;
2408              sum_x += x;
2409              sum_y += y;
2410              cnt++;
2411              grp_membs = eina_list_append(grp_membs, memb);
2412           }
2413      }
2414
2415    if (cnt >= 1)
2416      {
2417         // Mark as boss
2418         boss->grp->boss = EINA_TRUE;
2419         boss->grp->in = EINA_TRUE;
2420         sum_x = (sum_x + bx) / (cnt + 1);
2421         sum_y = (sum_y + by) / (cnt + 1);
2422         grp_membs = eina_list_append(grp_membs, boss);
2423         _overlay_group_coord_member_update(boss->grp, sum_x, sum_y, grp_membs);
2424
2425         // Append group to all overlay list
2426         boss->wsd->group_overlays =
2427           eina_list_append(boss->wsd->group_overlays, boss->grp->overlay);
2428      }
2429 }
2430
2431 static void
2432 _overlay_show(Elm_Map_Overlay *overlay)
2433 {
2434    Elm_Map_Smart_Data *sd = overlay->wsd;
2435
2436    if (overlay->paused) return;
2437    if ((overlay->grp) && (overlay->grp->klass) && (overlay->grp->klass->paused))
2438      return;
2439
2440    overlay->visible = EINA_TRUE;
2441    if (overlay->type == ELM_MAP_OVERLAY_TYPE_CLASS)
2442      {
2443         overlay->visible = EINA_FALSE;
2444         return;
2445      }
2446    if (overlay->grp)
2447      {
2448         if ((overlay->grp->in) ||
2449             (overlay->hide) || (overlay->zoom_min > sd->zoom))
2450           overlay->visible = EINA_FALSE;
2451
2452         if ((overlay->grp->klass) &&
2453             ((overlay->grp->klass->hide) ||
2454              (overlay->grp->klass->zoom_min > sd->zoom)))
2455           overlay->visible = EINA_FALSE;
2456      }
2457
2458    switch (overlay->type)
2459      {
2460       case ELM_MAP_OVERLAY_TYPE_DEFAULT:
2461         if (overlay->visible) _overlay_default_show(overlay->ovl);
2462         else _overlay_default_hide(overlay->ovl);
2463         break;
2464
2465       case ELM_MAP_OVERLAY_TYPE_GROUP:
2466         if (overlay->visible) _overlay_group_show(overlay->ovl);
2467         else _overlay_group_hide(overlay->ovl);
2468         break;
2469
2470       case ELM_MAP_OVERLAY_TYPE_BUBBLE:
2471         overlay->visible =
2472           _overlay_bubble_show_hide(overlay->ovl, overlay->visible);
2473         break;
2474
2475       case ELM_MAP_OVERLAY_TYPE_ROUTE:
2476         if (overlay->visible) _overlay_route_show(overlay->ovl);
2477         else _overlay_route_hide(overlay->ovl);
2478         break;
2479
2480       case ELM_MAP_OVERLAY_TYPE_LINE:
2481         if (overlay->visible) _overlay_line_show(overlay->ovl);
2482         else _overlay_line_hide(overlay->ovl);
2483         break;
2484
2485       case ELM_MAP_OVERLAY_TYPE_POLYGON:
2486         if (overlay->visible) _overlay_polygon_show(overlay->ovl);
2487         else _overlay_polygon_hide(overlay->ovl);
2488         break;
2489
2490       case ELM_MAP_OVERLAY_TYPE_CIRCLE:
2491         if (overlay->visible) _overlay_circle_show(overlay->ovl);
2492         else _overlay_circle_hide(overlay->ovl);
2493         break;
2494
2495       case ELM_MAP_OVERLAY_TYPE_SCALE:
2496         if (overlay->visible) _overlay_scale_show(overlay->ovl);
2497         else _overlay_scale_hide(overlay->ovl);
2498         break;
2499
2500       default:
2501         ERR("Invalid overlay type to show: %d", overlay->type);
2502      }
2503 }
2504
2505 static void
2506 _overlay_place(Elm_Map_Smart_Data *sd)
2507 {
2508    Eina_List *l, *ll;
2509    Elm_Map_Overlay *overlay;
2510
2511    eina_list_free(sd->group_overlays);
2512    sd->group_overlays = NULL;
2513
2514    EINA_LIST_FOREACH(sd->overlays, l, overlay)
2515      {
2516         // Reset groups
2517         if (overlay->type == ELM_MAP_OVERLAY_TYPE_CLASS) continue;
2518         overlay->grp->in = EINA_FALSE;
2519         overlay->grp->boss = EINA_FALSE;
2520         _overlay_group_hide(overlay->grp);
2521
2522         // Update overlays' coord
2523         if (overlay->type == ELM_MAP_OVERLAY_TYPE_DEFAULT)
2524           _overlay_default_coord_update(overlay->ovl);
2525         else if (overlay->type == ELM_MAP_OVERLAY_TYPE_BUBBLE)
2526           _overlay_bubble_coord_update(overlay->ovl);
2527      }
2528
2529    // Classify into group boss or follwer
2530    EINA_LIST_FOREACH(sd->overlays, l, overlay)
2531      {
2532         Elm_Map_Overlay *boss;
2533         Overlay_Class *clas;
2534
2535         if (overlay->type != ELM_MAP_OVERLAY_TYPE_CLASS) continue;
2536         if (overlay->hide || (overlay->zoom_min > sd->zoom)) continue;
2537
2538         clas = overlay->ovl;
2539         if (clas->zoom_max < sd->zoom) continue;
2540         EINA_LIST_FOREACH(clas->members, ll, boss)
2541           {
2542              if (boss->type == ELM_MAP_OVERLAY_TYPE_CLASS) continue;
2543              if (boss->hide || (boss->zoom_min > sd->zoom)) continue;
2544              if (boss->grp->in) continue;
2545              _overlay_grouping(clas->members, boss);
2546           }
2547      }
2548
2549    // Place group overlays and overlays
2550    EINA_LIST_FOREACH(sd->group_overlays, l, overlay)
2551      _overlay_show(overlay);
2552    EINA_LIST_FOREACH(sd->overlays, l, overlay)
2553      _overlay_show(overlay);
2554 }
2555
2556 static Evas_Object *
2557 _overlay_obj_get(const Elm_Map_Overlay *overlay)
2558 {
2559    EINA_SAFETY_ON_NULL_RETURN_VAL(overlay, NULL);
2560
2561    if (overlay->type == ELM_MAP_OVERLAY_TYPE_GROUP)
2562      {
2563         Overlay_Group *ovl = overlay->ovl;
2564         Overlay_Default *df = ovl->ovl;
2565
2566         return df->layout;
2567      }
2568    else if (overlay->type == ELM_MAP_OVERLAY_TYPE_DEFAULT)
2569      {
2570         Overlay_Default *ovl = overlay->ovl;
2571
2572         return ovl->layout;
2573      }
2574    else
2575      {
2576         ERR("Not supported overlay type: %d", overlay->type);
2577         return NULL;
2578      }
2579 }
2580
2581 static Eina_Bool
2582 _xml_name_attrs_dump_cb(void *data,
2583                         const char *key,
2584                         const char *value)
2585 {
2586    Name_Dump *dump = (Name_Dump *)data;
2587
2588    EINA_SAFETY_ON_NULL_RETURN_VAL(dump, EINA_FALSE);
2589    EINA_SAFETY_ON_NULL_RETURN_VAL(key, EINA_FALSE);
2590    EINA_SAFETY_ON_NULL_RETURN_VAL(value, EINA_FALSE);
2591
2592    if (!strncmp(key, NOMINATIM_ATTR_LON, sizeof(NOMINATIM_ATTR_LON)))
2593      dump->lon = _elm_atof(value);
2594    else if (!strncmp(key, NOMINATIM_ATTR_LAT, sizeof(NOMINATIM_ATTR_LAT)))
2595      dump->lat = _elm_atof(value);
2596    else if (!strncmp(key, NOMINATIM_ATTR_ADDRESS, sizeof(NOMINATIM_ATTR_ADDRESS)))
2597      {
2598         if (!dump->address)
2599           dump->address = strdup(value);
2600      }
2601
2602    return EINA_TRUE;
2603 }
2604
2605 static Eina_Bool
2606 _xml_route_dump_cb(void *data,
2607                    Eina_Simple_XML_Type type,
2608                    const char *value,
2609                    unsigned offset __UNUSED__,
2610                    unsigned length)
2611 {
2612    Route_Dump *dump = data;
2613
2614    EINA_SAFETY_ON_NULL_RETURN_VAL(dump, EINA_FALSE);
2615    EINA_SAFETY_ON_NULL_RETURN_VAL(value, EINA_FALSE);
2616
2617    switch (type)
2618      {
2619       case EINA_SIMPLE_XML_OPEN:
2620       case EINA_SIMPLE_XML_OPEN_EMPTY:
2621       {
2622          const char *attrs;
2623
2624          attrs = eina_simple_xml_tag_attributes_find(value, length);
2625          if (!attrs)
2626            {
2627               if (!strncmp(value, YOURS_DISTANCE, length))
2628                 dump->id = ROUTE_XML_DISTANCE;
2629               else if (!strncmp(value, YOURS_DESCRIPTION, length))
2630                 dump->id = ROUTE_XML_DESCRIPTION;
2631               else if (!strncmp(value, YOURS_COORDINATES, length))
2632                 dump->id = ROUTE_XML_COORDINATES;
2633               else dump->id = ROUTE_XML_NONE;
2634            }
2635       }
2636       break;
2637
2638       case EINA_SIMPLE_XML_DATA:
2639       {
2640          char *buf = malloc(length);
2641
2642          if (!buf) return EINA_FALSE;
2643
2644          snprintf(buf, length, "%s", value);
2645          if (dump->id == ROUTE_XML_DISTANCE) dump->distance = _elm_atof(buf);
2646          else if (!(dump->description) && (dump->id == ROUTE_XML_DESCRIPTION))
2647            dump->description = strdup(buf);
2648          else if (dump->id == ROUTE_XML_COORDINATES)
2649            dump->coordinates = strdup(buf);
2650
2651          free(buf);
2652       }
2653       break;
2654
2655       default:
2656         break;
2657      }
2658
2659    return EINA_TRUE;
2660 }
2661
2662 static Eina_Bool
2663 _xml_name_dump_cb(void *data,
2664                   Eina_Simple_XML_Type type,
2665                   const char *value,
2666                   unsigned offset __UNUSED__,
2667                   unsigned length)
2668 {
2669    Name_Dump *dump = data;
2670
2671    EINA_SAFETY_ON_NULL_RETURN_VAL(dump, EINA_FALSE);
2672    EINA_SAFETY_ON_NULL_RETURN_VAL(value, EINA_FALSE);
2673
2674    switch (type)
2675      {
2676       case EINA_SIMPLE_XML_OPEN:
2677       case EINA_SIMPLE_XML_OPEN_EMPTY:
2678       {
2679          const char *attrs;
2680          attrs = eina_simple_xml_tag_attributes_find(value, length);
2681          if (attrs)
2682            {
2683               if (!strncmp(value, NOMINATIM_RESULT,
2684                            sizeof(NOMINATIM_RESULT) - 1))
2685                 dump->id = NAME_XML_NAME;
2686               else dump->id = NAME_XML_NONE;
2687
2688               eina_simple_xml_attributes_parse
2689                 (attrs, length - (attrs - value), _xml_name_attrs_dump_cb,
2690                 dump);
2691            }
2692       }
2693       break;
2694
2695       case EINA_SIMPLE_XML_DATA:
2696       {
2697          char *buf = malloc(length + 1);
2698
2699          if (!buf) return EINA_FALSE;
2700          snprintf(buf, length + 1, "%s", value);
2701          if (dump->id == NAME_XML_NAME) dump->address = strdup(buf);
2702          free(buf);
2703       }
2704       break;
2705
2706       default:
2707         break;
2708      }
2709
2710    return EINA_TRUE;
2711 }
2712
2713 static Eina_Bool
2714 _xml_name_dump_list_cb(void *data,
2715                        Eina_Simple_XML_Type type,
2716                        const char *value,
2717                        unsigned offset,
2718                        unsigned length)
2719 {
2720    Elm_Map_Name_List *name_list = data;
2721    Elm_Map_Name *name;
2722    Name_Dump dump = {0, NULL, 0.0, 0.0};
2723    _xml_name_dump_cb(&dump, type, value, offset, length);
2724    name = calloc(1, sizeof(Elm_Map_Name));
2725    if (!name) return EINA_FALSE;
2726    if (dump.address)
2727      {
2728         name->address = strdup(dump.address);
2729         name->lon = dump.lon;
2730         name->lat = dump.lat;
2731         name->wsd = name_list->wsd;
2732         name_list->names = eina_list_append(name_list->names, name);
2733         name->wsd->names = eina_list_append(name->wsd->names, name);
2734      }
2735   else
2736     free(name);
2737
2738    return EINA_TRUE;
2739 }
2740
2741
2742 static void
2743 _kml_parse(Elm_Map_Route *r)
2744 {
2745    FILE *f;
2746    char **str;
2747    double lon, lat;
2748    unsigned int ele, idx;
2749
2750    EINA_SAFETY_ON_NULL_RETURN(r);
2751    EINA_SAFETY_ON_NULL_RETURN(r->fname);
2752
2753    Route_Dump dump = {0, r->fname, 0.0, NULL, NULL};
2754
2755    f = fopen(r->fname, "rb");
2756    if (f)
2757      {
2758         long sz;
2759
2760         fseek(f, 0, SEEK_END);
2761         sz = ftell(f);
2762         if (sz > 0)
2763           {
2764              char *buf = malloc(sz + 1);
2765              if (buf)
2766                {
2767                   memset(buf, 0, sz + 1);
2768                   rewind(f);
2769                   if (fread(buf, 1, sz, f))
2770                     {
2771                        eina_simple_xml_parse
2772                          (buf, sz, EINA_TRUE, _xml_route_dump_cb, &dump);
2773                     }
2774                   else
2775                     free(buf);
2776                }
2777           }
2778         fclose(f);
2779
2780         if (dump.distance) r->info.distance = dump.distance;
2781         if (dump.description)
2782           {
2783              eina_stringshare_replace(&r->info.waypoints, dump.description);
2784              str = eina_str_split_full(dump.description, "\n", 0, &ele);
2785              r->info.waypoint_count = ele;
2786              for (idx = 0; idx < ele; idx++)
2787                {
2788                   Path_Waypoint *wp = ELM_NEW(Path_Waypoint);
2789
2790                   if (wp)
2791                     {
2792                        wp->wsd = r->wsd;
2793                        wp->point = eina_stringshare_add(str[idx]);
2794                        DBG("%s", str[idx]);
2795                        r->waypoint = eina_list_append(r->waypoint, wp);
2796                     }
2797                }
2798              if (str && str[0])
2799                {
2800                   free(str[0]);
2801                   free(str);
2802                }
2803           }
2804         else WRN("description is not found !");
2805
2806         if (dump.coordinates)
2807           {
2808              eina_stringshare_replace(&r->info.nodes, dump.coordinates);
2809              str = eina_str_split_full(dump.coordinates, "\n", 0, &ele);
2810              r->info.node_count = ele;
2811              for (idx = 0; idx < ele; idx++)
2812                {
2813                   Path_Node *n = ELM_NEW(Path_Node);
2814
2815                   sscanf(str[idx], "%lf,%lf", &lon, &lat);
2816                   if (n)
2817                     {
2818                        n->wsd = r->wsd;
2819                        n->pos.lon = lon;
2820                        n->pos.lat = lat;
2821                        n->idx = idx;
2822                        DBG("%lf:%lf", lon, lat);
2823                        n->pos.address = NULL;
2824                        r->nodes = eina_list_append(r->nodes, n);
2825                     }
2826                }
2827              if (str && str[0])
2828                {
2829                   free(str[0]);
2830                   free(str);
2831                }
2832           }
2833      }
2834 }
2835
2836 static void
2837 _name_parse(Elm_Map_Name *n)
2838 {
2839    FILE *f;
2840
2841    EINA_SAFETY_ON_NULL_RETURN(n);
2842    EINA_SAFETY_ON_NULL_RETURN(n->fname);
2843
2844    Name_Dump dump = {0, NULL, 0.0, 0.0};
2845
2846    f = fopen(n->fname, "rb");
2847    if (f)
2848      {
2849         long sz;
2850
2851         fseek(f, 0, SEEK_END);
2852         sz = ftell(f);
2853         if (sz > 0)
2854           {
2855              char *buf = malloc(sz + 1);
2856              if (buf)
2857                {
2858                   memset(buf, 0, sz + 1);
2859                   rewind(f);
2860                   if (fread(buf, 1, sz, f))
2861                     {
2862                        eina_simple_xml_parse
2863                          (buf, sz, EINA_TRUE, _xml_name_dump_cb, &dump);
2864                     }
2865                   free(buf);
2866                }
2867           }
2868         fclose(f);
2869
2870         if (dump.address)
2871           {
2872              INF("[%lf : %lf] ADDRESS : %s", n->lon, n->lat, dump.address);
2873              n->address = strdup(dump.address);
2874           }
2875         n->lon = dump.lon;
2876         n->lat = dump.lat;
2877      }
2878 }
2879
2880 static void
2881 _name_list_parse(Elm_Map_Name_List *nl)
2882 {
2883    FILE *f;
2884    EINA_SAFETY_ON_NULL_RETURN(nl);
2885    EINA_SAFETY_ON_NULL_RETURN(nl->fname);
2886
2887    f = fopen(nl->fname, "rb");
2888    if (f)
2889      {
2890         long sz;
2891
2892         fseek(f, 0, SEEK_END);
2893         sz = ftell(f);
2894         if (sz > 0)
2895           {
2896              char *buf = malloc(sz + 1);
2897              if (buf)
2898                {
2899                   memset(buf, 0, sz + 1);
2900                   rewind(f);
2901                   if (fread(buf, 1, sz, f))
2902                     {
2903                        eina_simple_xml_parse
2904                          (buf, sz, EINA_TRUE, _xml_name_dump_list_cb, nl);
2905                     }
2906                   else
2907                     free(buf);
2908                }
2909           }
2910         fclose(f);
2911      }
2912 }
2913
2914 static void
2915 _route_cb(void *data,
2916           const char *file,
2917           int status)
2918 {
2919    Elm_Map_Route *route;
2920    Elm_Map_Smart_Data *sd;
2921
2922    EINA_SAFETY_ON_NULL_RETURN(data);
2923    EINA_SAFETY_ON_NULL_RETURN(file);
2924
2925    route = data;
2926    sd = route->wsd;
2927
2928    route->job = NULL;
2929    if (status == 200)
2930      {
2931         _kml_parse(route);
2932         INF("Route request success from (%lf, %lf) to (%lf, %lf)",
2933             route->flon, route->flat, route->tlon, route->tlat);
2934         if (route->cb) route->cb(route->data, ELM_WIDGET_DATA(sd)->obj, route);
2935         evas_object_smart_callback_call
2936           (ELM_WIDGET_DATA(sd)->obj, SIG_ROUTE_LOADED, NULL);
2937      }
2938    else
2939      {
2940         ERR("Route request failed: %d", status);
2941         if (route->cb) route->cb(route->data, ELM_WIDGET_DATA(sd)->obj, NULL);
2942         evas_object_smart_callback_call
2943           (ELM_WIDGET_DATA(sd)->obj, SIG_ROUTE_LOADED_FAIL, NULL);
2944      }
2945
2946    edje_object_signal_emit(ELM_WIDGET_DATA(sd)->resize_obj,
2947                            "elm,state,busy,stop", "elm");
2948 }
2949
2950 static void
2951 _name_cb(void *data,
2952          const char *file,
2953          int status)
2954 {
2955    Elm_Map_Name *name;
2956    Elm_Map_Smart_Data *sd;
2957
2958    EINA_SAFETY_ON_NULL_RETURN(data);
2959    EINA_SAFETY_ON_NULL_RETURN(file);
2960
2961    name = data;
2962    sd = name->wsd;
2963
2964    name->job = NULL;
2965    if (status == 200)
2966      {
2967         _name_parse(name);
2968         INF("Name request success address:%s, lon:%lf, lat:%lf",
2969             name->address, name->lon, name->lat);
2970         if (name->cb) name->cb(name->data, ELM_WIDGET_DATA(sd)->obj, name);
2971         evas_object_smart_callback_call
2972           (ELM_WIDGET_DATA(sd)->obj, SIG_NAME_LOADED, NULL);
2973      }
2974    else
2975      {
2976         ERR("Name request failed: %d", status);
2977         if (name->cb) name->cb(name->data, ELM_WIDGET_DATA(sd)->obj, NULL);
2978         evas_object_smart_callback_call
2979           (ELM_WIDGET_DATA(sd)->obj, SIG_NAME_LOADED_FAIL, NULL);
2980      }
2981    edje_object_signal_emit(ELM_WIDGET_DATA(sd)->resize_obj,
2982                            "elm,state,busy,stop", "elm");
2983 }
2984
2985 static void
2986 _name_list_cb(void *data,
2987               const char *file,
2988               int status)
2989 {
2990    Elm_Map_Name_List *name_list;
2991    Elm_Map_Smart_Data *sd;
2992
2993    EINA_SAFETY_ON_NULL_RETURN(data);
2994    EINA_SAFETY_ON_NULL_RETURN(file);
2995
2996    name_list = data;
2997    sd = name_list->wsd;
2998
2999    name_list->job = NULL;
3000    if (status == 200)
3001      {
3002         _name_list_parse(name_list);
3003         INF("Name List request success address");
3004         if (name_list->cb)
3005           name_list->cb(name_list->data, ELM_WIDGET_DATA(sd)->obj,
3006                         name_list->names);
3007         evas_object_smart_callback_call
3008           (ELM_WIDGET_DATA(sd)->obj, SIG_NAME_LOADED, NULL);
3009      }
3010    else
3011      {
3012         ERR("Name List request failed: %d", status);
3013         if (name_list->cb)
3014           name_list->cb(name_list->data, ELM_WIDGET_DATA(sd)->obj, NULL);
3015         evas_object_smart_callback_call
3016           (ELM_WIDGET_DATA(sd)->obj, SIG_NAME_LOADED_FAIL, NULL);
3017      }
3018    edje_object_signal_emit(ELM_WIDGET_DATA(sd)->resize_obj,
3019                            "elm,state,busy,stop", "elm");
3020    free(name_list->fname);
3021    free(name_list);
3022 }
3023
3024
3025 static char *
3026 _prepare_download()
3027 {
3028    char fname[PATH_MAX];
3029      {
3030         const char *cachedir;
3031
3032 #ifdef ELM_EFREET
3033         snprintf(fname, sizeof(fname), "%s" CACHE_NAME_ROOT,
3034                  efreet_cache_home_get());
3035         (void)cachedir;
3036 #else
3037         cachedir = getenv("XDG_CACHE_HOME");
3038         snprintf(fname, sizeof(fname), "%s/%s" CACHE_NAME_ROOT, getenv("HOME"),
3039                  cachedir ? : "/.config");
3040 #endif
3041         if (!ecore_file_exists(fname)) ecore_file_mkpath(fname);
3042      }
3043    return strdup(fname);
3044 }
3045
3046
3047 static Elm_Map_Name *
3048 _name_request(const Evas_Object *obj,
3049               int method,
3050               const char *address,
3051               double lon,
3052               double lat,
3053               Elm_Map_Name_Cb name_cb,
3054               void *data)
3055 {
3056    char *url;
3057    Elm_Map_Name *name;
3058    char *fname, fname2[PATH_MAX];
3059
3060    ELM_MAP_DATA_GET(obj, sd);
3061    EINA_SAFETY_ON_NULL_RETURN_VAL(sd->src_name, NULL);
3062
3063    fname = _prepare_download();
3064    url = sd->src_name->url_cb
3065    (ELM_WIDGET_DATA(sd)->obj, method, address, lon, lat);
3066    if (!url)
3067      {
3068         ERR("Name URL is NULL");
3069         free(fname);
3070         return NULL;
3071      }
3072
3073    name = ELM_NEW(Elm_Map_Name);
3074    name->wsd = sd;
3075    snprintf(fname2, sizeof(fname2), "%s/%d", fname, rand());
3076    name->fname = strdup(fname2);
3077    name->method = method;
3078    if (method == ELM_MAP_NAME_METHOD_SEARCH) name->address = strdup(address);
3079    else if (method == ELM_MAP_NAME_METHOD_REVERSE)
3080      {
3081         name->lon = lon;
3082         name->lat = lat;
3083      }
3084    name->cb = name_cb;
3085    name->data = data;
3086
3087    if (!ecore_file_download_full(url, name->fname, _name_cb, NULL, name,
3088                                  &(name->job), sd->ua) || !(name->job))
3089      {
3090         ERR("Can't request Name from %s to %s", url, name->fname);
3091         if (name->address) free(name->address);
3092         free(name->fname);
3093         free(name);
3094         free(fname);
3095         return NULL;
3096      }
3097    INF("Name requested from %s to %s", url, name->fname);
3098    free(url);
3099    free(fname);
3100
3101    sd->names = eina_list_append(sd->names, name);
3102    evas_object_smart_callback_call
3103      (ELM_WIDGET_DATA(sd)->obj, SIG_NAME_LOAD, name);
3104    edje_object_signal_emit(ELM_WIDGET_DATA(sd)->resize_obj,
3105                            "elm,state,busy,start", "elm");
3106    return name;
3107 }
3108
3109
3110 static Eina_List *
3111 _name_list_request(const Evas_Object *obj,
3112               int method,
3113               const char *address,
3114               double lon,
3115               double lat,
3116               Elm_Map_Name_List_Cb name_cb,
3117               void *data)
3118 {
3119    char *url;
3120    Elm_Map_Name_List *name_list;
3121    char *fname, fname2[PATH_MAX];
3122
3123    ELM_MAP_DATA_GET(obj, sd);
3124    EINA_SAFETY_ON_NULL_RETURN_VAL(sd->src_name, NULL);
3125
3126    fname = _prepare_download();
3127    url = sd->src_name->url_cb
3128    (ELM_WIDGET_DATA(sd)->obj, method, address, lon, lat);
3129    if (!url)
3130      {
3131         ERR("Name URL is NULL");
3132         free(fname);
3133         return NULL;
3134      }
3135    name_list = ELM_NEW(Elm_Map_Name_List);
3136    name_list->wsd = sd;
3137    snprintf(fname2, sizeof(fname2), "%s/%d", fname, rand());
3138    name_list->fname = strdup(fname2);
3139    name_list->cb = name_cb;
3140    name_list->data = data;
3141    if (!ecore_file_download_full(url, name_list->fname, _name_list_cb,
3142                                  NULL, name_list,
3143                                  &(name_list->job), sd->ua) || !(name_list->job))
3144      {
3145         ERR("Can't request Name from %s to %s", url, name_list->fname);
3146         free(name_list->fname);
3147         free(name_list);
3148         free(fname);
3149         return NULL;
3150      }
3151    INF("Name requested from %s to %s", url, name_list->fname);
3152    free(url);
3153    free(fname);
3154
3155    evas_object_smart_callback_call
3156      (ELM_WIDGET_DATA(sd)->obj, SIG_NAME_LOAD, name_list->names);
3157    edje_object_signal_emit(ELM_WIDGET_DATA(sd)->resize_obj,
3158                            "elm,state,busy,start", "elm");
3159    return name_list->names;
3160 }
3161
3162
3163 static Evas_Event_Flags
3164 _pinch_zoom_start_cb(void *data,
3165                      void *event_info __UNUSED__)
3166 {
3167    Elm_Map_Smart_Data *sd = data;
3168
3169    EINA_SAFETY_ON_NULL_RETURN_VAL(data, EVAS_EVENT_FLAG_NONE);
3170
3171    sd->pinch_zoom = sd->zoom_detail;
3172
3173    return EVAS_EVENT_FLAG_NONE;
3174 }
3175
3176 static Evas_Event_Flags
3177 _pinch_zoom_cb(void *data,
3178                void *event_info)
3179 {
3180    Elm_Map_Smart_Data *sd = data;
3181
3182    EINA_SAFETY_ON_NULL_RETURN_VAL(sd, EVAS_EVENT_FLAG_NONE);
3183
3184    if (!sd->paused)
3185      {
3186         Elm_Gesture_Zoom_Info *ei = event_info;
3187
3188         _zoom(sd, sd->pinch_zoom + ei->zoom - 1, 0);
3189      }
3190
3191    return EVAS_EVENT_FLAG_NONE;
3192 }
3193
3194 static Evas_Event_Flags
3195 _pinch_rotate_cb(void *data,
3196                  void *event_info)
3197 {
3198    Elm_Map_Smart_Data *sd = data;
3199
3200    EINA_SAFETY_ON_NULL_RETURN_VAL(sd, EVAS_EVENT_FLAG_NONE);
3201
3202    if (!sd->paused)
3203      {
3204         int x, y, w, h;
3205         int angle;
3206         Elm_Gesture_Rotate_Info *ei = event_info;
3207         evas_object_geometry_get(ELM_WIDGET_DATA(sd)->obj, &x, &y, &w, &h);
3208         sd->pinch_rotate.d = sd->pinch_rotate.a + ei->angle - ei->base_angle;
3209         angle = (int)(sd->pinch_rotate.d);
3210         x = x + ((double)w * 0.5);
3211         y = y + ((double)h * 0.5);
3212         sd->engine->rotate(ELM_WIDGET_DATA(sd)->obj, angle, x, y, 0);
3213         _overlay_place(sd);
3214      }
3215
3216    return EVAS_EVENT_FLAG_NONE;
3217 }
3218
3219 static Evas_Event_Flags
3220 _pinch_rotate_end_cb(void *data,
3221                      void *event_info __UNUSED__)
3222 {
3223    Elm_Map_Smart_Data *sd = data;
3224
3225    EINA_SAFETY_ON_NULL_RETURN_VAL(sd, EVAS_EVENT_FLAG_NONE);
3226
3227    sd->pinch_rotate.a = sd->pinch_rotate.d;
3228
3229    return EVAS_EVENT_FLAG_NONE;
3230 }
3231
3232 static Evas_Event_Flags
3233 _pinch_momentum_start_cb(void *data,
3234                          void *ei)
3235 {
3236    Elm_Map_Smart_Data *sd = data;
3237    EINA_SAFETY_ON_NULL_RETURN_VAL(sd, EVAS_EVENT_FLAG_NONE);
3238    Elm_Gesture_Momentum_Info *mi = ei;
3239
3240    if (strcmp(sd->engine->name, INTERNAL_ENGINE_NAME) &&
3241        (mi->n == 1))
3242      {
3243         sd->pinch_pan.st = mi->tx;
3244         sd->pinch_pan.x = mi->x1;
3245         sd->pinch_pan.y = mi->y1;
3246         _overlay_place(sd);
3247      }
3248    // FIXME: Because n line move has some bouncing bug,
3249    // perpect is calculated here
3250    if (sd->pinch_pan.perspect >= 90)
3251      sd->pinch_pan.perspect = 90;
3252    else if (sd->pinch_pan.perspect <= 0)
3253      sd->pinch_pan.perspect = 0;
3254    sd->pinch_pan.perspect_y = mi->y1;
3255
3256    return EVAS_EVENT_FLAG_NONE;
3257 }
3258
3259 static Evas_Event_Flags
3260 _pinch_momentum_move_cb(void *data,
3261                         void *ei)
3262 {
3263    Elm_Map_Smart_Data *sd = data;
3264    EINA_SAFETY_ON_NULL_RETURN_VAL(sd, EVAS_EVENT_FLAG_NONE);
3265    Elm_Gesture_Momentum_Info *mi = ei;
3266
3267    if (strcmp(sd->engine->name, INTERNAL_ENGINE_NAME) &&
3268        (mi->n == 1))
3269      {
3270         sd->engine->pan(ELM_WIDGET_DATA(sd)->obj, sd->pinch_pan.x,
3271                         sd->pinch_pan.y, mi->x2, mi->y2);
3272         sd->pinch_pan.x = mi->x2;
3273         sd->pinch_pan.y = mi->y2;
3274         _overlay_place(sd);
3275      }
3276    // FIXME: Because n line move has some bouncing bug,
3277    // perpect is calculated here
3278    sd->pinch_pan.perspect += (mi->y2 - sd->pinch_pan.perspect_y);
3279    sd->pinch_pan.perspect_y = mi->y2;
3280
3281    return EVAS_EVENT_FLAG_NONE;
3282 }
3283
3284 static Evas_Event_Flags
3285 _pinch_momentum_end_cb(void *data,
3286                         void *ei)
3287 {
3288    Elm_Map_Smart_Data *sd = data;
3289    EINA_SAFETY_ON_NULL_RETURN_VAL(sd, EVAS_EVENT_FLAG_NONE);
3290    Elm_Gesture_Momentum_Info *mi = ei;
3291
3292    if (strcmp(sd->engine->name, INTERNAL_ENGINE_NAME) &&
3293        (mi->n == 1))
3294      {
3295         sd->engine->pan(ELM_WIDGET_DATA(sd)->obj, sd->pinch_pan.x,
3296                         sd->pinch_pan.y,
3297                         sd->pinch_pan.x + (mi->mx)/25,
3298                         sd->pinch_pan.y + (mi->my)/25);
3299         _overlay_place(sd);
3300      }
3301
3302    return EVAS_EVENT_FLAG_NONE;
3303 }
3304
3305 static Evas_Event_Flags
3306 _pinch_n_lines_move_cb(void *data,
3307                        void *ei)
3308 {
3309    Elm_Map_Smart_Data *sd = data;
3310    EINA_SAFETY_ON_NULL_RETURN_VAL(sd, EVAS_EVENT_FLAG_NONE);
3311    Elm_Gesture_Line_Info *li = ei;
3312
3313    if (strcmp(sd->engine->name, INTERNAL_ENGINE_NAME) &&
3314        (li->momentum.n == 2) &&
3315        (((170 <= li->angle) && (li->angle <=190)) ||
3316         (350 <= li->angle) || (li->angle <=10)))
3317      {
3318         sd->engine->perpective(ELM_WIDGET_DATA(sd)->obj, sd->pinch_pan.perspect, 0);
3319      }
3320
3321    return EVAS_EVENT_FLAG_NONE;
3322 }
3323
3324 static Evas_Event_Flags
3325 _pinch_n_lines_end_cb(void *data,
3326                       void *ei)
3327 {
3328    Elm_Map_Smart_Data *sd = data;
3329    EINA_SAFETY_ON_NULL_RETURN_VAL(sd, EVAS_EVENT_FLAG_NONE);
3330    Elm_Gesture_Line_Info *li = ei;
3331
3332    if (strcmp(sd->engine->name, INTERNAL_ENGINE_NAME) &&
3333        (li->momentum.n == 2) &&
3334        (((170 <= li->angle) && (li->angle <=190)) ||
3335         (350 <= li->angle) || (li->angle <=10)))
3336      {
3337         sd->engine->perpective(ELM_WIDGET_DATA(sd)->obj, sd->pinch_pan.perspect, 0);
3338      }
3339
3340    return EVAS_EVENT_FLAG_NONE;
3341 }
3342 static void
3343 _elm_map_pan_smart_pos_set(Evas_Object *obj,
3344                            Evas_Coord x,
3345                            Evas_Coord y)
3346 {
3347    ELM_MAP_PAN_DATA_GET(obj, psd);
3348
3349    if ((x == psd->wsd->pan_x) && (y == psd->wsd->pan_y)) return;
3350
3351    psd->wsd->pan_x = x;
3352    psd->wsd->pan_y = y;
3353
3354    evas_object_smart_changed(obj);
3355 }
3356
3357 static void
3358 _elm_map_pan_smart_pos_get(const Evas_Object *obj,
3359                            Evas_Coord *x,
3360                            Evas_Coord *y)
3361 {
3362    ELM_MAP_PAN_DATA_GET(obj, psd);
3363
3364    if (x) *x = psd->wsd->pan_x;
3365    if (y) *y = psd->wsd->pan_y;
3366 }
3367
3368 static void
3369 _elm_map_pan_smart_pos_max_get(const Evas_Object *obj,
3370                                Evas_Coord *x,
3371                                Evas_Coord *y)
3372 {
3373    Evas_Coord ow, oh;
3374
3375    ELM_MAP_PAN_DATA_GET(obj, psd);
3376
3377    evas_object_geometry_get(obj, NULL, NULL, &ow, &oh);
3378    ow = psd->wsd->size.w - ow;
3379    oh = psd->wsd->size.h - oh;
3380
3381    if (ow < 0) ow = 0;
3382    if (oh < 0) oh = 0;
3383    if (x) *x = ow;
3384    if (y) *y = oh;
3385 }
3386
3387 static void
3388 _elm_map_pan_smart_pos_min_get(const Evas_Object *obj __UNUSED__,
3389                                Evas_Coord *x,
3390                                Evas_Coord *y)
3391 {
3392    if (x) *x = 0;
3393    if (y) *y = 0;
3394 }
3395
3396 static void
3397 _elm_map_pan_smart_content_size_get(const Evas_Object *obj,
3398                                     Evas_Coord *w,
3399                                     Evas_Coord *h)
3400 {
3401    ELM_MAP_PAN_DATA_GET(obj, psd);
3402
3403    if (w) *w = psd->wsd->size.w;
3404    if (h) *h = psd->wsd->size.h;
3405 }
3406
3407 static void
3408 _elm_map_pan_smart_add(Evas_Object *obj)
3409 {
3410    /* here just to allocate our extended data */
3411    EVAS_SMART_DATA_ALLOC(obj, Elm_Map_Pan_Smart_Data);
3412
3413    ELM_PAN_CLASS(_elm_map_pan_parent_sc)->base.add(obj);
3414 }
3415
3416 static void
3417 _elm_map_pan_smart_resize(Evas_Object *obj,
3418                           Evas_Coord w __UNUSED__,
3419                           Evas_Coord h __UNUSED__)
3420 {
3421    ELM_MAP_PAN_DATA_GET(obj, psd);
3422
3423    _sizing_eval(psd->wsd);
3424    if (!psd->wsd->calc_job.zoom_changed)
3425      {
3426         psd->wsd->calc_job.zoom_changed = EINA_TRUE;
3427         psd->wsd->calc_job.zoom_anim = EINA_FALSE;
3428         psd->wsd->calc_job.zoom = psd->wsd->zoom;
3429      }
3430    evas_object_smart_changed(obj);
3431 }
3432
3433 static Evas_Object *
3434 _map_pan_add(Evas_Object *obj)
3435 {
3436    Evas_Coord minw, minh;
3437    ELM_MAP_DATA_GET(obj, sd);
3438
3439    if (!sd->s_iface)
3440      {
3441         sd->layout = edje_object_add(evas_object_evas_get(obj));
3442         elm_widget_theme_object_set
3443            (obj, sd->layout , "map", "base", elm_widget_style_get(obj));
3444
3445         /* common scroller hit rectangle setup */
3446         sd->hit_rect = evas_object_rectangle_add(evas_object_evas_get(obj));
3447         evas_object_smart_member_add(sd->hit_rect, obj);
3448         elm_widget_sub_object_add(obj, sd->hit_rect);
3449         evas_object_color_set(sd->hit_rect, 0, 0, 0, 0);
3450         evas_object_show(sd->hit_rect);
3451         evas_object_repeat_events_set(sd->hit_rect, EINA_TRUE);
3452
3453         /* interface's add() routine issued AFTER the object's smart_add() */
3454         sd->s_iface = evas_object_smart_interface_get
3455            (obj, ELM_SCROLLABLE_IFACE_NAME);
3456
3457         sd->s_iface->objects_set(obj, sd->layout, sd->hit_rect);
3458         edje_object_size_min_calc(sd->layout, &minw, &minh);
3459         evas_object_size_hint_min_set(obj, minw, minh);
3460         sd->s_iface->wheel_disabled_set(obj, EINA_TRUE);
3461         sd->s_iface->bounce_allow_set
3462            (obj, _elm_config->thumbscroll_bounce_enable,
3463             _elm_config->thumbscroll_bounce_enable);
3464         sd->s_iface->extern_pan_set(obj, sd->pan_obj);
3465
3466      }
3467
3468    evas_object_show(sd->layout);
3469    sd->s_iface->animate_start_cb_set(obj, _scroll_animate_start_cb);
3470    sd->s_iface->animate_stop_cb_set(obj, _scroll_animate_stop_cb);
3471    sd->s_iface->scroll_cb_set(obj, _scroll_cb);
3472
3473    sd->sep_maps_overlays =
3474       evas_object_rectangle_add(evas_object_evas_get(obj));
3475    elm_widget_sub_object_add(obj, sd->sep_maps_overlays);
3476    evas_object_smart_member_add(sd->sep_maps_overlays, sd->pan_obj);
3477
3478    sd->map = evas_map_new(EVAS_MAP_POINT);
3479
3480    srand(time(NULL));
3481    sd->id = ((int)getpid() << 16) | id_num;
3482    id_num++;
3483    _grid_all_create(sd);
3484
3485    // FIXME: Tile Provider is better to provide default tile size!
3486    sd->tsize = DEFAULT_TILE_SIZE;
3487    sd->size.w = sd->tsize;
3488    sd->size.h = sd->tsize;
3489    sd->size.tile = sd->tsize;
3490
3491    if (!ecore_file_download_protocol_available("http://"))
3492      ERR("Ecore must be built with curl support for the map widget!");
3493    return sd->layout;
3494 }
3495
3496 static void
3497 _map_pan_del(Evas_Object *obj)
3498 {
3499    Elm_Map_Route *r;
3500    Elm_Map_Name *na;
3501    Eina_List *l, *ll;
3502    Evas_Object *track;
3503    Elm_Map_Overlay *overlay;
3504    ELM_MAP_DATA_GET(obj, sd);
3505
3506    EINA_LIST_FOREACH_SAFE(sd->routes, l, ll, r)
3507      elm_map_route_del(r);
3508    eina_list_free(sd->routes);
3509    sd->routes = NULL;
3510
3511    EINA_LIST_FOREACH_SAFE(sd->names, l, ll, na)
3512      elm_map_name_del(na);
3513    eina_list_free(sd->names);
3514    sd->names = NULL;
3515
3516    EINA_LIST_FOREACH_SAFE(sd->overlays, l, ll, overlay)
3517      elm_map_overlay_del(overlay);
3518    eina_list_free(sd->overlays);
3519    sd->overlays = NULL;
3520
3521    eina_list_free(sd->group_overlays);
3522    sd->group_overlays = NULL;
3523    eina_list_free(sd->all_overlays);
3524    sd->all_overlays = NULL;
3525
3526    EINA_LIST_FREE (sd->track, track)
3527      evas_object_del(track);
3528    sd->track = NULL;
3529
3530    if (sd->scr_timer)
3531      {
3532         ecore_timer_del(sd->scr_timer);
3533         sd->scr_timer = NULL;
3534      }
3535    if (sd->zoom_animator)
3536      {
3537         ecore_animator_del(sd->zoom_animator);
3538         sd->zoom_animator = NULL;
3539      }
3540    _grid_all_clear(sd);
3541    if (sd->download_idler) ecore_idler_del(sd->download_idler);
3542    if (sd->download_list) eina_list_free(sd->download_list);
3543
3544    {
3545       char buf[4096];
3546       const char *cachedir;
3547
3548 #ifdef ELM_EFREET
3549       snprintf(buf, sizeof(buf), "%s" CACHE_ROOT, efreet_cache_home_get());
3550       (void)cachedir;
3551 #else
3552       cachedir = getenv("XDG_CACHE_HOME");
3553       snprintf(buf, sizeof(buf), "%s/%s" CACHE_ROOT, getenv("HOME"),
3554                cachedir ? : "/.config");
3555 #endif
3556       if (!ecore_file_recursive_rm(buf))
3557         ERR("Deletion of %s failed", buf);
3558    }
3559    if (sd->map)
3560      {
3561         evas_map_free(sd->map);
3562         sd->map = NULL;
3563      }
3564
3565    evas_object_smart_member_del(sd->sep_maps_overlays);
3566    elm_widget_sub_object_del(obj, sd->sep_maps_overlays);
3567    evas_object_del(sd->sep_maps_overlays);
3568    sd->sep_maps_overlays = NULL;
3569
3570    sd->s_iface->scroll_cb_set(obj, NULL);
3571    sd->s_iface->animate_stop_cb_set(obj, NULL);
3572    sd->s_iface->animate_start_cb_set(obj, NULL);
3573 }
3574
3575 static void
3576 _map_pan_show(Evas_Object *obj, double lon, double lat, int animation)
3577 {
3578    int x, y, w, h;
3579    ELM_MAP_DATA_GET(obj, sd);
3580
3581    _region_to_coord_convert
3582      (sd, lon, lat, sd->size.w, &x, &y);
3583    _viewport_coord_get(sd, NULL, NULL, &w, &h);
3584    x = x - (w / 2);
3585    y = y - (h / 2);
3586
3587    if (animation)
3588       sd->s_iface->region_bring_in(ELM_WIDGET_DATA(sd)->obj, x, y, w, h);
3589    else
3590       sd->s_iface->content_region_show(ELM_WIDGET_DATA(sd)->obj, x, y, w, h);
3591 }
3592
3593 static void
3594 _map_pan_zoom_do(Elm_Map_Smart_Data *sd,
3595          double zoom)
3596 {
3597    Evas_Coord vx, vy, vw, vh;
3598    Evas_Coord ow, oh;
3599
3600    if (zoom > sd->src_tile->zoom_max) zoom = sd->src_tile->zoom_max;
3601    else if (zoom < sd->src_tile->zoom_min)
3602      zoom = sd->src_tile->zoom_min;
3603
3604    ow = sd->size.w;
3605    oh = sd->size.h;
3606    sd->size.tile = pow(2.0, (zoom - sd->zoom)) * sd->tsize;
3607    sd->size.w = pow(2.0, sd->zoom) * sd->size.tile;
3608    sd->size.h = sd->size.w;
3609
3610    // Fix to zooming with (viewport center vx, vy) as the center to prevent
3611    // from zooming with (0,0) as the cetner. (scroller default behavior)
3612    _viewport_coord_get(sd, &vx, &vy, &vw, &vh);
3613    if ((vw > 0) && (vh > 0) && (ow > 0) && (oh > 0))
3614      {
3615         Evas_Coord x, y;
3616         double sx, sy;
3617
3618         if (vw > ow) sx = 0.5;
3619         else sx = (double)(vx + (double)(vw / 2)) / ow;
3620         if (vh > oh) sy = 0.5;
3621         else sy = (double)(vy + (double)(vh / 2)) / oh;
3622
3623         if (sx > 1.0) sx = 1.0;
3624         if (sy > 1.0) sy = 1.0;
3625
3626         x = ceil((sx * sd->size.w) - (vw / 2));
3627         y = ceil((sy * sd->size.h) - (vh / 2));
3628         if (x < 0) x = 0;
3629         else if (x > (sd->size.w - vw))
3630           x = sd->size.w - vw;
3631         if (y < 0) y = 0;
3632         else if (y > (sd->size.h - vh))
3633           y = sd->size.h - vh;
3634         sd->s_iface->content_region_show
3635           (ELM_WIDGET_DATA(sd)->obj, x, y, vw, vh);
3636      }
3637
3638    evas_object_smart_callback_call(sd->pan_obj, "changed", NULL);
3639    evas_object_smart_changed(sd->pan_obj);
3640 }
3641
3642 static Eina_Bool
3643 _zoom_anim_cb(void *data)
3644 {
3645    Elm_Map_Smart_Data *sd = data;
3646
3647    if (sd->ani.cnt <= 0)
3648      {
3649         sd->zoom_animator = NULL;
3650         evas_object_smart_changed(sd->pan_obj);
3651
3652         return ECORE_CALLBACK_CANCEL;
3653      }
3654    else
3655      {
3656         sd->ani.zoom += sd->ani.diff;
3657         sd->ani.cnt--;
3658         sd->zoom_detail = sd->ani.zoom;
3659         sd->zoom = ROUND(sd->zoom_detail);
3660         _map_pan_zoom_do(sd, sd->ani.zoom);
3661
3662         return ECORE_CALLBACK_RENEW;
3663      }
3664 }
3665
3666 static void
3667 _map_pan_zoom(Evas_Object *obj, double zoom, int animation)
3668 {
3669    ELM_MAP_DATA_GET(obj, sd);
3670
3671    if (sd->mode == ELM_MAP_ZOOM_MODE_MANUAL)
3672      {
3673         if (animation)
3674           {
3675              sd->ani.cnt = 10;
3676              sd->ani.zoom = sd->zoom;
3677              sd->ani.diff = (double)(zoom - sd->zoom) / 10;
3678              if (sd->zoom_animator) ecore_animator_del(sd->zoom_animator);
3679              sd->zoom_animator = ecore_animator_add(_zoom_anim_cb, sd);
3680           }
3681         else
3682           {
3683              sd->zoom_detail = zoom;
3684              sd->zoom = ROUND(sd->zoom_detail);
3685              _map_pan_zoom_do(sd, zoom);
3686           }
3687      }
3688    else
3689      {
3690         double diff;
3691         Evas_Coord w, h;
3692         Evas_Coord vw, vh;
3693
3694         w = sd->size.w;
3695         h = sd->size.h;
3696         _viewport_coord_get(sd, NULL, NULL, &vw, &vh);
3697
3698         if (sd->mode == ELM_MAP_ZOOM_MODE_AUTO_FIT)
3699           {
3700              if ((w < vw) && (h < vh))
3701                {
3702                   diff = 0.001;
3703                   while ((w < vw) && (h < vh))
3704                     {
3705                        zoom += diff;
3706                        w = pow(2.0, zoom) * sd->tsize;
3707                        h = pow(2.0, zoom) * sd->tsize;
3708                     }
3709                }
3710              else
3711                {
3712                   diff = -0.001;
3713                   while ((w > vw) || (h > vh))
3714                     {
3715                        zoom += diff;
3716                        w = pow(2.0, zoom) * sd->tsize;
3717                        h = pow(2.0, zoom) * sd->tsize;
3718                     }
3719                }
3720           }
3721         else if (sd->mode == ELM_MAP_ZOOM_MODE_AUTO_FILL)
3722           {
3723              if ((w < vw) || (h < vh))
3724                {
3725                   diff = 0.01;
3726                   while ((w < vw) || (h < vh))
3727                     {
3728                        zoom += diff;
3729                        w = pow(2.0, zoom) * sd->tsize;
3730                        h = pow(2.0, zoom) * sd->tsize;
3731                     }
3732                }
3733              else
3734                {
3735                   diff = -0.01;
3736                   while ((w > vw) && (h > vh))
3737                     {
3738                        zoom += diff;
3739                        w = pow(2.0, zoom) * sd->tsize;
3740                        h = pow(2.0, zoom) * sd->tsize;
3741                     }
3742                }
3743           }
3744         sd->zoom_detail = zoom;
3745         sd->zoom = ROUND(sd->zoom_detail);
3746         _map_pan_zoom_do(sd, zoom);
3747      }
3748 }
3749
3750 static void
3751 _map_pan_rotate(Evas_Object *obj, double angle, int x, int y, int animation __UNUSED__)
3752 {
3753    ELM_MAP_DATA_GET(obj, sd);
3754    sd->pan_rotate.d = angle;
3755    sd->pan_rotate.cx = x;
3756    sd->pan_rotate.cy = y;
3757    evas_object_smart_changed(sd->pan_obj);
3758 }
3759
3760 static void
3761 _map_pan_rotate_get(const Evas_Object *obj, double *angle, int *x, int *y)
3762 {
3763    ELM_MAP_DATA_GET(obj, sd);
3764    if (angle) *angle = sd->pan_rotate.d;
3765    if (x) *x = sd->pan_rotate.cx;
3766    if (y) *y = sd->pan_rotate.cy;
3767 }
3768
3769 static void
3770 _map_pan_perspective_set(Evas_Object *obj __UNUSED__, double perpective __UNUSED__, int animate __UNUSED__)
3771 {
3772    WRN("Not implemented function");
3773 }
3774
3775 static void
3776 _map_pan_region_get(const Evas_Object *obj, double *lon, double *lat)
3777 {
3778    double tlon, tlat;
3779    Evas_Coord vx, vy, vw, vh;
3780    ELM_MAP_DATA_GET(obj, sd);
3781
3782    _viewport_coord_get(sd, &vx, &vy, &vw, &vh);
3783    _coord_to_region_convert
3784      (sd, vx + vw / 2, vy + vh / 2, sd->size.w, &tlon, &tlat);
3785    if (lon) *lon = tlon;
3786    if (lat) *lat = tlat;
3787 }
3788
3789 static void
3790 _map_pan_canvas_to_region(const Evas_Object *obj, int x, int y, double *lon, double *lat)
3791 {
3792    ELM_MAP_DATA_GET(obj, sd);
3793    _canvas_to_coord(sd, x, y, &x, &y);
3794    _coord_to_region_convert(sd, x, y, sd->size.w, lon, lat);
3795 }
3796
3797 static void
3798 _map_pan_region_to_canvas(const Evas_Object *obj, double lon, double lat, int *x, int *y)
3799 {
3800    ELM_MAP_DATA_GET(obj, sd);
3801    _region_to_coord_convert(sd, lon, lat, sd->size.w, x, y);
3802    _coord_to_canvas(sd, *x, *y, x, y);
3803 }
3804
3805 static void
3806 _move_unimplemented(Evas_Object *obj __UNUSED__, int x __UNUSED__, int y __UNUSED__)
3807 {
3808    WRN("move is not implemented");
3809 }
3810
3811 static void
3812 _resize_unimplemented(Evas_Object *obj __UNUSED__, int w __UNUSED__, int y __UNUSED__)
3813 {
3814    WRN("resize is not implemented");
3815 }
3816
3817 static void
3818 _pan_unimplemented(Evas_Object *obj __UNUSED__, int x_1 __UNUSED__, int y_1 __UNUSED__, int x_2 __UNUSED__, int y_2 __UNUSED__)
3819 {
3820    WRN("pan is not implemented");
3821 }
3822
3823 static void
3824 _canvas_to_region_unimplemented(const Evas_Object *obj __UNUSED__, int x __UNUSED__, int y __UNUSED__, double *lon __UNUSED__, double *lat __UNUSED__)
3825 {
3826    WRN("canvas to region is not implemented");
3827 }
3828
3829 static void
3830 _region_to_canvas_unimplemented(const Evas_Object *obj __UNUSED__, double lon __UNUSED__, double lat __UNUSED__, int *x __UNUSED__, int *y __UNUSED__)
3831 {
3832    WRN("region to canvas is not implemented");
3833 }
3834
3835 static void
3836 _map_pan_overlays_show(Elm_Map_Smart_Data *sd, Eina_List *overlays)
3837 {
3838    double max_lon, min_lon, max_lat, min_lat, lon, lat;
3839    int zoom, zoom_max;
3840    Evas_Coord vw, vh;
3841
3842    EINA_SAFETY_ON_NULL_RETURN(sd);
3843    EINA_SAFETY_ON_NULL_RETURN(overlays);
3844
3845    _region_max_min_get(overlays, &max_lon, &min_lon, &max_lat, &min_lat);
3846    lon = (max_lon + min_lon) / 2;
3847    lat = (max_lat + min_lat) / 2;
3848
3849    zoom = sd->src_tile->zoom_min;
3850    _viewport_coord_get(sd, NULL, NULL, &vw, &vh);
3851    if (sd->src_tile->zoom_max < sd->zoom_max)
3852      zoom_max = sd->src_tile->zoom_max;
3853    else zoom_max = sd->zoom_max;
3854    while (zoom <= zoom_max)
3855      {
3856         Evas_Coord size, max_x, max_y, min_x, min_y;
3857
3858         size = pow(2.0, zoom) * sd->tsize;
3859         _region_to_coord_convert
3860           (sd, min_lon, max_lat, size, &min_x, &max_y);
3861         _region_to_coord_convert
3862           (sd, max_lon, min_lat, size, &max_x, &min_y);
3863         if ((max_x - min_x) > vw || (max_y - min_y) > vh) break;
3864         zoom++;
3865      }
3866    zoom--;
3867
3868    sd->engine->zoom(ELM_WIDGET_DATA(sd)->obj, zoom, 0);
3869    sd->engine->show(ELM_WIDGET_DATA(sd)->obj, lon, lat, EINA_FALSE);
3870 }
3871
3872 static void
3873 _calc_job(Elm_Map_Smart_Data *sd)
3874 {
3875    if (sd->calc_job.zoom_changed)
3876      {
3877         _map_pan_zoom(ELM_WIDGET_DATA(sd)->obj, sd->calc_job.zoom, sd->calc_job.zoom_anim);
3878         sd->calc_job.zoom_changed = EINA_FALSE;
3879      }
3880    if (!sd->zoom_animator && sd->calc_job.show_changed)
3881      {
3882         _map_pan_show(ELM_WIDGET_DATA(sd)->obj, sd->calc_job.lon, sd->calc_job.lat,
3883                       sd->calc_job.show_anim);
3884         sd->calc_job.show_changed = EINA_FALSE;
3885      }
3886    if (!sd->zoom_animator && sd->calc_job.overlays_changed)
3887      {
3888         _map_pan_overlays_show(sd, sd->calc_job.overlays);
3889         sd->calc_job.overlays_changed = EINA_FALSE;
3890      }
3891 }
3892
3893 static void
3894 _elm_map_pan_smart_calculate(Evas_Object *obj)
3895 {
3896    Evas_Coord w, h;
3897
3898    ELM_MAP_PAN_DATA_GET(obj, psd);
3899
3900    evas_object_geometry_get(obj, NULL, NULL, &w, &h);
3901    if (w <= 0 || h <= 0) return;
3902
3903    _grid_place(psd->wsd);
3904    _overlay_place(psd->wsd);
3905    _track_place(psd->wsd);
3906    _calc_job(psd->wsd);
3907 }
3908
3909 static void
3910 _elm_map_pan_smart_move(Evas_Object *obj,
3911                         Evas_Coord x __UNUSED__,
3912                         Evas_Coord y __UNUSED__)
3913 {
3914    EINA_SAFETY_ON_NULL_RETURN(obj);
3915
3916    evas_object_smart_changed(obj);
3917 }
3918
3919 static void
3920 _elm_map_pan_smart_set_user(Elm_Map_Pan_Smart_Class *sc)
3921 {
3922    ELM_PAN_CLASS(sc)->base.add = _elm_map_pan_smart_add;
3923    ELM_PAN_CLASS(sc)->base.move = _elm_map_pan_smart_move;
3924    ELM_PAN_CLASS(sc)->base.resize = _elm_map_pan_smart_resize;
3925    ELM_PAN_CLASS(sc)->base.calculate = _elm_map_pan_smart_calculate;
3926
3927    ELM_PAN_CLASS(sc)->pos_set = _elm_map_pan_smart_pos_set;
3928    ELM_PAN_CLASS(sc)->pos_get = _elm_map_pan_smart_pos_get;
3929    ELM_PAN_CLASS(sc)->pos_max_get = _elm_map_pan_smart_pos_max_get;
3930    ELM_PAN_CLASS(sc)->pos_min_get = _elm_map_pan_smart_pos_min_get;
3931    ELM_PAN_CLASS(sc)->content_size_get =
3932      _elm_map_pan_smart_content_size_get;
3933 }
3934
3935 static Eina_Bool
3936 _elm_map_smart_on_focus(Evas_Object *obj)
3937 {
3938    ELM_MAP_DATA_GET(obj, sd);
3939
3940    if (elm_widget_focus_get(obj))
3941      {
3942         edje_object_signal_emit
3943           (ELM_WIDGET_DATA(sd)->resize_obj, "elm,action,focus", "elm");
3944         evas_object_focus_set(ELM_WIDGET_DATA(sd)->resize_obj, EINA_TRUE);
3945      }
3946    else
3947      {
3948         edje_object_signal_emit
3949           (ELM_WIDGET_DATA(sd)->resize_obj, "elm,action,unfocus", "elm");
3950         evas_object_focus_set(ELM_WIDGET_DATA(sd)->resize_obj, EINA_FALSE);
3951      }
3952
3953    return EINA_TRUE;
3954 }
3955
3956 static Eina_Bool
3957 _elm_map_smart_theme(Evas_Object *obj)
3958 {
3959    ELM_MAP_DATA_GET(obj, sd);
3960
3961    if (!ELM_WIDGET_CLASS(_elm_map_parent_sc)->theme(obj))
3962      return EINA_FALSE;
3963
3964    _sizing_eval(sd);
3965
3966    return EINA_TRUE;
3967 }
3968
3969 static Eina_Bool
3970 _elm_map_smart_event(Evas_Object *obj,
3971                      Evas_Object *src __UNUSED__,
3972                      Evas_Callback_Type type,
3973                      void *event_info)
3974 {
3975    Evas_Coord vh;
3976    Evas_Coord x, y;
3977    Evas_Event_Key_Down *ev = event_info;
3978    Evas_Coord step_x, step_y, page_x, page_y;
3979
3980    ELM_MAP_DATA_GET(obj, sd);
3981
3982    if (elm_widget_disabled_get(obj)) return EINA_FALSE;
3983    if (type != EVAS_CALLBACK_KEY_DOWN) return EINA_FALSE;
3984    if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD) return EINA_FALSE;
3985
3986    sd->s_iface->content_pos_get(obj, &x, &y);
3987    sd->s_iface->step_size_get(obj, &step_x, &step_y);
3988    sd->s_iface->page_size_get(obj, &page_x, &page_y);
3989    sd->s_iface->content_viewport_size_get(obj, NULL, &vh);
3990
3991    if ((!strcmp(ev->keyname, "Left")) ||
3992        ((!strcmp(ev->keyname, "KP_Left")) && (!ev->string)))
3993      {
3994         x -= step_x;
3995      }
3996    else if ((!strcmp(ev->keyname, "Right")) ||
3997             ((!strcmp(ev->keyname, "KP_Right")) && (!ev->string)))
3998      {
3999         x += step_x;
4000      }
4001    else if ((!strcmp(ev->keyname, "Up")) ||
4002             ((!strcmp(ev->keyname, "KP_Up")) && (!ev->string)))
4003      {
4004         y -= step_y;
4005      }
4006    else if ((!strcmp(ev->keyname, "Down")) ||
4007             ((!strcmp(ev->keyname, "KP_Down")) && (!ev->string)))
4008      {
4009         y += step_y;
4010      }
4011    else if ((!strcmp(ev->keyname, "Prior")) ||
4012             ((!strcmp(ev->keyname, "KP_Prior")) && (!ev->string)))
4013      {
4014         if (page_y < 0)
4015           y -= -(page_y * vh) / 100;
4016         else
4017           y -= page_y;
4018      }
4019    else if ((!strcmp(ev->keyname, "Next")) ||
4020             ((!strcmp(ev->keyname, "KP_Next")) && (!ev->string)))
4021      {
4022         if (page_y < 0)
4023           y += -(page_y * vh) / 100;
4024         else
4025           y += page_y;
4026      }
4027    else if (!strcmp(ev->keyname, "KP_Add"))
4028      {
4029         _zoom(sd, sd->zoom + 1, 1);
4030         return EINA_TRUE;
4031      }
4032    else if (!strcmp(ev->keyname, "KP_Subtract"))
4033      {
4034         _zoom(sd, sd->zoom - 1, 1);
4035         return EINA_TRUE;
4036      }
4037    else return EINA_FALSE;
4038
4039    ev->event_flags |= EVAS_EVENT_FLAG_ON_HOLD;
4040    sd->s_iface->content_pos_set(obj, x, y, EINA_TRUE);
4041
4042    return EINA_TRUE;
4043 }
4044
4045 static void
4046 _source_tile_set(Elm_Map_Smart_Data *sd,
4047                  const char *source_name)
4048 {
4049    Source_Tile *s;
4050    Eina_List *l;
4051
4052    EINA_SAFETY_ON_NULL_RETURN(source_name);
4053
4054    if (sd->src_tile && !strcmp(sd->src_tile->name, source_name))
4055      return;
4056
4057    EINA_LIST_FOREACH(sd->src_tiles, l, s)
4058      {
4059         if (!strcmp(s->name, source_name))
4060           {
4061              sd->src_tile = s;
4062              break;
4063           }
4064      }
4065    if (!sd->src_tile)
4066      {
4067         ERR("source name (%s) is not found", source_name);
4068         return;
4069      }
4070
4071    if (sd->src_tile->zoom_max < sd->zoom)
4072      sd->zoom = sd->src_tile->zoom_max;
4073    else if (sd->src_tile->zoom_min > sd->zoom)
4074      sd->zoom = sd->src_tile->zoom_min;
4075
4076    if (sd->src_tile->zoom_max < sd->zoom_max)
4077      sd->zoom_max = sd->src_tile->zoom_max;
4078    if (sd->src_tile->zoom_min > sd->zoom_min)
4079      sd->zoom_min = sd->src_tile->zoom_min;
4080
4081    _grid_all_clear(sd);
4082    _grid_all_create(sd);
4083    sd->zoom_detail = sd->zoom;
4084    _map_pan_zoom_do(sd, sd->zoom);
4085 }
4086
4087 static void
4088 _source_route_set(Elm_Map_Smart_Data *sd,
4089                   const char *source_name)
4090 {
4091    Source_Route *s;
4092    Eina_List *l;
4093
4094    EINA_SAFETY_ON_NULL_RETURN(source_name);
4095
4096    if (sd->src_route && !strcmp(sd->src_route->name, source_name))
4097      return;
4098
4099    EINA_LIST_FOREACH(sd->src_routes, l, s)
4100      {
4101         if (!strcmp(s->name, source_name))
4102           {
4103              sd->src_route = s;
4104              break;
4105           }
4106      }
4107    if (!sd->src_route)
4108      {
4109         ERR("source name (%s) is not found", source_name);
4110         return;
4111      }
4112 }
4113
4114 static void
4115 _source_name_set(Elm_Map_Smart_Data *sd,
4116                  const char *source_name)
4117 {
4118    Source_Name *s;
4119    Eina_List *l;
4120
4121    EINA_SAFETY_ON_NULL_RETURN(source_name);
4122
4123    if (sd->src_name && !strcmp(sd->src_name->name, source_name))
4124      return;
4125
4126    EINA_LIST_FOREACH(sd->src_names, l, s)
4127      {
4128         if (!strcmp(s->name, source_name))
4129           {
4130              sd->src_name = s;
4131              break;
4132           }
4133      }
4134    if (!sd->src_name)
4135      {
4136         ERR("source name (%s) is not found", source_name);
4137         return;
4138      }
4139 }
4140
4141 static Eina_Bool
4142 _source_mod_cb(Eina_Module *m,
4143                     void *data)
4144 {
4145    const char *file;
4146    Elm_Map_Smart_Data *sd = data;
4147
4148    Elm_Map_Module_Source_Name_Func name_cb;
4149    Elm_Map_Module_Add_Func add_cb;
4150    Elm_Map_Module_Del_Func del_cb;
4151    Elm_Map_Module_Move_Func move_cb;
4152    Elm_Map_Module_Resize_Func resize_cb;
4153    Elm_Map_Module_Region_Get_Func region_get_cb;
4154    Elm_Map_Module_Pan_Func pan_cb;
4155    Elm_Map_Module_Show_Func show_cb;
4156    Elm_Map_Module_Zoom_Func zoom_cb;
4157    Elm_Map_Module_Rotate_Func rotate_cb;
4158    Elm_Map_Module_Rotate_Get_Func rotate_get_cb;
4159    Elm_Map_Module_Canvas_to_Region_Func canvas_to_region_cb;
4160    Elm_Map_Module_Region_to_Canvas_Func region_to_canvas_cb;
4161    Elm_Map_Module_Perspective_Set_Func perpective_cb;
4162    Elm_Map_Module_Tile_Url_Func tile_url_cb;
4163    Elm_Map_Module_Tile_Scale_Func scale_cb;
4164    Elm_Map_Module_Tile_Zoom_Min_Func zoom_min;
4165    Elm_Map_Module_Tile_Zoom_Max_Func zoom_max;
4166    Elm_Map_Module_Tile_Geo_to_Coord_Func geo_to_coord;
4167    Elm_Map_Module_Tile_Coord_to_Geo_Func coord_to_geo;
4168    Elm_Map_Module_Route_Url_Func route_url_cb;
4169    Elm_Map_Module_Name_Url_Func name_url_cb;
4170
4171    EINA_SAFETY_ON_NULL_RETURN_VAL(data, EINA_FALSE);
4172
4173    file = eina_module_file_get(m);
4174    if (!eina_module_load(m))
4175      {
4176         ERR("Could not load module \"%s\": %s", file,
4177             eina_error_msg_get(eina_error_get()));
4178         return EINA_FALSE;
4179      }
4180    name_cb = eina_module_symbol_get(m, "map_module_source_name_get");
4181    if (!name_cb)
4182      {
4183         name_cb = eina_module_symbol_get(m, "map_module_name_get");
4184         if (!name_cb)
4185           {
4186              WRN("Could not find map module name from module \"%s\": %s",
4187                  file, eina_error_msg_get(eina_error_get()));
4188              eina_module_unload(m);
4189              return EINA_FALSE;
4190           }
4191      }
4192
4193    // Find Map Engine
4194    zoom_min = eina_module_symbol_get(m, "map_module_zoom_min_get");
4195    zoom_max = eina_module_symbol_get(m, "map_module_zoom_max_get");
4196    add_cb = eina_module_symbol_get(m, "map_module_add");
4197    del_cb = eina_module_symbol_get(m, "map_module_del");
4198    move_cb = eina_module_symbol_get(m, "map_module_move");
4199    resize_cb = eina_module_symbol_get(m, "map_module_resize");
4200    region_get_cb = eina_module_symbol_get(m, "map_module_region_get");
4201    pan_cb = eina_module_symbol_get(m, "map_module_pan");
4202    show_cb = eina_module_symbol_get(m, "map_module_show");
4203    zoom_cb = eina_module_symbol_get(m, "map_module_zoom");
4204    rotate_cb = eina_module_symbol_get(m, "map_module_rotate");
4205    rotate_get_cb = eina_module_symbol_get(m, "map_module_rotate_get");
4206    perpective_cb = eina_module_symbol_get(m, "map_module_perpective_set");
4207    canvas_to_region_cb = eina_module_symbol_get(m, "map_module_canvas_to_region");
4208    region_to_canvas_cb = eina_module_symbol_get(m, "map_module_region_to_canvas");
4209    if (zoom_min && zoom_max && add_cb && del_cb && show_cb && zoom_cb && rotate_cb && rotate_get_cb && perpective_cb)
4210      {
4211         INF("Map ENGINE module is loaded \"%s\"",  file);
4212         Source_Engine *s;
4213         s = ELM_NEW(Source_Engine);
4214         s->name = name_cb();
4215         s->zoom_min = zoom_min();
4216         s->zoom_max = zoom_max();
4217         s->add = add_cb;
4218         s->del = del_cb;
4219         if (move_cb) s->move = move_cb;
4220         else s->move = _move_unimplemented;
4221         if (resize_cb) s->resize = resize_cb;
4222         else s->resize = _resize_unimplemented;
4223         s->region_get = region_get_cb;
4224         if (pan_cb) s->pan = pan_cb;
4225         else s->pan = _pan_unimplemented;
4226         s->show = show_cb;
4227         s->zoom = zoom_cb;
4228         s->rotate = rotate_cb;
4229         s->rotate_get = rotate_get_cb;
4230         s->perpective = perpective_cb;
4231         if (canvas_to_region_cb) s->canvas_to_region = canvas_to_region_cb;
4232         else s->canvas_to_region = _canvas_to_region_unimplemented;
4233         if (region_to_canvas_cb) s->region_to_canvas = region_to_canvas_cb;
4234         else s->region_to_canvas = _region_to_canvas_unimplemented;
4235
4236         sd->engines = eina_list_append(sd->engines, s);
4237      }
4238
4239    // Find TILE module
4240    tile_url_cb = eina_module_symbol_get(m, "map_module_tile_url_get");
4241    zoom_min = eina_module_symbol_get(m, "map_module_tile_zoom_min_get");
4242    zoom_max = eina_module_symbol_get(m, "map_module_tile_zoom_max_get");
4243    geo_to_coord = eina_module_symbol_get(m, "map_module_tile_geo_to_coord");
4244    coord_to_geo = eina_module_symbol_get(m, "map_module_tile_coord_to_geo");
4245    scale_cb = eina_module_symbol_get(m, "map_module_tile_scale_get");
4246    if (tile_url_cb && zoom_min && zoom_max && geo_to_coord && coord_to_geo && scale_cb)
4247      {
4248         INF("Map TILE module is loaded \"%s\"",  file);
4249         Source_Tile *s;
4250         s = ELM_NEW(Source_Tile);
4251         s->name = name_cb();
4252         s->zoom_min = zoom_min();
4253         s->zoom_max = zoom_max();
4254         s->url_cb = tile_url_cb;
4255         s->geo_to_coord = geo_to_coord;
4256         s->coord_to_geo = coord_to_geo;
4257         s->scale_cb = scale_cb;
4258         sd->src_tiles = eina_list_append(sd->src_tiles, s);
4259      }
4260
4261    // Find ROUTE module
4262    route_url_cb = eina_module_symbol_get(m, "map_module_route_url_get");
4263    if (route_url_cb)
4264      {
4265         INF("Map ROUTE module is loaded \"%s\"",  file);
4266         Source_Route *s;
4267         s = ELM_NEW(Source_Tile);
4268         s->name = name_cb();
4269         s->url_cb = route_url_cb;
4270         sd->src_routes = eina_list_append(sd->src_routes, s);
4271      }
4272
4273    // Find NAME module
4274    name_url_cb = eina_module_symbol_get(m, "map_module_name_url_get");
4275    if (name_url_cb)
4276      {
4277         INF("Map NAME module is loaded \"%s\"",  file);
4278         Source_Name *s;
4279         s = ELM_NEW(Source_Tile);
4280         s->name = name_cb();
4281         s->url_cb = name_url_cb;
4282         sd->src_names = eina_list_append(sd->src_names, s);
4283      }
4284    return EINA_TRUE;
4285 }
4286
4287 static void
4288 _source_all_unload(Elm_Map_Smart_Data *sd)
4289 {
4290    int idx = 0;
4291    Source_Tile *s;
4292
4293    for (idx = 0; sd->src_tile_names[idx]; idx++)
4294      eina_stringshare_del(sd->src_tile_names[idx]);
4295    for (idx = 0; sd->src_route_names[idx]; idx++)
4296      eina_stringshare_del(sd->src_route_names[idx]);
4297    for (idx = 0; sd->src_name_names[idx]; idx++)
4298      eina_stringshare_del(sd->src_name_names[idx]);
4299
4300    EINA_LIST_FREE(sd->src_tiles, s) free(s);
4301    EINA_LIST_FREE(sd->src_routes, s) free(s);
4302    EINA_LIST_FREE(sd->src_names, s) free(s);
4303
4304    eina_module_list_free(sd->src_mods);
4305 }
4306
4307
4308 static void
4309 _source_all_load(Elm_Map_Smart_Data *sd)
4310 {
4311    Source_Engine *engine;
4312    Source_Tile *src_tile;
4313    Source_Route *src_route;
4314    Source_Name *src_name;
4315    unsigned int idx;
4316    Eina_List *l;
4317
4318    // Load hard coded TILE source
4319    for (idx = 0; idx < (sizeof(src_tiles) / sizeof(Source_Tile)); idx++)
4320      {
4321         src_tile = ELM_NEW(Source_Tile);
4322         src_tile->name = src_tiles[idx].name;
4323         src_tile->zoom_min = src_tiles[idx].zoom_min;
4324         src_tile->zoom_max = src_tiles[idx].zoom_max;
4325         src_tile->url_cb = src_tiles[idx].url_cb;
4326         src_tile->geo_to_coord = src_tiles[idx].geo_to_coord;
4327         src_tile->coord_to_geo = src_tiles[idx].coord_to_geo;
4328         src_tile->scale_cb = src_tiles[idx].scale_cb;
4329         sd->src_tiles = eina_list_append(sd->src_tiles, src_tile);
4330      }
4331    // Load hard coded ROUTE source
4332    for (idx = 0; idx < (sizeof(src_routes) / sizeof(Source_Route)); idx++)
4333      {
4334         src_route = ELM_NEW(Source_Route);
4335         src_route->name = src_routes[idx].name;
4336         src_route->url_cb = src_routes[idx].url_cb;
4337         sd->src_routes = eina_list_append(sd->src_routes, src_route);
4338      }
4339    // Load from hard coded NAME source
4340    for (idx = 0; idx < (sizeof(src_names) / sizeof(Source_Name)); idx++)
4341      {
4342         src_name = ELM_NEW(Source_Name);
4343         src_name->name = src_names[idx].name;
4344         src_name->url_cb = src_names[idx].url_cb;
4345         sd->src_names = eina_list_append(sd->src_names, src_name);
4346      }
4347    // Load Internal Default Map Engine
4348    engine = ELM_NEW(Source_Engine);
4349    engine->name = INTERNAL_ENGINE_NAME;
4350    engine->zoom_min = src_tiles[0].zoom_min;
4351    engine->zoom_max = src_tiles[0].zoom_max;
4352    engine->add = _map_pan_add;
4353    engine->del = _map_pan_del;
4354    engine->pan = _pan_unimplemented;
4355    engine->show = _map_pan_show;
4356    engine->zoom = _map_pan_zoom;
4357    engine->rotate = _map_pan_rotate;
4358    engine->rotate_get = _map_pan_rotate_get;
4359    engine->perpective = _map_pan_perspective_set;
4360    engine->region_get = _map_pan_region_get;
4361    engine->canvas_to_region = _map_pan_canvas_to_region;
4362    engine->region_to_canvas = _map_pan_region_to_canvas;
4363    sd->engines = eina_list_append(sd->engines, engine);
4364
4365    // Load from modules
4366    sd->src_mods = eina_module_list_get(sd->src_mods, MODULES_PATH, 1,
4367                                        &_source_mod_cb, sd);
4368
4369    // Set default source
4370    sd->engine = eina_list_nth(sd->engines, 0);
4371    sd->src_tile = eina_list_nth(sd->src_tiles, 0);
4372    sd->src_route = eina_list_nth(sd->src_routes, 0);
4373    sd->src_name = eina_list_nth(sd->src_names, 0);
4374
4375    // Make name string of sources
4376    idx = 0;
4377    sd->engine_names = calloc((eina_list_count(sd->engines) + 1),
4378                                  sizeof(const char *));
4379    EINA_LIST_FOREACH(sd->engines, l, engine)
4380      {
4381         eina_stringshare_replace(&sd->engine_names[idx], engine->name);
4382         INF("engine : %s", sd->engine_names[idx]);
4383         idx++;
4384      }
4385    idx = 0;
4386    sd->src_tile_names = calloc((eina_list_count(sd->src_tiles) + 1),
4387                                sizeof(const char *));
4388    EINA_LIST_FOREACH(sd->src_tiles, l, src_tile)
4389      {
4390         eina_stringshare_replace(&sd->src_tile_names[idx], src_tile->name);
4391         INF("source tile: %s", sd->src_tile_names[idx]);
4392         idx++;
4393      }
4394    idx = 0;
4395    sd->src_route_names = calloc((eina_list_count(sd->src_routes) + 1),
4396                                 sizeof(const char *));
4397    EINA_LIST_FOREACH(sd->src_routes, l, src_route)
4398      {
4399         eina_stringshare_replace(&sd->src_route_names[idx], src_route->name);
4400         INF("source route: %s", sd->src_route_names[idx]);
4401         idx++;
4402      }
4403    idx = 0;
4404    sd->src_name_names = calloc((eina_list_count(sd->src_names) + 1),
4405                                sizeof(const char *));
4406    EINA_LIST_FOREACH(sd->src_names, l, src_name)
4407      {
4408         eina_stringshare_replace(&sd->src_name_names[idx], src_name->name);
4409         INF("source name: %s", sd->src_name_names[idx]);
4410         idx++;
4411      }
4412 }
4413
4414 static void
4415 _elm_map_smart_add(Evas_Object *obj)
4416 {
4417    Evas_Object *layout;
4418    Elm_Map_Pan_Smart_Data *pan_data;
4419    EVAS_SMART_DATA_ALLOC(obj, Elm_Map_Smart_Data);
4420
4421    ELM_WIDGET_CLASS(_elm_map_parent_sc)->base.add(obj);
4422
4423    elm_widget_can_focus_set(obj, EINA_TRUE);
4424
4425    priv->pan_obj = evas_object_smart_add
4426       (evas_object_evas_get(obj), _elm_map_pan_smart_class_new());
4427    pan_data = evas_object_smart_data_get(priv->pan_obj);
4428    pan_data->wsd = priv;
4429
4430    _source_all_load(priv);
4431    layout = priv->engine->add(obj);
4432    elm_widget_resize_object_set(obj, layout);
4433
4434    evas_object_event_callback_add
4435      (obj, EVAS_CALLBACK_MOUSE_DOWN, _mouse_down_cb, priv);
4436    evas_object_event_callback_add
4437      (obj, EVAS_CALLBACK_MOUSE_UP, _mouse_up_cb, priv);
4438    evas_object_event_callback_add
4439      (obj, EVAS_CALLBACK_MOUSE_WHEEL, _mouse_wheel_cb, priv);
4440    evas_object_event_callback_add
4441       (obj, EVAS_CALLBACK_CHANGED_SIZE_HINTS, _changed_size_hints_cb, priv);
4442
4443    priv->g_layer = elm_gesture_layer_add(obj);
4444    if (!priv->g_layer) ERR("elm_gesture_layer_add() failed");
4445    elm_gesture_layer_attach(priv->g_layer, obj);
4446    elm_gesture_layer_cb_set
4447      (priv->g_layer, ELM_GESTURE_ZOOM, ELM_GESTURE_STATE_START,
4448      _pinch_zoom_start_cb, priv);
4449    elm_gesture_layer_cb_set
4450      (priv->g_layer, ELM_GESTURE_ZOOM, ELM_GESTURE_STATE_MOVE,
4451      _pinch_zoom_cb, priv);
4452    elm_gesture_layer_cb_set
4453      (priv->g_layer, ELM_GESTURE_ROTATE, ELM_GESTURE_STATE_MOVE,
4454      _pinch_rotate_cb, priv);
4455    elm_gesture_layer_cb_set
4456      (priv->g_layer, ELM_GESTURE_ROTATE, ELM_GESTURE_STATE_END,
4457      _pinch_rotate_end_cb, priv);
4458    elm_gesture_layer_cb_set
4459      (priv->g_layer, ELM_GESTURE_ROTATE, ELM_GESTURE_STATE_ABORT,
4460      _pinch_rotate_end_cb, priv);
4461    elm_gesture_layer_cb_set
4462      (priv->g_layer, ELM_GESTURE_MOMENTUM, ELM_GESTURE_STATE_START,
4463      _pinch_momentum_start_cb, priv);
4464    elm_gesture_layer_cb_set
4465      (priv->g_layer, ELM_GESTURE_MOMENTUM, ELM_GESTURE_STATE_MOVE,
4466      _pinch_momentum_move_cb, priv);
4467    elm_gesture_layer_cb_set
4468      (priv->g_layer, ELM_GESTURE_MOMENTUM, ELM_GESTURE_STATE_END,
4469      _pinch_momentum_end_cb, priv);
4470    elm_gesture_layer_cb_set
4471      (priv->g_layer, ELM_GESTURE_N_LINES, ELM_GESTURE_STATE_MOVE,
4472      _pinch_n_lines_move_cb, priv);
4473    elm_gesture_layer_cb_set
4474      (priv->g_layer, ELM_GESTURE_N_LINES, ELM_GESTURE_STATE_END,
4475      _pinch_n_lines_end_cb, priv);
4476
4477    priv->mode = ELM_MAP_ZOOM_MODE_MANUAL;
4478    priv->zoom_min = priv->engine->zoom_min;
4479    priv->zoom_max = priv->engine->zoom_max;
4480    priv->zoom = 0;
4481    priv->zoom_detail = 0;
4482
4483    priv->engine->zoom(obj, 0, 0);
4484 }
4485
4486 static void
4487 _elm_map_smart_del(Evas_Object *obj)
4488 {
4489    ELM_MAP_DATA_GET(obj, sd);
4490
4491    if (sd->zoom_timer) ecore_timer_del(sd->zoom_timer);
4492    if (sd->long_timer) ecore_timer_del(sd->long_timer);
4493    if (sd->loaded_timer) ecore_timer_del(sd->loaded_timer);
4494
4495    if (sd->user_agent) eina_stringshare_del(sd->user_agent);
4496    if (sd->ua) eina_hash_free(sd->ua);
4497
4498    sd->engine->del(obj);
4499    _source_all_unload(sd);
4500
4501    evas_object_del(sd->pan_obj);
4502    ELM_WIDGET_CLASS(_elm_map_parent_sc)->base.del(obj);
4503 }
4504
4505 static void
4506 _elm_map_smart_calculate(Evas_Object *obj)
4507 {
4508    ELM_MAP_DATA_GET(obj, sd);
4509
4510    if (strcmp(sd->engine->name, INTERNAL_ENGINE_NAME))
4511      _overlay_place(sd);
4512 }
4513
4514 static void
4515 _elm_map_smart_move(Evas_Object *obj,
4516                     Evas_Coord x,
4517                     Evas_Coord y)
4518 {
4519    ELM_MAP_DATA_GET(obj, sd);
4520
4521    ELM_WIDGET_CLASS(_elm_map_parent_sc)->base.move(obj, x, y);
4522
4523    if (!strcmp(sd->engine->name, INTERNAL_ENGINE_NAME))
4524       evas_object_move(sd->hit_rect, x, y);
4525    else
4526      {
4527         sd->engine->move(obj, x, y);
4528         _overlay_place(sd);
4529      }
4530 }
4531
4532 static void
4533 _elm_map_smart_resize(Evas_Object *obj,
4534                       Evas_Coord w,
4535                       Evas_Coord h)
4536 {
4537    ELM_MAP_DATA_GET(obj, sd);
4538
4539    ELM_WIDGET_CLASS(_elm_map_parent_sc)->base.resize(obj, w, h);
4540
4541    if (!strcmp(sd->engine->name, INTERNAL_ENGINE_NAME))
4542       evas_object_resize(sd->hit_rect, w, h);
4543    else
4544      {
4545         sd->engine->resize(obj, w, h);
4546         _overlay_place(sd);
4547      }
4548 }
4549
4550 static void
4551 _elm_map_smart_member_add(Evas_Object *obj,
4552                           Evas_Object *member)
4553 {
4554    ELM_MAP_DATA_GET(obj, sd);
4555
4556    ELM_WIDGET_CLASS(_elm_map_parent_sc)->base.member_add(obj, member);
4557
4558    if (sd->hit_rect)
4559      evas_object_raise(sd->hit_rect);
4560 }
4561
4562 static void
4563 _elm_map_smart_set_user(Elm_Map_Smart_Class *sc)
4564 {
4565    ELM_WIDGET_CLASS(sc)->base.add = _elm_map_smart_add;
4566    ELM_WIDGET_CLASS(sc)->base.del = _elm_map_smart_del;
4567    ELM_WIDGET_CLASS(sc)->base.calculate = _elm_map_smart_calculate;
4568
4569    ELM_WIDGET_CLASS(sc)->base.move = _elm_map_smart_move;
4570    ELM_WIDGET_CLASS(sc)->base.resize = _elm_map_smart_resize;
4571    ELM_WIDGET_CLASS(sc)->base.member_add = _elm_map_smart_member_add;
4572
4573    ELM_WIDGET_CLASS(sc)->on_focus = _elm_map_smart_on_focus;
4574    ELM_WIDGET_CLASS(sc)->theme = _elm_map_smart_theme;
4575    ELM_WIDGET_CLASS(sc)->event = _elm_map_smart_event;
4576    ELM_WIDGET_CLASS(sc)->translate = _elm_map_smart_translate;
4577 }
4578 #endif
4579
4580 EAPI const Elm_Map_Smart_Class *
4581 elm_map_smart_class_get(void)
4582 {
4583 #ifdef HAVE_ELEMENTARY_ECORE_CON
4584    static Elm_Map_Smart_Class _sc =
4585      ELM_MAP_SMART_CLASS_INIT_NAME_VERSION(ELM_MAP_SMART_NAME);
4586    static const Elm_Map_Smart_Class *class = NULL;
4587    Evas_Smart_Class *esc = (Evas_Smart_Class *)&_sc;
4588
4589    if (class) return class;
4590
4591    _elm_map_smart_set(&_sc);
4592    esc->callbacks = _smart_callbacks;
4593    class = &_sc;
4594
4595    return class;
4596 #else
4597    return NULL;
4598 #endif
4599 }
4600
4601 EAPI Evas_Object *
4602 elm_map_add(Evas_Object *parent)
4603 {
4604 #ifdef HAVE_ELEMENTARY_ECORE_CON
4605    Evas_Object *obj;
4606
4607    EINA_SAFETY_ON_NULL_RETURN_VAL(parent, NULL);
4608
4609    obj = elm_widget_add(_elm_map_smart_class_new(), parent);
4610    if (!obj) return NULL;
4611
4612    if (!elm_widget_sub_object_add(parent, obj))
4613      ERR("could not add %p as sub object of %p", obj, parent);
4614
4615    return obj;
4616 #else
4617    (void)parent;
4618    return NULL;
4619 #endif
4620 }
4621
4622 EAPI void
4623 elm_map_zoom_set(Evas_Object *obj,
4624                  int zoom)
4625 {
4626 #ifdef HAVE_ELEMENTARY_ECORE_CON
4627
4628    ELM_MAP_CHECK(obj);
4629    ELM_MAP_DATA_GET(obj, sd);
4630    EINA_SAFETY_ON_NULL_RETURN(sd->src_tile);
4631
4632    Eina_Bool animation;
4633
4634    if (sd->mode != ELM_MAP_ZOOM_MODE_MANUAL) return;
4635    if (zoom < 0) zoom = 0;
4636    if (sd->zoom == zoom) return;
4637
4638    if (sd->paused) animation = EINA_FALSE;
4639    else animation = EINA_TRUE;
4640
4641    if (!strcmp(sd->engine->name, INTERNAL_ENGINE_NAME))
4642      {
4643         sd->calc_job.zoom_changed = EINA_TRUE;
4644         sd->calc_job.zoom_anim = animation;
4645         sd->calc_job.zoom = zoom;
4646         evas_object_smart_changed(sd->pan_obj);
4647      }
4648    else _zoom(sd, zoom, 1);
4649
4650 #else
4651    (void)obj;
4652    (void)zoom;
4653 #endif
4654 }
4655
4656 EAPI int
4657 elm_map_zoom_get(const Evas_Object *obj)
4658 {
4659 #ifdef HAVE_ELEMENTARY_ECORE_CON
4660    ELM_MAP_CHECK(obj) 0;
4661    ELM_MAP_DATA_GET(obj, sd);
4662
4663    return sd->zoom;
4664 #else
4665    (void)obj;
4666    return 0;
4667 #endif
4668 }
4669
4670 EAPI void
4671 elm_map_zoom_mode_set(Evas_Object *obj,
4672                       Elm_Map_Zoom_Mode mode)
4673 {
4674 #ifdef HAVE_ELEMENTARY_ECORE_CON
4675    ELM_MAP_CHECK(obj);
4676    ELM_MAP_DATA_GET(obj, sd);
4677
4678    if ((mode == ELM_MAP_ZOOM_MODE_MANUAL) && (sd->mode == !!mode)) return;
4679
4680    sd->mode = mode;
4681    if (!strcmp(sd->engine->name, INTERNAL_ENGINE_NAME))
4682      {
4683         sd->calc_job.zoom_changed = EINA_TRUE;
4684         sd->calc_job.zoom_anim = EINA_FALSE;
4685         sd->calc_job.zoom = sd->zoom;
4686         evas_object_smart_changed(sd->pan_obj);
4687      }
4688    else ERR("Engine(%s) do not support zoom mode", sd->engine->name);
4689
4690 #else
4691    (void)obj;
4692    (void)mode;
4693 #endif
4694 }
4695
4696 EAPI Elm_Map_Zoom_Mode
4697 elm_map_zoom_mode_get(const Evas_Object *obj)
4698 {
4699 #ifdef HAVE_ELEMENTARY_ECORE_CON
4700    ELM_MAP_CHECK(obj) ELM_MAP_ZOOM_MODE_MANUAL;
4701    ELM_MAP_DATA_GET(obj, sd);
4702
4703    return sd->mode;
4704 #else
4705    (void)obj;
4706    return ELM_MAP_ZOOM_MODE_MANUAL;
4707 #endif
4708 }
4709
4710 EAPI void
4711 elm_map_zoom_max_set(Evas_Object *obj,
4712                      int zoom)
4713 {
4714 #ifdef HAVE_ELEMENTARY_ECORE_CON
4715    ELM_MAP_CHECK(obj);
4716    ELM_MAP_DATA_GET(obj, sd);
4717    EINA_SAFETY_ON_NULL_RETURN(sd->src_tile);
4718
4719    sd->zoom_max = zoom;
4720 #else
4721    (void)obj;
4722    (void)zoom;
4723 #endif
4724 }
4725
4726 EAPI int
4727 elm_map_zoom_max_get(const Evas_Object *obj)
4728 {
4729 #ifdef HAVE_ELEMENTARY_ECORE_CON
4730    ELM_MAP_CHECK(obj) - 1;
4731    ELM_MAP_DATA_GET(obj, sd);
4732    EINA_SAFETY_ON_NULL_RETURN_VAL(sd->src_tile, -1);
4733
4734    return sd->zoom_max;
4735 #else
4736    (void)obj;
4737    return -1;
4738 #endif
4739 }
4740
4741 EAPI void
4742 elm_map_zoom_min_set(Evas_Object *obj,
4743                      int zoom)
4744 {
4745 #ifdef HAVE_ELEMENTARY_ECORE_CON
4746    ELM_MAP_CHECK(obj);
4747    ELM_MAP_DATA_GET(obj, sd);
4748    EINA_SAFETY_ON_NULL_RETURN(sd->src_tile);
4749
4750    sd->zoom_min = zoom;
4751 #else
4752    (void)obj;
4753    (void)zoom;
4754 #endif
4755 }
4756
4757 EAPI int
4758 elm_map_zoom_min_get(const Evas_Object *obj)
4759 {
4760 #ifdef HAVE_ELEMENTARY_ECORE_CON
4761    ELM_MAP_CHECK(obj) - 1;
4762    ELM_MAP_DATA_GET(obj, sd);
4763    EINA_SAFETY_ON_NULL_RETURN_VAL(sd->src_tile, -1);
4764
4765    return sd->zoom_min;
4766 #else
4767    (void)obj;
4768    return -1;
4769 #endif
4770 }
4771
4772 EAPI void
4773 elm_map_region_bring_in(Evas_Object *obj,
4774                         double lon,
4775                         double lat)
4776 {
4777 #ifdef HAVE_ELEMENTARY_ECORE_CON
4778    ELM_MAP_CHECK(obj);
4779    ELM_MAP_DATA_GET(obj, sd);
4780
4781    if (!strcmp(sd->engine->name, INTERNAL_ENGINE_NAME))
4782      {
4783         sd->calc_job.show_changed = EINA_TRUE;
4784         sd->calc_job.show_anim = EINA_TRUE;
4785         sd->calc_job.lon = lon;
4786         sd->calc_job.lat = lat;
4787         evas_object_smart_changed(sd->pan_obj);
4788      }
4789    else
4790      {
4791         sd->engine->show(obj, lon, lat, 1);
4792         _overlay_place(sd);
4793      }
4794 #else
4795    (void)obj;
4796    (void)lon;
4797    (void)lat;
4798 #endif
4799 }
4800
4801 EAPI void
4802 elm_map_region_show(Evas_Object *obj,
4803                     double lon,
4804                     double lat)
4805 {
4806 #ifdef HAVE_ELEMENTARY_ECORE_CON
4807    ELM_MAP_CHECK(obj);
4808    ELM_MAP_DATA_GET(obj, sd);
4809
4810    if (!strcmp(sd->engine->name, INTERNAL_ENGINE_NAME))
4811      {
4812         sd->calc_job.show_changed = EINA_TRUE;
4813         sd->calc_job.show_anim = EINA_FALSE;
4814         sd->calc_job.lon = lon;
4815         sd->calc_job.lat = lat;
4816         evas_object_smart_changed(sd->pan_obj);
4817      }
4818    else
4819      {
4820         sd->engine->show(obj, lon, lat, 0);
4821         _overlay_place(sd);
4822      }
4823
4824 #else
4825    (void)obj;
4826    (void)lon;
4827    (void)lat;
4828 #endif
4829 }
4830
4831 EAPI void
4832 elm_map_region_get(const Evas_Object *obj,
4833                    double *lon,
4834                    double *lat)
4835 {
4836 #ifdef HAVE_ELEMENTARY_ECORE_CON
4837
4838    ELM_MAP_CHECK(obj);
4839    ELM_MAP_DATA_GET(obj, sd);
4840
4841    double tlon, tlat;
4842    sd->engine->region_get(obj, &tlon, &tlat);
4843    if (lon) *lon = tlon;
4844    if (lat) *lat = tlat;
4845 #else
4846    (void)obj;
4847    (void)lon;
4848    (void)lat;
4849 #endif
4850 }
4851
4852 EAPI void
4853 elm_map_paused_set(Evas_Object *obj,
4854                    Eina_Bool paused)
4855 {
4856 #ifdef HAVE_ELEMENTARY_ECORE_CON
4857    ELM_MAP_CHECK(obj);
4858    ELM_MAP_DATA_GET(obj, sd);
4859
4860    if (sd->paused == !!paused) return;
4861    sd->paused = !!paused;
4862
4863    if (!strcmp(sd->engine->name, INTERNAL_ENGINE_NAME))
4864      {
4865         if (paused)
4866           {
4867              if (sd->zoom_animator)
4868                {
4869                   if (sd->zoom_animator) ecore_animator_del(sd->zoom_animator);
4870                   sd->zoom_animator = NULL;
4871                   sd->zoom_detail = sd->zoom;
4872                   _map_pan_zoom_do(sd, sd->zoom);
4873                }
4874              edje_object_signal_emit(ELM_WIDGET_DATA(sd)->resize_obj,
4875                                      "elm,state,busy,stop", "elm");
4876           }
4877         else
4878           {
4879              if (sd->download_num >= 1)
4880                 edje_object_signal_emit(ELM_WIDGET_DATA(sd)->resize_obj,
4881                                         "elm,state,busy,start", "elm");
4882           }
4883      }
4884
4885 #else
4886    (void)obj;
4887    (void)paused;
4888 #endif
4889 }
4890
4891 EAPI Eina_Bool
4892 elm_map_paused_get(const Evas_Object *obj)
4893 {
4894 #ifdef HAVE_ELEMENTARY_ECORE_CON
4895    ELM_MAP_CHECK(obj) EINA_FALSE;
4896    ELM_MAP_DATA_GET(obj, sd);
4897
4898    return sd->paused;
4899 #else
4900    (void)obj;
4901    return EINA_FALSE;
4902 #endif
4903 }
4904
4905 EAPI void
4906 elm_map_rotate_set(Evas_Object *obj,
4907                    double degree,
4908                    Evas_Coord cx,
4909                    Evas_Coord cy)
4910 {
4911 #ifdef HAVE_ELEMENTARY_ECORE_CON
4912    ELM_MAP_CHECK(obj);
4913    ELM_MAP_DATA_GET(obj, sd);
4914
4915    sd->engine->rotate(obj, degree, cx, cy, degree);
4916 #else
4917    (void)obj;
4918    (void)degree;
4919    (void)cx;
4920    (void)cy;
4921 #endif
4922 }
4923
4924 EAPI void
4925 elm_map_rotate_get(const Evas_Object *obj,
4926                    double *degree,
4927                    Evas_Coord *cx,
4928                    Evas_Coord *cy)
4929 {
4930 #ifdef HAVE_ELEMENTARY_ECORE_CON
4931    ELM_MAP_CHECK(obj);
4932    ELM_MAP_DATA_GET(obj, sd);
4933
4934    sd->engine->rotate_get(obj, degree, cx, cy);
4935 #else
4936    (void)obj;
4937    (void)degree;
4938    (void)cx;
4939    (void)cy;
4940 #endif
4941 }
4942
4943 EAPI void
4944 elm_map_wheel_disabled_set(Evas_Object *obj,
4945                            Eina_Bool disabled)
4946 {
4947 #ifdef HAVE_ELEMENTARY_ECORE_CON
4948    ELM_MAP_CHECK(obj);
4949    ELM_MAP_DATA_GET(obj, sd);
4950
4951    if ((!sd->wheel_disabled) && (disabled))
4952      evas_object_event_callback_del_full
4953        (obj, EVAS_CALLBACK_MOUSE_WHEEL, _mouse_wheel_cb, sd);
4954    else if ((sd->wheel_disabled) && (!disabled))
4955      evas_object_event_callback_add
4956        (obj, EVAS_CALLBACK_MOUSE_WHEEL, _mouse_wheel_cb, sd);
4957    sd->wheel_disabled = !!disabled;
4958 #else
4959    (void)obj;
4960    (void)disabled;
4961 #endif
4962 }
4963
4964 EAPI Eina_Bool
4965 elm_map_wheel_disabled_get(const Evas_Object *obj)
4966 {
4967 #ifdef HAVE_ELEMENTARY_ECORE_CON
4968    ELM_MAP_CHECK(obj) EINA_FALSE;
4969    ELM_MAP_DATA_GET(obj, sd);
4970
4971    return sd->wheel_disabled;
4972 #else
4973    (void)obj;
4974    return EINA_FALSE;
4975 #endif
4976 }
4977
4978 EAPI void
4979 elm_map_tile_load_status_get(const Evas_Object *obj,
4980                              int *try_num,
4981                              int *finish_num)
4982 {
4983 #ifdef HAVE_ELEMENTARY_ECORE_CON
4984    ELM_MAP_CHECK(obj);
4985    ELM_MAP_DATA_GET(obj, sd);
4986
4987    if (try_num) *try_num = sd->try_num;
4988    if (finish_num) *finish_num = sd->finish_num;
4989 #else
4990    (void)obj;
4991    (void)try_num;
4992    (void)finish_num;
4993 #endif
4994 }
4995
4996 EAPI void
4997 elm_map_canvas_to_region_convert(const Evas_Object *obj,
4998                                  Evas_Coord x,
4999                                  Evas_Coord y,
5000                                  double *lon,
5001                                  double *lat)
5002 {
5003 #ifdef HAVE_ELEMENTARY_ECORE_CON
5004    ELM_MAP_CHECK(obj);
5005    ELM_MAP_DATA_GET(obj, sd);
5006    EINA_SAFETY_ON_NULL_RETURN(lon);
5007    EINA_SAFETY_ON_NULL_RETURN(lat);
5008
5009    sd->engine->canvas_to_region(obj, x, y, lon, lat);
5010 #else
5011    (void)obj;
5012    (void)x;
5013    (void)y;
5014    (void)lon;
5015    (void)lat;
5016 #endif
5017 }
5018
5019 EAPI void
5020 elm_map_region_to_canvas_convert(const Evas_Object *obj,
5021                                  double lon,
5022                                  double lat,
5023                                  Evas_Coord *x,
5024                                  Evas_Coord *y)
5025 {
5026 #ifdef HAVE_ELEMENTARY_ECORE_CON
5027    ELM_MAP_CHECK(obj);
5028    ELM_MAP_DATA_GET(obj, sd);
5029    EINA_SAFETY_ON_NULL_RETURN(x);
5030    EINA_SAFETY_ON_NULL_RETURN(y);
5031
5032    sd->engine->region_to_canvas(obj, lon, lat, x, y);
5033 #else
5034    (void)obj;
5035    (void)lon;
5036    (void)lat;
5037    (void)x;
5038    (void)y;
5039 #endif
5040 }
5041
5042 EAPI void
5043 elm_map_user_agent_set(Evas_Object *obj,
5044                        const char *user_agent)
5045 {
5046 #ifdef HAVE_ELEMENTARY_ECORE_CON
5047    ELM_MAP_CHECK(obj);
5048    ELM_MAP_DATA_GET(obj, sd);
5049    EINA_SAFETY_ON_NULL_RETURN(user_agent);
5050
5051    eina_stringshare_replace(&sd->user_agent, user_agent);
5052
5053    if (!sd->ua) sd->ua = eina_hash_string_small_new(NULL);
5054    eina_hash_set(sd->ua, "User-Agent", sd->user_agent);
5055 #else
5056    (void)obj;
5057    (void)user_agent;
5058 #endif
5059 }
5060
5061 EAPI const char *
5062 elm_map_user_agent_get(const Evas_Object *obj)
5063 {
5064 #ifdef HAVE_ELEMENTARY_ECORE_CON
5065    ELM_MAP_CHECK(obj) NULL;
5066    ELM_MAP_DATA_GET(obj, sd);
5067
5068    return sd->user_agent;
5069 #else
5070    (void)obj;
5071    return NULL;
5072 #endif
5073 }
5074
5075 EAPI void
5076 elm_map_engine_set(Evas_Object *obj,
5077                    const char *engine_name)
5078 {
5079    ELM_MAP_CHECK(obj);
5080    ELM_MAP_DATA_GET(obj, sd);
5081    EINA_SAFETY_ON_NULL_RETURN(engine_name);
5082
5083    Source_Engine *engine = NULL;
5084    Source_Engine *e;
5085    Eina_List *l;
5086    Evas_Object *layout;
5087    double lon, lat;
5088
5089    if (sd->engine && !strcmp(sd->engine->name, engine_name))
5090       return;
5091
5092    EINA_LIST_FOREACH(sd->engines, l, e)
5093      {
5094         if (!strcmp(e->name, engine_name))
5095           {
5096              engine = e;
5097              break;
5098           }
5099      }
5100    if (!engine)
5101      {
5102         ERR("Engine name (%s) is not found", engine_name);
5103         return;
5104      }
5105    layout = engine->add(obj);
5106    if (!layout)
5107      {
5108         engine->del(obj);
5109         ERR("%s engine can not be added", engine->name);
5110         return;
5111      }
5112    sd->engine->region_get(obj, &lon, &lat);
5113    sd->engine->del(obj);
5114    sd->engine = engine;
5115
5116    if (sd->engine->zoom_max < sd->zoom)
5117      sd->zoom = sd->engine->zoom_max;
5118    else if (sd->engine->zoom_min > sd->zoom)
5119      sd->zoom = sd->engine->zoom_min;
5120
5121    if (sd->engine->zoom_max < sd->zoom_max)
5122      sd->zoom_max = sd->engine->zoom_max;
5123    if (sd->engine->zoom_min > sd->zoom_min)
5124      sd->zoom_min = sd->engine->zoom_min;
5125
5126    evas_object_hide(ELM_WIDGET_DATA(sd)->resize_obj);
5127    elm_widget_resize_object_set(obj, layout);
5128    sd->engine->zoom(obj, sd->zoom, 0);
5129    sd->engine->show(obj, lon, lat, 0);
5130 }
5131
5132 EAPI const char *
5133 elm_map_engine_get(const Evas_Object *obj)
5134 {
5135    ELM_MAP_CHECK(obj) NULL;
5136    ELM_MAP_DATA_GET(obj, sd);
5137
5138    EINA_SAFETY_ON_NULL_RETURN_VAL(sd->src_tile, NULL);
5139
5140    return sd->engine->name;
5141 }
5142
5143 EAPI const char **
5144 elm_map_engines_get(const Evas_Object *obj)
5145 {
5146    ELM_MAP_CHECK(obj) NULL;
5147    ELM_MAP_DATA_GET(obj, sd);
5148
5149    return sd->engine_names;
5150 }
5151
5152 EAPI void
5153 elm_map_source_set(Evas_Object *obj,
5154                    Elm_Map_Source_Type type,
5155                    const char *source_name)
5156 {
5157 #ifdef HAVE_ELEMENTARY_ECORE_CON
5158    ELM_MAP_CHECK(obj);
5159    ELM_MAP_DATA_GET(obj, sd);
5160    EINA_SAFETY_ON_NULL_RETURN(source_name);
5161
5162    if (strcmp(sd->engine->name, INTERNAL_ENGINE_NAME))
5163      {
5164         ERR("Current engine is not %s", INTERNAL_ENGINE_NAME);
5165         return;
5166      }
5167
5168    if (type == ELM_MAP_SOURCE_TYPE_TILE)
5169       _source_tile_set(sd, source_name);
5170    else if (type == ELM_MAP_SOURCE_TYPE_ROUTE)
5171      _source_route_set(sd, source_name);
5172    else if (type == ELM_MAP_SOURCE_TYPE_NAME)
5173      _source_name_set(sd, source_name);
5174    else ERR("Not supported map source type: %d", type);
5175
5176 #else
5177    (void)obj;
5178    (void)type;
5179    (void)source_name;
5180 #endif
5181 }
5182
5183 EAPI const char *
5184 elm_map_source_get(const Evas_Object *obj,
5185                    Elm_Map_Source_Type type)
5186 {
5187 #ifdef HAVE_ELEMENTARY_ECORE_CON
5188    ELM_MAP_CHECK(obj) NULL;
5189    ELM_MAP_DATA_GET(obj, sd);
5190
5191    if (strcmp(sd->engine->name, INTERNAL_ENGINE_NAME))
5192      {
5193         ERR("Current engine is not %s", INTERNAL_ENGINE_NAME);
5194         return NULL;
5195      }
5196    EINA_SAFETY_ON_NULL_RETURN_VAL(sd->src_tile, NULL);
5197
5198    if (type == ELM_MAP_SOURCE_TYPE_TILE) return sd->src_tile->name;
5199    else if (type == ELM_MAP_SOURCE_TYPE_ROUTE)
5200      return sd->src_route->name;
5201    else if (type == ELM_MAP_SOURCE_TYPE_NAME)
5202      return sd->src_name->name;
5203    else ERR("Not supported map source type: %d", type);
5204
5205    return NULL;
5206 #else
5207    (void)obj;
5208    (void)type;
5209    return NULL;
5210 #endif
5211 }
5212
5213 EAPI const char **
5214 elm_map_sources_get(const Evas_Object *obj,
5215                     Elm_Map_Source_Type type)
5216 {
5217 #ifdef HAVE_ELEMENTARY_ECORE_CON
5218    ELM_MAP_CHECK(obj) NULL;
5219    ELM_MAP_DATA_GET(obj, sd);
5220
5221    if (type == ELM_MAP_SOURCE_TYPE_TILE) return sd->src_tile_names;
5222    else if (type == ELM_MAP_SOURCE_TYPE_ROUTE)
5223      return sd->src_route_names;
5224    else if (type == ELM_MAP_SOURCE_TYPE_NAME)
5225      return sd->src_name_names;
5226    else ERR("Not supported map source type: %d", type);
5227
5228    return NULL;
5229 #else
5230    (void)obj;
5231    (void)type;
5232    return NULL;
5233 #endif
5234 }
5235
5236 EAPI Elm_Map_Route *
5237 elm_map_route_add(Evas_Object *obj,
5238                   Elm_Map_Route_Type type,
5239                   Elm_Map_Route_Method method,
5240                   double flon,
5241                   double flat,
5242                   double tlon,
5243                   double tlat,
5244                   Elm_Map_Route_Cb route_cb,
5245                   void *data)
5246 {
5247 #ifdef HAVE_ELEMENTARY_ECORE_CON
5248    char *url;
5249    char *type_name;
5250    Elm_Map_Route *route;
5251    char fname[PATH_MAX], fname2[PATH_MAX];
5252
5253    ELM_MAP_CHECK(obj) NULL;
5254    ELM_MAP_DATA_GET(obj, sd);
5255
5256    EINA_SAFETY_ON_NULL_RETURN_VAL(sd->src_route, NULL);
5257
5258    {
5259       const char *cachedir;
5260
5261 #ifdef ELM_EFREET
5262       snprintf(fname, sizeof(fname), "%s" CACHE_ROUTE_ROOT,
5263                efreet_cache_home_get());
5264       (void)cachedir;
5265 #else
5266       cachedir = getenv("XDG_CACHE_HOME");
5267       snprintf(fname, sizeof(fname), "%s/%s" CACHE_ROUTE_ROOT, getenv("HOME"),
5268                cachedir ? : "/.config");
5269 #endif
5270       if (!ecore_file_exists(fname)) ecore_file_mkpath(fname);
5271    }
5272
5273    if (type == ELM_MAP_ROUTE_TYPE_MOTOCAR)
5274      type_name = strdup(ROUTE_TYPE_MOTORCAR);
5275    else if (type == ELM_MAP_ROUTE_TYPE_BICYCLE)
5276      type_name = strdup(ROUTE_TYPE_BICYCLE);
5277    else if (type == ELM_MAP_ROUTE_TYPE_FOOT)
5278      type_name = strdup(ROUTE_TYPE_FOOT);
5279    else type_name = NULL;
5280
5281    url = sd->src_route->url_cb(obj, type_name, method, flon, flat, tlon, tlat);
5282    if (!url)
5283      {
5284         ERR("Route URL is NULL");
5285         if (type_name) free(type_name);
5286         return NULL;
5287      }
5288    if (type_name) free(type_name);
5289
5290    route = ELM_NEW(Elm_Map_Route);
5291    route->wsd = sd;
5292    snprintf(fname2, sizeof(fname2), "%s/%d", fname, rand());
5293    route->fname = strdup(fname2);
5294    route->type = type;
5295    route->method = method;
5296    route->flon = flon;
5297    route->flat = flat;
5298    route->tlon = tlon;
5299    route->tlat = tlat;
5300    route->cb = route_cb;
5301    route->data = data;
5302
5303    if (!ecore_file_download_full(url, route->fname, _route_cb, NULL, route,
5304                                  &(route->job), sd->ua) || !(route->job))
5305      {
5306         ERR("Can't request Route from %s to %s", url, route->fname);
5307         free(route->fname);
5308         free(route);
5309         return NULL;
5310      }
5311    INF("Route requested from %s to %s", url, route->fname);
5312    free(url);
5313
5314    sd->routes = eina_list_append(sd->routes, route);
5315    evas_object_smart_callback_call
5316      (ELM_WIDGET_DATA(sd)->obj, SIG_ROUTE_LOAD, route);
5317    edje_object_signal_emit(ELM_WIDGET_DATA(sd)->resize_obj,
5318                            "elm,state,busy,start", "elm");
5319    return route;
5320 #else
5321    (void)obj;
5322    (void)type;
5323    (void)method;
5324    (void)flon;
5325    (void)flat;
5326    (void)tlon;
5327    (void)tlat;
5328    (void)route_cb;
5329    (void)data;
5330    return NULL;
5331 #endif
5332 }
5333
5334 EAPI void
5335 elm_map_route_del(Elm_Map_Route *route)
5336 {
5337 #ifdef HAVE_ELEMENTARY_ECORE_CON
5338    Path_Waypoint *w;
5339    Path_Node *n;
5340
5341    EINA_SAFETY_ON_NULL_RETURN(route);
5342    EINA_SAFETY_ON_NULL_RETURN(route->wsd);
5343    ELM_MAP_CHECK(ELM_WIDGET_DATA(route->wsd)->obj);
5344
5345    if (route->job) ecore_file_download_abort(route->job);
5346
5347    EINA_LIST_FREE (route->waypoint, w)
5348      {
5349         if (w->point) eina_stringshare_del(w->point);
5350         free(w);
5351      }
5352
5353    EINA_LIST_FREE (route->nodes, n)
5354      {
5355         if (n->pos.address) eina_stringshare_del(n->pos.address);
5356         free(n);
5357      }
5358
5359    if (route->fname)
5360      {
5361         ecore_file_remove(route->fname);
5362         free(route->fname);
5363      }
5364
5365    route->wsd->routes = eina_list_remove(route->wsd->routes, route);
5366    free(route);
5367 #else
5368    (void)route;
5369 #endif
5370 }
5371
5372 EAPI double
5373 elm_map_route_distance_get(const Elm_Map_Route *route)
5374 {
5375 #ifdef HAVE_ELEMENTARY_ECORE_CON
5376    EINA_SAFETY_ON_NULL_RETURN_VAL(route, 0.0);
5377    return route->info.distance;
5378 #else
5379    (void)route;
5380    return 0.0;
5381 #endif
5382 }
5383
5384 EAPI const char *
5385 elm_map_route_node_get(const Elm_Map_Route *route)
5386 {
5387 #ifdef HAVE_ELEMENTARY_ECORE_CON
5388    EINA_SAFETY_ON_NULL_RETURN_VAL(route, NULL);
5389    return route->info.nodes;
5390 #else
5391    (void)route;
5392    return NULL;
5393 #endif
5394 }
5395
5396 EAPI const char *
5397 elm_map_route_waypoint_get(const Elm_Map_Route *route)
5398 {
5399 #ifdef HAVE_ELEMENTARY_ECORE_CON
5400    EINA_SAFETY_ON_NULL_RETURN_VAL(route, NULL);
5401    return route->info.waypoints;
5402 #else
5403    (void)route;
5404    return NULL;
5405 #endif
5406 }
5407
5408 EAPI Elm_Map_Name *
5409 elm_map_name_add(const Evas_Object *obj,
5410                  const char *address,
5411                  double lon,
5412                  double lat,
5413                  Elm_Map_Name_Cb name_cb,
5414                  void *data)
5415 {
5416 #ifdef HAVE_ELEMENTARY_ECORE_CON
5417    ELM_MAP_CHECK(obj) NULL;
5418
5419    if (address)
5420      return _name_request(obj, ELM_MAP_NAME_METHOD_SEARCH, address, 0, 0,
5421                           name_cb, data);
5422    else
5423      return _name_request(obj, ELM_MAP_NAME_METHOD_REVERSE, NULL, lon, lat,
5424                           name_cb, data);
5425 #else
5426    (void)obj;
5427    (void)address;
5428    (void)lon;
5429    (void)lat;
5430    (void)name_cb;
5431    (void)data;
5432    return NULL;
5433 #endif
5434 }
5435
5436 EAPI void
5437 elm_map_name_search(const Evas_Object *obj,
5438                   const char *address,
5439                   Elm_Map_Name_List_Cb name_cb,
5440                   void *data)
5441 {
5442 #ifdef HAVE_ELEMENTARY_ECORE_CON
5443    ELM_MAP_CHECK(obj);
5444    if (address)
5445      _name_list_request(obj, ELM_MAP_NAME_METHOD_SEARCH, address, 0, 0,
5446                         name_cb, data);
5447 #else
5448    (void) obj;
5449    (void) address;
5450    (void) name_cb;
5451    (void) data;
5452 #endif
5453 }
5454
5455 EAPI void
5456 elm_map_name_del(Elm_Map_Name *name)
5457 {
5458 #ifdef HAVE_ELEMENTARY_ECORE_CON
5459    EINA_SAFETY_ON_NULL_RETURN(name);
5460    EINA_SAFETY_ON_NULL_RETURN(name->wsd);
5461    ELM_MAP_CHECK(ELM_WIDGET_DATA(name->wsd)->obj);
5462
5463    if (name->job) ecore_file_download_abort(name->job);
5464    if (name->address) free(name->address);
5465    if (name->fname)
5466      {
5467         ecore_file_remove(name->fname);
5468         free(name->fname);
5469      }
5470
5471    name->wsd->names = eina_list_remove(name->wsd->names, name);
5472    free(name);
5473 #else
5474    (void)name;
5475 #endif
5476 }
5477
5478 EAPI const char *
5479 elm_map_name_address_get(const Elm_Map_Name *name)
5480 {
5481 #ifdef HAVE_ELEMENTARY_ECORE_CON
5482    EINA_SAFETY_ON_NULL_RETURN_VAL(name, NULL);
5483    EINA_SAFETY_ON_NULL_RETURN_VAL(name->wsd, NULL);
5484    ELM_MAP_CHECK(ELM_WIDGET_DATA(name->wsd)->obj) NULL;
5485
5486    return name->address;
5487 #else
5488    (void)name;
5489    return NULL;
5490 #endif
5491 }
5492
5493 EAPI void
5494 elm_map_name_region_get(const Elm_Map_Name *name,
5495                         double *lon,
5496                         double *lat)
5497 {
5498 #ifdef HAVE_ELEMENTARY_ECORE_CON
5499    EINA_SAFETY_ON_NULL_RETURN(name);
5500    EINA_SAFETY_ON_NULL_RETURN(name->wsd);
5501    ELM_MAP_CHECK(ELM_WIDGET_DATA(name->wsd)->obj);
5502
5503    if (lon) *lon = name->lon;
5504    if (lat) *lat = name->lat;
5505 #else
5506    (void)name;
5507    (void)lon;
5508    (void)lat;
5509 #endif
5510 }
5511
5512 EAPI Elm_Map_Overlay *
5513 elm_map_overlay_add(Evas_Object *obj,
5514                     double lon,
5515                     double lat)
5516 {
5517 #ifdef HAVE_ELEMENTARY_ECORE_CON
5518    Elm_Map_Overlay *overlay;
5519
5520    ELM_MAP_CHECK(obj) NULL;
5521    ELM_MAP_DATA_GET(obj, sd);
5522
5523    overlay = ELM_NEW(Elm_Map_Overlay);
5524    overlay->wsd = sd;
5525    overlay->type = ELM_MAP_OVERLAY_TYPE_DEFAULT;
5526    overlay->c.r = 0x87;
5527    overlay->c.g = 0xce;
5528    overlay->c.b = 0xeb;
5529    overlay->c.a = 255;
5530    overlay->ovl = _overlay_default_new(overlay, lon, lat, overlay->c, 1);
5531    overlay->grp = _overlay_group_new(sd);
5532    sd->overlays = eina_list_append(sd->overlays, overlay);
5533
5534    evas_object_smart_changed(sd->pan_obj);
5535
5536    return overlay;
5537 #else
5538    (void)obj;
5539    (void)lon;
5540    (void)lat;
5541    return NULL;
5542 #endif
5543 }
5544
5545 EAPI Eina_List *
5546 elm_map_overlays_get(Evas_Object *obj)
5547 {
5548 #ifdef HAVE_ELEMENTARY_ECORE_CON
5549    Eina_List *l;
5550    Elm_Map_Overlay *ovl;
5551
5552    ELM_MAP_CHECK(obj) NULL;
5553    ELM_MAP_DATA_GET(obj, sd);
5554
5555    eina_list_free(sd->all_overlays);
5556    sd->all_overlays = NULL;
5557
5558    EINA_LIST_FOREACH(sd->overlays, l, ovl)
5559      sd->all_overlays = eina_list_append(sd->all_overlays, ovl);
5560    EINA_LIST_FOREACH(sd->group_overlays, l, ovl)
5561      sd->all_overlays = eina_list_append(sd->all_overlays, ovl);
5562
5563    return sd->all_overlays;
5564 #else
5565    (void)obj;
5566    return NULL;
5567 #endif
5568 }
5569
5570 EAPI void
5571 elm_map_overlay_del(Elm_Map_Overlay *overlay)
5572 {
5573 #ifdef HAVE_ELEMENTARY_ECORE_CON
5574    EINA_SAFETY_ON_NULL_RETURN(overlay);
5575    EINA_SAFETY_ON_NULL_RETURN(overlay->wsd);
5576    ELM_MAP_CHECK(ELM_WIDGET_DATA(overlay->wsd)->obj);
5577
5578    evas_object_smart_callback_call
5579      (ELM_WIDGET_DATA(overlay->wsd)->obj, SIG_OVERLAY_DEL, overlay);
5580    if (overlay->del_cb)
5581      overlay->del_cb
5582        (overlay->del_cb_data, ELM_WIDGET_DATA(overlay->wsd)->obj, overlay);
5583
5584    if (overlay->grp)
5585      {
5586         if (overlay->grp->klass)
5587           elm_map_overlay_class_remove(overlay->grp->klass, overlay);
5588         _overlay_group_free(overlay->grp);
5589      }
5590
5591    if (overlay->type == ELM_MAP_OVERLAY_TYPE_DEFAULT)
5592      _overlay_default_free(overlay->ovl);
5593    else if (overlay->type == ELM_MAP_OVERLAY_TYPE_BUBBLE)
5594      _overlay_bubble_free(overlay->ovl);
5595    else if (overlay->type == ELM_MAP_OVERLAY_TYPE_CLASS)
5596      _overlay_class_free(overlay->ovl);
5597    else if (overlay->type == ELM_MAP_OVERLAY_TYPE_ROUTE)
5598      _overlay_route_free(overlay->ovl);
5599    else if (overlay->type == ELM_MAP_OVERLAY_TYPE_LINE)
5600      _overlay_line_free(overlay->ovl);
5601    else if (overlay->type == ELM_MAP_OVERLAY_TYPE_POLYGON)
5602      _overlay_polygon_free(overlay->ovl);
5603    else if (overlay->type == ELM_MAP_OVERLAY_TYPE_CIRCLE)
5604      _overlay_circle_free(overlay->ovl);
5605    else if (overlay->type == ELM_MAP_OVERLAY_TYPE_SCALE)
5606      _overlay_scale_free(overlay->ovl);
5607    else ERR("Invalid overlay type: %d", overlay->type);
5608
5609    overlay->wsd->overlays = eina_list_remove(overlay->wsd->overlays, overlay);
5610    evas_object_smart_changed(overlay->wsd->pan_obj);
5611
5612    free(overlay);
5613 #else
5614    (void)overlay;
5615 #endif
5616 }
5617
5618 EAPI Elm_Map_Overlay_Type
5619 elm_map_overlay_type_get(const Elm_Map_Overlay *overlay)
5620 {
5621 #ifdef HAVE_ELEMENTARY_ECORE_CON
5622    EINA_SAFETY_ON_NULL_RETURN_VAL(overlay, ELM_MAP_OVERLAY_TYPE_NONE);
5623    EINA_SAFETY_ON_NULL_RETURN_VAL(overlay->wsd, ELM_MAP_OVERLAY_TYPE_NONE);
5624    ELM_MAP_CHECK(ELM_WIDGET_DATA(overlay->wsd)->obj) ELM_MAP_OVERLAY_TYPE_NONE;
5625
5626    return overlay->type;
5627 #else
5628    (void)overlay;
5629    return ELM_MAP_OVERLAY_TYPE_NONE;
5630 #endif
5631 }
5632
5633 EAPI void
5634 elm_map_overlay_data_set(Elm_Map_Overlay *overlay,
5635                          void *data)
5636 {
5637 #ifdef HAVE_ELEMENTARY_ECORE_CON
5638    EINA_SAFETY_ON_NULL_RETURN(overlay);
5639    EINA_SAFETY_ON_NULL_RETURN(overlay->wsd);
5640    ELM_MAP_CHECK(ELM_WIDGET_DATA(overlay->wsd)->obj);
5641
5642    overlay->data = data;
5643 #else
5644    (void)overlay;
5645    (void)data;
5646 #endif
5647 }
5648
5649 EAPI void *
5650 elm_map_overlay_data_get(const Elm_Map_Overlay *overlay)
5651 {
5652 #ifdef HAVE_ELEMENTARY_ECORE_CON
5653    EINA_SAFETY_ON_NULL_RETURN_VAL(overlay, NULL);
5654    EINA_SAFETY_ON_NULL_RETURN_VAL(overlay->wsd, NULL);
5655    ELM_MAP_CHECK(ELM_WIDGET_DATA(overlay->wsd)->obj) NULL;
5656
5657    return overlay->data;
5658 #else
5659    (void)overlay;
5660    return NULL;
5661 #endif
5662 }
5663
5664 EAPI void
5665 elm_map_overlay_hide_set(Elm_Map_Overlay *overlay,
5666                          Eina_Bool hide)
5667 {
5668 #ifdef HAVE_ELEMENTARY_ECORE_CON
5669    EINA_SAFETY_ON_NULL_RETURN(overlay);
5670    EINA_SAFETY_ON_NULL_RETURN(overlay->wsd);
5671    ELM_MAP_CHECK(ELM_WIDGET_DATA(overlay->wsd)->obj);
5672
5673    if (overlay->hide == !!hide) return;
5674    overlay->hide = hide;
5675
5676    evas_object_smart_changed(overlay->wsd->pan_obj);
5677 #else
5678    (void)overlay;
5679    (void)hide;
5680 #endif
5681 }
5682
5683 EAPI Eina_Bool
5684 elm_map_overlay_hide_get(const Elm_Map_Overlay *overlay)
5685 {
5686 #ifdef HAVE_ELEMENTARY_ECORE_CON
5687    EINA_SAFETY_ON_NULL_RETURN_VAL(overlay, EINA_FALSE);
5688    EINA_SAFETY_ON_NULL_RETURN_VAL(overlay->wsd, EINA_FALSE);
5689    ELM_MAP_CHECK(ELM_WIDGET_DATA(overlay->wsd)->obj) EINA_FALSE;
5690
5691    return overlay->hide;
5692 #else
5693    (void)overlay;
5694    return EINA_FALSE;
5695 #endif
5696 }
5697
5698 EAPI void
5699 elm_map_overlay_displayed_zoom_min_set(Elm_Map_Overlay *overlay,
5700                                        int zoom)
5701 {
5702 #ifdef HAVE_ELEMENTARY_ECORE_CON
5703    EINA_SAFETY_ON_NULL_RETURN(overlay);
5704    EINA_SAFETY_ON_NULL_RETURN(overlay->wsd);
5705    ELM_MAP_CHECK(ELM_WIDGET_DATA(overlay->wsd)->obj);
5706
5707    overlay->zoom_min = zoom;
5708    evas_object_smart_changed(overlay->wsd->pan_obj);
5709 #else
5710    (void)overlay;
5711    (void)zoom;
5712 #endif
5713 }
5714
5715 EAPI int
5716 elm_map_overlay_displayed_zoom_min_get(const Elm_Map_Overlay *overlay)
5717 {
5718 #ifdef HAVE_ELEMENTARY_ECORE_CON
5719    EINA_SAFETY_ON_NULL_RETURN_VAL(overlay, 0);
5720    EINA_SAFETY_ON_NULL_RETURN_VAL(overlay->wsd, 0);
5721    ELM_MAP_CHECK(ELM_WIDGET_DATA(overlay->wsd)->obj) 0;
5722
5723    return overlay->zoom_min;
5724 #else
5725    (void)overlay;
5726    return 0;
5727 #endif
5728 }
5729
5730 EAPI void
5731 elm_map_overlay_paused_set(Elm_Map_Overlay *overlay,
5732                            Eina_Bool paused)
5733 {
5734 #ifdef HAVE_ELEMENTARY_ECORE_CON
5735    EINA_SAFETY_ON_NULL_RETURN(overlay);
5736    EINA_SAFETY_ON_NULL_RETURN(overlay->wsd);
5737    ELM_MAP_CHECK(ELM_WIDGET_DATA(overlay->wsd)->obj);
5738
5739    if (overlay->paused == !!paused) return;
5740    overlay->paused = paused;
5741
5742    evas_object_smart_changed(overlay->wsd->pan_obj);
5743 #else
5744    (void)overlay;
5745    (void)paused;
5746 #endif
5747 }
5748
5749 EAPI Eina_Bool
5750 elm_map_overlay_paused_get(const Elm_Map_Overlay *overlay)
5751 {
5752 #ifdef HAVE_ELEMENTARY_ECORE_CON
5753    EINA_SAFETY_ON_NULL_RETURN_VAL(overlay, EINA_FALSE);
5754    EINA_SAFETY_ON_NULL_RETURN_VAL(overlay->wsd, EINA_FALSE);
5755    ELM_MAP_CHECK(ELM_WIDGET_DATA(overlay->wsd)->obj) EINA_FALSE;
5756
5757    return overlay->paused;
5758 #else
5759    (void)overlay;
5760    return EINA_FALSE;
5761 #endif
5762 }
5763
5764 EAPI Eina_Bool
5765 elm_map_overlay_visible_get(const Elm_Map_Overlay *overlay)
5766 {
5767 #ifdef HAVE_ELEMENTARY_ECORE_CON
5768    EINA_SAFETY_ON_NULL_RETURN_VAL(overlay, EINA_FALSE);
5769    EINA_SAFETY_ON_NULL_RETURN_VAL(overlay->wsd, EINA_FALSE);
5770    ELM_MAP_CHECK(ELM_WIDGET_DATA(overlay->wsd)->obj) EINA_FALSE;
5771
5772    return overlay->visible;
5773 #else
5774    (void)overlay;
5775    return EINA_FALSE;
5776 #endif
5777 }
5778
5779 EAPI void
5780 elm_map_overlay_show(Elm_Map_Overlay *overlay)
5781 {
5782 #ifdef HAVE_ELEMENTARY_ECORE_CON
5783    EINA_SAFETY_ON_NULL_RETURN(overlay);
5784    EINA_SAFETY_ON_NULL_RETURN(overlay->wsd);
5785    ELM_MAP_CHECK(ELM_WIDGET_DATA(overlay->wsd)->obj);
5786
5787    if (overlay->type == ELM_MAP_OVERLAY_TYPE_DEFAULT)
5788      {
5789         Overlay_Default *ovl = overlay->ovl;
5790
5791         elm_map_region_show
5792           (ELM_WIDGET_DATA(overlay->wsd)->obj, ovl->lon, ovl->lat);
5793      }
5794    else if (overlay->type == ELM_MAP_OVERLAY_TYPE_BUBBLE)
5795      {
5796         Overlay_Bubble *ovl = overlay->ovl;
5797
5798         elm_map_region_show
5799           (ELM_WIDGET_DATA(overlay->wsd)->obj, ovl->lon, ovl->lat);
5800      }
5801    else if (overlay->type == ELM_MAP_OVERLAY_TYPE_CLASS)
5802      {
5803         Overlay_Class *ovl = overlay->ovl;
5804         double lon, lat, max_lo, min_lo, max_la, min_la;
5805
5806         _region_max_min_get(ovl->members, &max_lo, &min_lo, &max_la, &min_la);
5807         lon = (max_lo + min_lo) / 2;
5808         lat = (max_la + min_la) / 2;
5809         elm_map_region_show(ELM_WIDGET_DATA(overlay->wsd)->obj, lon, lat);
5810      }
5811    else ERR("Not supported overlay type: %d", overlay->type);
5812
5813    evas_object_smart_changed(overlay->wsd->pan_obj);
5814 #else
5815    (void)overlay;
5816 #endif
5817 }
5818
5819 EAPI void
5820 elm_map_overlays_show(Eina_List *overlays)
5821 {
5822 #ifdef HAVE_ELEMENTARY_ECORE_CON
5823    Elm_Map_Smart_Data *sd;
5824    Elm_Map_Overlay *overlay;
5825
5826    EINA_SAFETY_ON_NULL_RETURN(overlays);
5827    EINA_SAFETY_ON_FALSE_RETURN(eina_list_count(overlays));
5828
5829    overlay = eina_list_data_get(overlays);
5830    sd = overlay->wsd;
5831
5832    if (!strcmp(sd->engine->name, INTERNAL_ENGINE_NAME))
5833      {
5834         sd->calc_job.overlays_changed = EINA_TRUE;
5835         sd->calc_job.overlays = overlays;
5836         evas_object_smart_changed(sd->pan_obj);
5837      }
5838    else ERR("Engine(%s) do not support overlays show", sd->engine->name);
5839
5840 #else
5841    (void)overlays;
5842 #endif
5843 }
5844
5845 EAPI void
5846 elm_map_overlay_region_set(Elm_Map_Overlay *overlay,
5847                            double lon,
5848                            double lat)
5849 {
5850 #ifdef HAVE_ELEMENTARY_ECORE_CON
5851    EINA_SAFETY_ON_NULL_RETURN(overlay);
5852    EINA_SAFETY_ON_NULL_RETURN(overlay->wsd);
5853    ELM_MAP_CHECK(ELM_WIDGET_DATA(overlay->wsd)->obj);
5854
5855    if (overlay->type == ELM_MAP_OVERLAY_TYPE_DEFAULT)
5856      {
5857         Overlay_Default *ovl = overlay->ovl;
5858
5859         ovl->lon = lon;
5860         ovl->lat = lat;
5861      }
5862    else if (overlay->type == ELM_MAP_OVERLAY_TYPE_BUBBLE)
5863      {
5864         Overlay_Bubble *ovl = overlay->ovl;
5865
5866         ovl->pobj = NULL;
5867         ovl->lon = lon;
5868         ovl->lat = lat;
5869      }
5870    else ERR("Not supported overlay type: %d", overlay->type);
5871
5872    if (!strcmp(overlay->wsd->engine->name, INTERNAL_ENGINE_NAME))
5873      evas_object_smart_changed(overlay->wsd->pan_obj);
5874    else _overlay_place(overlay->wsd);
5875 #else
5876    (void)overlay;
5877    (void)lon;
5878    (void)lat;
5879 #endif
5880 }
5881
5882 EAPI void
5883 elm_map_overlay_region_get(const Elm_Map_Overlay *overlay,
5884                            double *lon,
5885                            double *lat)
5886 {
5887 #ifdef HAVE_ELEMENTARY_ECORE_CON
5888    EINA_SAFETY_ON_NULL_RETURN(overlay);
5889    EINA_SAFETY_ON_NULL_RETURN(overlay->wsd);
5890    ELM_MAP_CHECK(ELM_WIDGET_DATA(overlay->wsd)->obj);
5891
5892    if (overlay->type == ELM_MAP_OVERLAY_TYPE_GROUP)
5893      {
5894         Overlay_Group *ovl = overlay->ovl;
5895
5896         if (lon) *lon = ovl->lon;
5897         if (lat) *lat = ovl->lat;
5898      }
5899    else if (overlay->type == ELM_MAP_OVERLAY_TYPE_DEFAULT)
5900      {
5901         const Overlay_Default *ovl = overlay->ovl;
5902
5903         if (lon) *lon = ovl->lon;
5904         if (lat) *lat = ovl->lat;
5905      }
5906    else if (overlay->type == ELM_MAP_OVERLAY_TYPE_BUBBLE)
5907      {
5908         const Overlay_Bubble *ovl = overlay->ovl;
5909
5910         if (lon) *lon = ovl->lon;
5911         if (lat) *lat = ovl->lat;
5912      }
5913    else ERR("Not supported overlay type: %d", overlay->type);
5914 #else
5915    (void)overlay;
5916    (void)lon;
5917    (void)lat;
5918 #endif
5919 }
5920
5921 EAPI void
5922 elm_map_overlay_icon_set(Elm_Map_Overlay *overlay,
5923                          Evas_Object *icon)
5924 {
5925 #ifdef HAVE_ELEMENTARY_ECORE_CON
5926    EINA_SAFETY_ON_NULL_RETURN(overlay);
5927    EINA_SAFETY_ON_NULL_RETURN(icon);
5928    EINA_SAFETY_ON_NULL_RETURN(overlay->wsd);
5929    ELM_MAP_CHECK(ELM_WIDGET_DATA(overlay->wsd)->obj);
5930
5931    if (overlay->type == ELM_MAP_OVERLAY_TYPE_DEFAULT)
5932      _overlay_default_icon_update(overlay->ovl, icon);
5933    else if (overlay->type == ELM_MAP_OVERLAY_TYPE_CLASS)
5934      _overlay_class_icon_update(overlay->ovl, icon);
5935    else ERR("Not supported overlay type: %d", overlay->type);
5936
5937    evas_object_smart_changed(overlay->wsd->pan_obj);
5938 #else
5939    (void)overlay;
5940    (void)icon;
5941 #endif
5942 }
5943
5944 EAPI const Evas_Object *
5945 elm_map_overlay_icon_get(const Elm_Map_Overlay *overlay)
5946 {
5947 #ifdef HAVE_ELEMENTARY_ECORE_CON
5948    EINA_SAFETY_ON_NULL_RETURN_VAL(overlay, NULL);
5949    EINA_SAFETY_ON_NULL_RETURN_VAL(overlay->wsd, NULL);
5950    ELM_MAP_CHECK(ELM_WIDGET_DATA(overlay->wsd)->obj) NULL;
5951
5952    if (overlay->type == ELM_MAP_OVERLAY_TYPE_DEFAULT)
5953      {
5954         const Overlay_Default *ovl = overlay->ovl;
5955
5956         return ovl->icon;
5957      }
5958    else if (overlay->type == ELM_MAP_OVERLAY_TYPE_CLASS)
5959      {
5960         const Overlay_Class *ovl = overlay->ovl;
5961
5962         return ovl->icon;
5963      }
5964    else
5965      {
5966         ERR("Not supported overlay type: %d", overlay->type);
5967         return NULL;
5968      }
5969 #else
5970    (void)overlay;
5971    return NULL;
5972 #endif
5973 }
5974
5975 EAPI void
5976 elm_map_overlay_content_set(Elm_Map_Overlay *overlay,
5977                             Evas_Object *content)
5978 {
5979 #ifdef HAVE_ELEMENTARY_ECORE_CON
5980    EINA_SAFETY_ON_NULL_RETURN(overlay);
5981    EINA_SAFETY_ON_NULL_RETURN(content);
5982    EINA_SAFETY_ON_NULL_RETURN(overlay->wsd);
5983    ELM_MAP_CHECK(ELM_WIDGET_DATA(overlay->wsd)->obj);
5984
5985    if (overlay->type == ELM_MAP_OVERLAY_TYPE_DEFAULT)
5986      _overlay_default_content_update(overlay->ovl, content, overlay);
5987    else if (overlay->type == ELM_MAP_OVERLAY_TYPE_CLASS)
5988      _overlay_class_content_update(overlay->ovl, content);
5989    else ERR("Not supported overlay type: %d", overlay->type);
5990
5991    evas_object_smart_changed(overlay->wsd->pan_obj);
5992 #else
5993    (void)overlay;
5994    (void)content;
5995 #endif
5996 }
5997
5998 EAPI const Evas_Object *
5999 elm_map_overlay_content_get(const Elm_Map_Overlay *overlay)
6000 {
6001 #ifdef HAVE_ELEMENTARY_ECORE_CON
6002    EINA_SAFETY_ON_NULL_RETURN_VAL(overlay, NULL);
6003    EINA_SAFETY_ON_NULL_RETURN_VAL(overlay->wsd, NULL);
6004
6005    ELM_MAP_CHECK(ELM_WIDGET_DATA(overlay->wsd)->obj) NULL;
6006
6007    if (overlay->type == ELM_MAP_OVERLAY_TYPE_DEFAULT)
6008      {
6009         const Overlay_Default *ovl = overlay->ovl;
6010         return ovl->content;
6011      }
6012    else if (overlay->type == ELM_MAP_OVERLAY_TYPE_CLASS)
6013      {
6014         const Overlay_Class *ovl = overlay->ovl;
6015         return ovl->content;
6016      }
6017    else
6018      {
6019         ERR("Not supported overlay type: %d", overlay->type);
6020         return NULL;
6021      }
6022 #else
6023    (void)overlay;
6024    return NULL;
6025 #endif
6026 }
6027
6028 EAPI void
6029 elm_map_overlay_color_set(Elm_Map_Overlay *overlay,
6030                           int r,
6031                           int g,
6032                           int b,
6033                           int a)
6034 {
6035 #ifdef HAVE_ELEMENTARY_ECORE_CON
6036    EINA_SAFETY_ON_NULL_RETURN(overlay);
6037    EINA_SAFETY_ON_NULL_RETURN(overlay->wsd);
6038    ELM_MAP_CHECK(ELM_WIDGET_DATA(overlay->wsd)->obj);
6039
6040    overlay->c.r = r;
6041    overlay->c.g = g;
6042    overlay->c.b = b;
6043    overlay->c.a = a;
6044
6045    if (overlay->type == ELM_MAP_OVERLAY_TYPE_CLASS)
6046      _overlay_class_color_update(overlay->ovl, overlay->c);
6047    else if (overlay->type == ELM_MAP_OVERLAY_TYPE_DEFAULT)
6048      _overlay_default_color_update(overlay->ovl, overlay->c);
6049    else if (overlay->type == ELM_MAP_OVERLAY_TYPE_ROUTE)
6050      _overlay_route_color_update(overlay->ovl, overlay->c);
6051    else
6052      {
6053         ERR("Not supported overlay type: %d", overlay->type);
6054      }
6055
6056 #else
6057    (void)overlay;
6058    (void)r;
6059    (void)g;
6060    (void)b;
6061    (void)a;
6062 #endif
6063 }
6064
6065 EAPI void
6066 elm_map_overlay_color_get(const Elm_Map_Overlay *overlay,
6067                           int *r,
6068                           int *g,
6069                           int *b,
6070                           int *a)
6071 {
6072 #ifdef HAVE_ELEMENTARY_ECORE_CON
6073    EINA_SAFETY_ON_NULL_RETURN(overlay);
6074    EINA_SAFETY_ON_NULL_RETURN(overlay->wsd);
6075    ELM_MAP_CHECK(ELM_WIDGET_DATA(overlay->wsd)->obj);
6076
6077    if (overlay->type == ELM_MAP_OVERLAY_TYPE_ROUTE)
6078      {
6079         if (r) *r = overlay->c.r;
6080         if (g) *g = overlay->c.g;
6081         if (b) *b = overlay->c.b;
6082         if (a) *a = overlay->c.a;
6083      }
6084    else ERR("Not supported overlay type: %d", overlay->type);
6085 #else
6086    (void)overlay;
6087    (void)r;
6088    (void)g;
6089    (void)b;
6090    (void)a;
6091 #endif
6092 }
6093
6094 EAPI void
6095 elm_map_overlay_get_cb_set(Elm_Map_Overlay *overlay,
6096                            Elm_Map_Overlay_Get_Cb get_cb,
6097                            void *data)
6098 {
6099 #ifdef HAVE_ELEMENTARY_ECORE_CON
6100    EINA_SAFETY_ON_NULL_RETURN(overlay);
6101    EINA_SAFETY_ON_NULL_RETURN(overlay->wsd);
6102    ELM_MAP_CHECK(ELM_WIDGET_DATA(overlay->wsd)->obj);
6103
6104    overlay->cb = get_cb;
6105    overlay->cb_data = data;
6106
6107    if (overlay->type == ELM_MAP_OVERLAY_TYPE_CLASS)
6108      _overlay_class_cb_set(overlay->ovl, get_cb, data);
6109 #else
6110    (void)overlay;
6111    (void)get_cb;
6112    (void)data;
6113 #endif
6114 }
6115
6116 EAPI void
6117 elm_map_overlay_del_cb_set(Elm_Map_Overlay *overlay,
6118                            Elm_Map_Overlay_Del_Cb del_cb,
6119                            void *data)
6120 {
6121 #ifdef HAVE_ELEMENTARY_ECORE_CON
6122    EINA_SAFETY_ON_NULL_RETURN(overlay);
6123    EINA_SAFETY_ON_NULL_RETURN(overlay->wsd);
6124    ELM_MAP_CHECK(ELM_WIDGET_DATA(overlay->wsd)->obj);
6125
6126    overlay->del_cb = del_cb;
6127    overlay->del_cb_data = data;
6128 #else
6129    (void)overlay;
6130    (void)del_cb;
6131    (void)data;
6132 #endif
6133 }
6134
6135 EAPI Elm_Map_Overlay *
6136 elm_map_overlay_class_add(Evas_Object *obj)
6137 {
6138 #ifdef HAVE_ELEMENTARY_ECORE_CON
6139    Elm_Map_Overlay *overlay;
6140
6141    ELM_MAP_CHECK(obj) NULL;
6142    ELM_MAP_DATA_GET(obj, sd);
6143
6144    overlay = ELM_NEW(Elm_Map_Overlay);
6145    overlay->wsd = sd;
6146    overlay->type = ELM_MAP_OVERLAY_TYPE_CLASS;
6147    overlay->ovl = _overlay_class_new(sd);
6148    overlay->c.r = 0x90;
6149    overlay->c.g = 0xee;
6150    overlay->c.b = 0x90;
6151    overlay->c.a = 0xff;
6152    sd->overlays = eina_list_append(sd->overlays, overlay);
6153
6154    evas_object_smart_changed(sd->pan_obj);
6155    return overlay;
6156 #else
6157    (void)obj;
6158    return NULL;
6159 #endif
6160 }
6161
6162 EAPI void
6163 elm_map_overlay_class_append(Elm_Map_Overlay *klass,
6164                              Elm_Map_Overlay *overlay)
6165 {
6166 #ifdef HAVE_ELEMENTARY_ECORE_CON
6167    Overlay_Class *class_ovl;
6168
6169    EINA_SAFETY_ON_NULL_RETURN(klass);
6170    EINA_SAFETY_ON_NULL_RETURN(overlay);
6171    EINA_SAFETY_ON_NULL_RETURN(klass->wsd);
6172    ELM_MAP_CHECK(ELM_WIDGET_DATA(klass->wsd)->obj);
6173    EINA_SAFETY_ON_FALSE_RETURN(klass->type == ELM_MAP_OVERLAY_TYPE_CLASS);
6174
6175    class_ovl = klass->ovl;
6176    if (eina_list_data_find(class_ovl->members, overlay))
6177      {
6178         ERR("Already added overlay into clas");
6179         return;
6180      }
6181    class_ovl->members = eina_list_append(class_ovl->members, overlay);
6182
6183    // Update group by class
6184    overlay->grp->klass = klass;
6185    _overlay_group_icon_update(overlay->grp, class_ovl->icon);
6186    _overlay_group_content_update(overlay->grp, class_ovl->content, overlay);
6187    _overlay_group_color_update(overlay->grp, klass->c);
6188    _overlay_group_cb_set(overlay->grp, klass->cb, klass->data);
6189    if (overlay->type == ELM_MAP_OVERLAY_TYPE_DEFAULT)
6190      {
6191         _overlay_default_class_icon_update(overlay->ovl, class_ovl->icon);
6192         _overlay_default_class_content_update
6193           (overlay->ovl, class_ovl->content);
6194      }
6195
6196    evas_object_smart_changed(klass->wsd->pan_obj);
6197 #else
6198    (void)klass;
6199    (void)overlay;
6200 #endif
6201 }
6202
6203 EAPI void
6204 elm_map_overlay_class_remove(Elm_Map_Overlay *klass,
6205                              Elm_Map_Overlay *overlay)
6206 {
6207 #ifdef HAVE_ELEMENTARY_ECORE_CON
6208    Overlay_Class *ovl;
6209
6210    EINA_SAFETY_ON_NULL_RETURN(klass);
6211    EINA_SAFETY_ON_NULL_RETURN(overlay);
6212    EINA_SAFETY_ON_NULL_RETURN(klass->wsd);
6213    ELM_MAP_CHECK(ELM_WIDGET_DATA(klass->wsd)->obj);
6214    EINA_SAFETY_ON_FALSE_RETURN(klass->type == ELM_MAP_OVERLAY_TYPE_CLASS);
6215
6216    ovl = klass->ovl;
6217    ovl->members = eina_list_remove(ovl->members, overlay);
6218
6219    overlay->grp->klass = NULL;
6220    _overlay_group_icon_update(overlay->grp, NULL);
6221    _overlay_group_content_update(overlay->grp, NULL, NULL);
6222    if (overlay->type == ELM_MAP_OVERLAY_TYPE_DEFAULT)
6223      {
6224         _overlay_default_class_icon_update(overlay->ovl, NULL);
6225         _overlay_default_class_content_update(overlay->ovl, NULL);
6226      }
6227
6228    evas_object_smart_changed(klass->wsd->pan_obj);
6229 #else
6230    (void)klass;
6231    (void)overlay;
6232 #endif
6233 }
6234
6235 EAPI void
6236 elm_map_overlay_class_zoom_max_set(Elm_Map_Overlay *klass,
6237                                    int zoom)
6238 {
6239 #ifdef HAVE_ELEMENTARY_ECORE_CON
6240    Overlay_Class *ovl;
6241
6242    EINA_SAFETY_ON_NULL_RETURN(klass);
6243    EINA_SAFETY_ON_NULL_RETURN(klass->wsd);
6244    ELM_MAP_CHECK(ELM_WIDGET_DATA(klass->wsd)->obj);
6245    EINA_SAFETY_ON_FALSE_RETURN(klass->type == ELM_MAP_OVERLAY_TYPE_CLASS);
6246
6247    ovl = klass->ovl;
6248    if (ovl->zoom_max == !!zoom) return;
6249    ovl->zoom_max = zoom;
6250
6251    evas_object_smart_changed(klass->wsd->pan_obj);
6252 #else
6253    (void)klass;
6254    (void)zoom;
6255 #endif
6256 }
6257
6258 EAPI int
6259 elm_map_overlay_class_zoom_max_get(const Elm_Map_Overlay *klass)
6260 {
6261 #ifdef HAVE_ELEMENTARY_ECORE_CON
6262    const Overlay_Class *ovl;
6263
6264    EINA_SAFETY_ON_NULL_RETURN_VAL(klass, OVERLAY_CLASS_ZOOM_MAX);
6265    EINA_SAFETY_ON_NULL_RETURN_VAL(klass->wsd, OVERLAY_CLASS_ZOOM_MAX);
6266    ELM_MAP_CHECK(ELM_WIDGET_DATA(klass->wsd)->obj) OVERLAY_CLASS_ZOOM_MAX;
6267
6268    EINA_SAFETY_ON_FALSE_RETURN_VAL
6269      (klass->type == ELM_MAP_OVERLAY_TYPE_CLASS, OVERLAY_CLASS_ZOOM_MAX);
6270
6271    ovl = klass->ovl;
6272    return ovl->zoom_max;
6273 #else
6274    (void)klass;
6275    return OVERLAY_CLASS_ZOOM_MAX;
6276 #endif
6277 }
6278
6279 EAPI Eina_List *
6280 elm_map_overlay_group_members_get(const Elm_Map_Overlay *grp)
6281 {
6282 #ifdef HAVE_ELEMENTARY_ECORE_CON
6283    Overlay_Group *ovl;
6284
6285    EINA_SAFETY_ON_NULL_RETURN_VAL(grp, NULL);
6286    EINA_SAFETY_ON_NULL_RETURN_VAL(grp->wsd, NULL);
6287    ELM_MAP_CHECK(ELM_WIDGET_DATA(grp->wsd)->obj) NULL;
6288
6289    EINA_SAFETY_ON_FALSE_RETURN_VAL
6290      (grp->type == ELM_MAP_OVERLAY_TYPE_GROUP, NULL);
6291
6292    ovl = grp->ovl;
6293    return ovl->members;
6294 #else
6295    (void)grp;
6296    return NULL;
6297 #endif
6298 }
6299
6300 EAPI Elm_Map_Overlay *
6301 elm_map_overlay_bubble_add(Evas_Object *obj)
6302 {
6303 #ifdef HAVE_ELEMENTARY_ECORE_CON
6304    Elm_Map_Overlay *overlay;
6305
6306    ELM_MAP_CHECK(obj) NULL;
6307    ELM_MAP_DATA_GET(obj, sd);
6308
6309    overlay = ELM_NEW(Elm_Map_Overlay);
6310    overlay->wsd = sd;
6311    overlay->type = ELM_MAP_OVERLAY_TYPE_BUBBLE;
6312    overlay->c.r = 255;
6313    overlay->c.g = 255;
6314    overlay->c.b = 255;
6315    overlay->c.a = 255;
6316    overlay->ovl = _overlay_bubble_new(overlay);
6317    overlay->grp = _overlay_group_new(sd);
6318    sd->overlays = eina_list_append(sd->overlays, overlay);
6319
6320    evas_object_smart_changed(sd->pan_obj);
6321    return overlay;
6322 #else
6323    (void)obj;
6324    return NULL;
6325 #endif
6326 }
6327
6328 EAPI void
6329 elm_map_overlay_bubble_follow(Elm_Map_Overlay *bubble,
6330                               const Elm_Map_Overlay *parent)
6331 {
6332 #ifdef HAVE_ELEMENTARY_ECORE_CON
6333    Overlay_Bubble *ovl;
6334    Evas_Object *pobj;
6335
6336    EINA_SAFETY_ON_NULL_RETURN(bubble);
6337    EINA_SAFETY_ON_NULL_RETURN(parent);
6338    ELM_MAP_CHECK(ELM_WIDGET_DATA(bubble->wsd)->obj);
6339    EINA_SAFETY_ON_FALSE_RETURN(bubble->type == ELM_MAP_OVERLAY_TYPE_BUBBLE);
6340
6341    ovl = bubble->ovl;
6342    pobj = _overlay_obj_get(parent);
6343    if (!pobj) return;
6344
6345    ovl->pobj = pobj;
6346    evas_object_smart_changed(bubble->wsd->pan_obj);
6347 #else
6348    (void)bubble;
6349    (void)parent;
6350 #endif
6351 }
6352
6353 EAPI void
6354 elm_map_overlay_bubble_content_append(Elm_Map_Overlay *bubble,
6355                                       Evas_Object *content)
6356 {
6357 #ifdef HAVE_ELEMENTARY_ECORE_CON
6358    Overlay_Bubble *bb;
6359
6360    EINA_SAFETY_ON_NULL_RETURN(bubble);
6361    EINA_SAFETY_ON_NULL_RETURN(content);
6362    ELM_MAP_CHECK(ELM_WIDGET_DATA(bubble->wsd)->obj);
6363    EINA_SAFETY_ON_FALSE_RETURN(bubble->type == ELM_MAP_OVERLAY_TYPE_BUBBLE);
6364
6365    bb = bubble->ovl;
6366    elm_box_pack_end(bb->bx, content);
6367
6368    evas_object_smart_changed(bubble->wsd->pan_obj);
6369 #else
6370    (void)bubble;
6371    (void)content;
6372 #endif
6373 }
6374
6375 EAPI void
6376 elm_map_overlay_bubble_content_clear(Elm_Map_Overlay *bubble)
6377 {
6378 #ifdef HAVE_ELEMENTARY_ECORE_CON
6379    Overlay_Bubble *bb;
6380
6381    EINA_SAFETY_ON_NULL_RETURN(bubble);
6382    ELM_MAP_CHECK(ELM_WIDGET_DATA(bubble->wsd)->obj);
6383    EINA_SAFETY_ON_FALSE_RETURN(bubble->type == ELM_MAP_OVERLAY_TYPE_BUBBLE);
6384
6385    bb = bubble->ovl;
6386    elm_box_clear(bb->bx);
6387
6388    evas_object_smart_changed(bubble->wsd->pan_obj);
6389 #else
6390    (void)bubble;
6391 #endif
6392 }
6393
6394 EAPI Elm_Map_Overlay *
6395 elm_map_overlay_route_add(Evas_Object *obj,
6396                           const Elm_Map_Route *route)
6397 {
6398 #ifdef HAVE_ELEMENTARY_ECORE_CON
6399    Elm_Map_Overlay *overlay;
6400
6401    ELM_MAP_CHECK(obj) NULL;
6402    ELM_MAP_DATA_GET(obj, sd);
6403
6404    EINA_SAFETY_ON_NULL_RETURN_VAL(route, NULL);
6405    EINA_SAFETY_ON_NULL_RETURN_VAL(route->wsd, NULL);
6406    EINA_SAFETY_ON_FALSE_RETURN_VAL
6407      (obj == ELM_WIDGET_DATA(route->wsd)->obj, NULL);
6408
6409    overlay = ELM_NEW(Elm_Map_Overlay);
6410    overlay->wsd = sd;
6411    overlay->type = ELM_MAP_OVERLAY_TYPE_ROUTE;
6412    overlay->c.r = 0xff;
6413    overlay->c.g = 0x00;
6414    overlay->c.b = 0x00;
6415    overlay->c.a = 0xff;
6416    overlay->ovl = _overlay_route_new(sd, route, overlay->c);
6417    overlay->grp = _overlay_group_new(sd);
6418    sd->overlays = eina_list_append(sd->overlays, overlay);
6419
6420    evas_object_smart_changed(sd->pan_obj);
6421    return overlay;
6422 #else
6423    (void)obj;
6424    (void)route;
6425    return NULL;
6426 #endif
6427 }
6428
6429 EAPI Elm_Map_Overlay *
6430 elm_map_overlay_line_add(Evas_Object *obj,
6431                          double flon,
6432                          double flat,
6433                          double tlon,
6434                          double tlat)
6435 {
6436 #ifdef HAVE_ELEMENTARY_ECORE_CON
6437    Elm_Map_Overlay *overlay;
6438
6439    ELM_MAP_CHECK(obj) NULL;
6440    ELM_MAP_DATA_GET(obj, sd);
6441
6442    overlay = ELM_NEW(Elm_Map_Overlay);
6443    overlay->wsd = sd;
6444    overlay->type = ELM_MAP_OVERLAY_TYPE_LINE;
6445    overlay->c.r = 0xff;
6446    overlay->c.g = 0x00;
6447    overlay->c.b = 0x00;
6448    overlay->c.a = 0xff;
6449    overlay->ovl = _overlay_line_new(sd, flon, flat, tlon, tlat, overlay->c);
6450    overlay->grp = _overlay_group_new(sd);
6451    sd->overlays = eina_list_append(sd->overlays, overlay);
6452
6453    evas_object_smart_changed(sd->pan_obj);
6454    return overlay;
6455 #else
6456    (void)obj;
6457    (void)flon;
6458    (void)flat;
6459    (void)tlon;
6460    (void)tlat;
6461    return NULL;
6462 #endif
6463 }
6464
6465 EAPI Elm_Map_Overlay *
6466 elm_map_overlay_polygon_add(Evas_Object *obj)
6467 {
6468 #ifdef HAVE_ELEMENTARY_ECORE_CON
6469    Elm_Map_Overlay *overlay;
6470
6471    ELM_MAP_CHECK(obj) NULL;
6472    ELM_MAP_DATA_GET(obj, sd);
6473
6474    overlay = ELM_NEW(Elm_Map_Overlay);
6475    overlay->wsd = sd;
6476    overlay->type = ELM_MAP_OVERLAY_TYPE_POLYGON;
6477    overlay->c.r = 0xdc;
6478    overlay->c.g = 0x14;
6479    overlay->c.b = 0x3c;
6480    overlay->c.a = 220;
6481    overlay->ovl = _overlay_polygon_new(sd, overlay->c);
6482    overlay->grp = _overlay_group_new(sd);
6483    sd->overlays = eina_list_append(sd->overlays, overlay);
6484    evas_object_smart_changed(sd->pan_obj);
6485    return overlay;
6486 #else
6487    (void)obj;
6488    return NULL;
6489 #endif
6490 }
6491
6492 EAPI void
6493 elm_map_overlay_polygon_region_add(Elm_Map_Overlay *overlay,
6494                                    double lon,
6495                                    double lat)
6496 {
6497 #ifdef HAVE_ELEMENTARY_ECORE_CON
6498    Overlay_Polygon *ovl;
6499    Region *r;
6500
6501    EINA_SAFETY_ON_NULL_RETURN(overlay);
6502    ELM_MAP_CHECK(ELM_WIDGET_DATA(overlay->wsd)->obj);
6503    EINA_SAFETY_ON_FALSE_RETURN(overlay->type == ELM_MAP_OVERLAY_TYPE_POLYGON);
6504
6505    ovl = overlay->ovl;
6506    r = ELM_NEW(Region);
6507    r->lon = lon;
6508    r->lat = lat;
6509    ovl->regions = eina_list_append(ovl->regions, r);
6510
6511    evas_object_smart_changed(ovl->wsd->pan_obj);
6512 #else
6513    (void)overlay;
6514    (void)lon;
6515    (void)lat;
6516 #endif
6517 }
6518
6519 EAPI Elm_Map_Overlay *
6520 elm_map_overlay_circle_add(Evas_Object *obj,
6521                            double lon,
6522                            double lat,
6523                            double radius)
6524 {
6525 #ifdef HAVE_ELEMENTARY_ECORE_CON
6526    Elm_Map_Overlay *overlay;
6527
6528    ELM_MAP_CHECK(obj) NULL;
6529    ELM_MAP_DATA_GET(obj, sd);
6530
6531    overlay = ELM_NEW(Elm_Map_Overlay);
6532    overlay->wsd = sd;
6533    overlay->type = ELM_MAP_OVERLAY_TYPE_CIRCLE;
6534    overlay->c.r = 0xdc;
6535    overlay->c.g = 0x14;
6536    overlay->c.b = 0x3c;
6537    overlay->c.a = 220;
6538    overlay->ovl = _overlay_circle_new(sd, lon, lat, radius, overlay->c);
6539    overlay->grp = _overlay_group_new(sd);
6540    sd->overlays = eina_list_append(sd->overlays, overlay);
6541
6542    evas_object_smart_changed(sd->pan_obj);
6543    return overlay;
6544 #else
6545    (void)obj;
6546    (void)lon;
6547    (void)lat;
6548    (void)radius;
6549    return NULL;
6550 #endif
6551 }
6552
6553 EAPI Elm_Map_Overlay *
6554 elm_map_overlay_scale_add(Evas_Object *obj,
6555                           Evas_Coord x,
6556                           Evas_Coord y)
6557 {
6558 #ifdef HAVE_ELEMENTARY_ECORE_CON
6559    Elm_Map_Overlay *overlay;
6560
6561    ELM_MAP_CHECK(obj) NULL;
6562    ELM_MAP_DATA_GET(obj, sd);
6563
6564    overlay = ELM_NEW(Elm_Map_Overlay);
6565    overlay->wsd = sd;
6566    overlay->type = ELM_MAP_OVERLAY_TYPE_SCALE;
6567    overlay->c.r = 0;
6568    overlay->c.g = 0;
6569    overlay->c.b = 0;
6570    overlay->c.a = 255;
6571    overlay->ovl = _overlay_scale_new(sd, x, y, overlay->c);
6572    overlay->grp = _overlay_group_new(sd);
6573    sd->overlays = eina_list_append(sd->overlays, overlay);
6574
6575    evas_object_smart_changed(sd->pan_obj);
6576    return overlay;
6577 #else
6578    (void)obj;
6579    (void)x;
6580    (void)y;
6581    return NULL;
6582 #endif
6583 }
6584
6585 #ifdef ELM_EMAP
6586 EAPI Evas_Object *
6587 elm_map_track_add(Evas_Object *obj,
6588                   void *emap)
6589 {
6590 #ifdef HAVE_ELEMENTARY_ECORE_CON
6591    EMap_Route *emapr = emap;
6592    Evas_Object *route;
6593
6594    ELM_MAP_CHECK(obj) NULL;
6595    ELM_MAP_DATA_GET(obj, sd);
6596
6597    route = elm_route_add(obj);
6598    elm_route_emap_set(route, emapr);
6599    sd->track = eina_list_append(sd->track, route);
6600
6601    return route;
6602 #else
6603    (void)obj;
6604    (void)emap;
6605    return NULL;
6606 #endif
6607 }
6608
6609 EAPI void
6610 elm_map_track_remove(Evas_Object *obj,
6611                      Evas_Object *route)
6612 {
6613 #ifdef HAVE_ELEMENTARY_ECORE_CON
6614    ELM_MAP_CHECK(obj);
6615    ELM_MAP_DATA_GET(obj, sd);
6616
6617    sd->track = eina_list_remove(sd->track, route);
6618    evas_object_del(route);
6619 #else
6620    (void)obj;
6621    (void)route;
6622 #endif
6623 }
6624
6625 #else
6626 EAPI Evas_Object *
6627 elm_map_track_add(Evas_Object *obj __UNUSED__,
6628                   void *emap __UNUSED__)
6629 {
6630    return NULL;
6631 }
6632
6633 EAPI void
6634 elm_map_track_remove(Evas_Object *obj __UNUSED__,
6635                      Evas_Object *route __UNUSED__)
6636 {
6637 }
6638 #endif