src/lib/elm_map.c

   1 #ifdef HAVE_CONFIG_H
   2 # include "elementary_config.h"
   3 #endif
   4
   5 #include "Elementary.h"
   6 #include "elm_priv.h"
   7 #include "els_scroller.h"
   8
   9 #ifdef HAVE_ELEMENTARY_ECORE_CON
  10
  11 typedef struct _Widget_Data Widget_Data;
  12 typedef struct _Pan Pan;
  13 typedef struct _Grid Grid;
  14 typedef struct _Grid_Item Grid_Item;
  15 typedef struct _Marker_Group Marker_Group;
  16 typedef struct _Marker_Bubble Marker_Bubble;
  17 typedef struct _Path_Node Path_Node;
  18 typedef struct _Path_Waypoint Path_Waypoint;
  19 typedef struct _Url_Data Url_Data;
  20 typedef struct _Route_Dump Route_Dump;
  21 typedef struct _Name_Dump Name_Dump;
  22 typedef struct _Track_Dump Track_Dump;
  23 typedef struct _Delayed_Data Delayed_Data;
  24 typedef struct _Map_Sources_Tab Map_Sources_Tab;
  25
  26 #define ROUND(z) (((z) < 0) ? (int)ceil((z) - 0.005) : (int)floor((z) + 0.005))
  27 #define EVAS_MAP_POINT 4
  28 #define DEFAULT_TILE_SIZE 256
  29 #define MARER_MAX_NUMBER 30
  30 #define CACHE_ROOT_PATH   "/tmp/elm_map"
  31 #define CACHE_PATH        CACHE_ROOT_PATH"/%d/%d/%d"
  32 #define CACHE_FILE_PATH   "%s/%d.png"
  33 #define DEST_ROUTE_XML_FILE "/tmp/elm_map-route-XXXXXX"
  34 #define DEST_NAME_XML_FILE "/tmp/elm_map-name-XXXXXX"
  35
  36 #define ROUTE_YOURS_URL "http://www.yournavigation.org/api/dev/route.php"
  37 #define ROUTE_TYPE_MOTORCAR "motocar"
  38 #define ROUTE_TYPE_BICYCLE "bicycle"
  39 #define ROUTE_TYPE_FOOT "foot"
  40 #define YOURS_DISTANCE "distance"
  41 #define YOURS_DESCRIPTION "description"
  42 #define YOURS_COORDINATES "coordinates"
  43
  44 #define NAME_NOMINATIM_URL "http://nominatim.openstreetmap.org"
  45 #define NOMINATIM_RESULT "result"
  46 #define NOMINATIM_PLACE "place"
  47 #define NOMINATIM_ATTR_LON "lon"
  48 #define NOMINATIM_ATTR_LAT "lat"
  49
  50 #define MAX_CONCURRENT_DOWNLOAD 10
  51
  52 /* FIXME: This is unused currently
  53 #define GPX_NAME "name>"
  54 #define GPX_COORDINATES "trkpt "
  55 #define GPX_LON "lon"
  56 #define GPX_LAT "lat"
  57 #define GPX_ELE "ele>"
  58 #define GPX_TIME "time>"
  59 */
  60
  61 enum _Route_Xml_Attribute
  62 {
  63    ROUTE_XML_NONE,
  64    ROUTE_XML_DISTANCE,
  65    ROUTE_XML_DESCRIPTION,
  66    ROUTE_XML_COORDINATES,
  67    ROUTE_XML_LAST
  68 } Route_Xml_Attibute;
  69
  70 enum _Name_Xml_Attribute
  71 {
  72    NAME_XML_NONE,
  73    NAME_XML_NAME,
  74    NAME_XML_LON,
  75    NAME_XML_LAT,
  76    NAME_XML_LAST
  77 } Name_Xml_Attibute;
  78
  79 enum _Track_Xml_Attribute
  80 {
  81    TRACK_XML_NONE,
  82    TRACK_XML_COORDINATES,
  83    TRACK_XML_LAST
  84 } Track_Xml_Attibute;
  85
  86 struct _Delayed_Data
  87 {
  88    void (*func)(void *data);
  89    Widget_Data *wd;
  90    Elm_Map_Zoom_Mode mode;
  91    int zoom;
  92    double lon, lat;
  93    Eina_List *markers;
  94 };
  95
  96 // Map sources
  97 // Currently the size of a tile must be 256*256
  98 // and the size of the map must be pow(2.0, z)*tile_size
  99 struct _Map_Sources_Tab
 100 {
 101    const char *name;
 102    int zoom_min;
 103    int zoom_max;
 104    ElmMapModuleUrlFunc url_cb;
 105    Elm_Map_Route_Sources route_source;
 106    ElmMapModuleRouteUrlFunc route_url_cb;
 107    ElmMapModuleNameUrlFunc name_url_cb;
 108    ElmMapModuleGeoIntoCoordFunc geo_into_coord;
 109    ElmMapModuleCoordIntoGeoFunc coord_into_geo;
 110 };
 111
 112 struct _Url_Data
 113 {
 114    Ecore_Con_Url *con_url;
 115
 116    FILE *fd;
 117    char *fname;
 118 };
 119
 120 struct _Elm_Map_Marker_Class
 121 {
 122    const char *style;
 123    struct _Elm_Map_Marker_Class_Func
 124      {
 125         ElmMapMarkerGetFunc get;
 126         ElmMapMarkerDelFunc del; //if NULL the object will be destroyed with evas_object_del()
 127         ElmMapMarkerIconGetFunc icon_get;
 128      } func;
 129 };
 130
 131 struct _Elm_Map_Group_Class
 132 {
 133    Widget_Data *wd;
 134
 135    Eina_List *markers;
 136    int zoom_displayed; // display the group if the zoom is >= to zoom_display
 137    int zoom_grouped;   // group the markers only if the zoom is <= to zoom_groups
 138    const char *style;
 139    void *data;
 140    struct
 141      {
 142         ElmMapGroupIconGetFunc icon_get;
 143      } func;
 144
 145    Eina_Bool hide : 1;
 146 };
 147
 148 struct _Marker_Bubble
 149 {
 150    Widget_Data *wd;
 151    Evas_Object *pobj;
 152    Evas_Object *obj, *sc, *bx;
 153 };
 154
 155 struct _Elm_Map_Marker
 156 {
 157    Widget_Data *wd;
 158    Elm_Map_Marker_Class *clas;
 159    Elm_Map_Group_Class *group_clas;
 160    double longitude, latitude;
 161    Evas_Coord w, h;
 162    Evas_Object *obj;
 163
 164    Evas_Coord x, y;
 165    Eina_Bool grouped : 1;
 166    Eina_Bool leader : 1; // if marker is group leader
 167    Marker_Group *group;
 168
 169    Marker_Bubble *bubble;
 170    Evas_Object *content;
 171    void *data;
 172 };
 173
 174 struct _Marker_Group
 175 {
 176    Widget_Data *wd;
 177    Elm_Map_Group_Class *clas;
 178    Evas_Coord w, h;
 179    Evas_Object *obj;
 180
 181    Evas_Coord x, y;
 182    Eina_List *markers;
 183
 184    Marker_Bubble *bubble;
 185 };
 186
 187 struct _Elm_Map_Route
 188 {
 189    Widget_Data *wd;
 190
 191    Path_Node *n;
 192    Path_Waypoint *w;
 193    Ecore_Con_Url *con_url;
 194
 195    int type;
 196    int method;
 197    int x, y;
 198    double flon, flat, tlon, tlat;
 199
 200    Eina_List *nodes, *path;
 201    Eina_List *waypoint;
 202
 203    struct
 204      {
 205         int node_count;
 206         int waypoint_count;
 207         const char *nodes;
 208         const char *waypoints;
 209         double distance; /* unit : km */
 210      } info;
 211
 212    Eina_List *handlers;
 213    Url_Data ud;
 214
 215    struct
 216      {
 217         int r;
 218         int g;
 219         int b;
 220         int a;
 221      } color;
 222
 223    Eina_Bool inbound : 1;
 224 };
 225
 226 struct _Path_Node
 227 {
 228    Widget_Data *wd;
 229
 230    int idx;
 231    struct
 232      {
 233         double lon, lat;
 234         char *address;
 235      } pos;
 236 };
 237
 238 struct _Path_Waypoint
 239 {
 240    Widget_Data *wd;
 241
 242    const char *point;
 243 };
 244
 245 struct _Elm_Map_Name
 246 {
 247    Widget_Data *wd;
 248
 249    Ecore_Con_Url *con_url;
 250    int method;
 251    char *address;
 252    double lon, lat;
 253    Url_Data ud;
 254    Ecore_Event_Handler *handler;
 255 };
 256
 257 struct _Route_Dump
 258 {
 259    int id;
 260    char *fname;
 261    double distance;
 262    char *description;
 263    char *coordinates;
 264 };
 265
 266 struct _Name_Dump
 267 {
 268    int id;
 269    char *address;
 270    double lon;
 271    double lat;
 272 };
 273
 274 struct _Grid_Item
 275 {
 276    Grid *g;
 277
 278    Widget_Data *wd;
 279    Evas_Object *img;
 280    const char *file;
 281    const char *source;
 282    int x, y;  // Tile coordinate
 283    Eina_Bool file_have : 1;
 284
 285    Ecore_File_Download_Job *job;
 286 };
 287
 288 struct _Grid
 289 {
 290    Widget_Data *wd;
 291    int zoom; // zoom level tiles want for optimal display (1, 2, 4, 8)
 292    int tw, th; // size of grid in tiles
 293    Eina_Matrixsparse *grid;
 294 };
 295
 296 struct _Pan
 297 {
 298    Evas_Object_Smart_Clipped_Data __clipped_data;
 299    Widget_Data *wd;
 300 };
 301
 302 struct _Widget_Data
 303 {
 304    Evas_Object *obj;
 305    Evas_Object *scr;
 306    Evas_Object *ges;
 307    Evas_Object *pan_smart;
 308    Evas_Object *sep_maps_markers; // Tiles are below this and overlays are on top
 309    Evas_Map *map;
 310
 311    Map_Sources_Tab *src;
 312    Eina_List *srcs;
 313    const char **src_names;
 314    int zoom_min, zoom_max;
 315    int tsize;
 316
 317    int id;
 318    Eina_List *grids;
 319
 320    int zoom;
 321    double zoom_detail;
 322    double prev_lon, prev_lat;
 323    Evas_Coord ox, oy;
 324    struct
 325      {
 326         int w, h;  // Current pixel width, heigth of a grid
 327         int tile;  // Current pixel size of a grid item
 328      } size;
 329    Elm_Map_Zoom_Mode mode;
 330    struct
 331      {
 332         double zoom;
 333         double diff;
 334         int cnt;
 335      } ani;
 336    Ecore_Timer *zoom_timer;
 337    Ecore_Animator *zoom_animator;
 338
 339    int try_num;
 340    int finish_num;
 341    int download_num;
 342    Eina_List *download_list;
 343    Ecore_Idler *download_idler;
 344    Eina_Hash *ua;
 345    const char *user_agent;
 346
 347    Evas_Coord pan_x, pan_y;
 348    Eina_List *delayed_jobs;
 349
 350    Ecore_Timer *scr_timer;
 351    Ecore_Timer *long_timer;
 352    Evas_Event_Mouse_Down ev;
 353    Eina_Bool on_hold : 1;
 354    Eina_Bool paused : 1;
 355
 356    double pinch_zoom;
 357    struct
 358      {
 359         Evas_Coord cx, cy;
 360         double a, d;
 361      } rotate;
 362
 363    Eina_Bool wheel_disabled : 1;
 364
 365    unsigned int markers_max_num;
 366    Eina_Bool paused_markers : 1;
 367    Eina_List *group_classes;
 368    Eina_List *marker_classes;
 369    Eina_List *markers;
 370
 371    Elm_Map_Route_Sources route_source;
 372    Eina_List *route;
 373    Eina_List *track;
 374    Eina_List *names;
 375 };
 376
 377 static char *_mapnik_url_cb(Evas_Object *obj __UNUSED__, int x, int y, int zoom);
 378 static char *_osmarender_url_cb(Evas_Object *obj __UNUSED__, int x, int y, int zoom);
 379 static char *_cyclemap_url_cb(Evas_Object *obj __UNUSED__, int x, int y, int zoom);
 380 static char *_mapquest_url_cb(Evas_Object *obj __UNUSED__, int x, int y, int zoom);
 381 static char *_mapquest_aerial_url_cb(Evas_Object *obj __UNUSED__, int x, int y, int zoom);
 382 static char *_yours_url_cb(Evas_Object *obj __UNUSED__, char *type_name, int method, double flon, double flat, double tlon, double tlat);
 383 static char *_nominatim_url_cb(Evas_Object *obj, int method, char *name, double lon, double lat);
 384 /*
 385 static char *_monav_url_cb(Evas_Object *obj __UNUSED__, char *type_name, int method, double flon, double flat, double tlon, double tlat)
 386 static char *_ors_url_cb(Evas_Object *obj __UNUSED__, char *type_name, int method, double flon, double flat, double tlon, double tlat);
 387 */
 388
 389 static Map_Sources_Tab default_map_sources_tab[] =
 390 {
 391      {"Mapnik", 0, 18, _mapnik_url_cb, ELM_MAP_ROUTE_SOURCE_YOURS, _yours_url_cb, _nominatim_url_cb, NULL, NULL},
 392      {"Osmarender", 0, 17, _osmarender_url_cb, ELM_MAP_ROUTE_SOURCE_YOURS, _yours_url_cb, _nominatim_url_cb, NULL, NULL},
 393      {"CycleMap", 0, 16, _cyclemap_url_cb, ELM_MAP_ROUTE_SOURCE_YOURS, _yours_url_cb, _nominatim_url_cb, NULL, NULL},
 394      {"MapQuest", 0, 18, _mapquest_url_cb, ELM_MAP_ROUTE_SOURCE_YOURS, _yours_url_cb, _nominatim_url_cb, NULL, NULL},
 395      {"MapQuest Open Aerial", 0, 11, _mapquest_aerial_url_cb, ELM_MAP_ROUTE_SOURCE_YOURS, _yours_url_cb, _nominatim_url_cb, NULL, NULL},
 396 };
 397
 398 static const char *widtype = NULL;
 399 static Evas_Smart_Class parent_sc = EVAS_SMART_CLASS_INIT_NULL;
 400 static Evas_Smart_Class sc;
 401 static Evas_Smart *smart;
 402 static int idnum = 1;
 403
 404 static const char SIG_CHANGED[] = "changed";
 405 static const char SIG_CLICKED[] = "clicked";
 406 static const char SIG_CLICKED_DOUBLE[] = "clicked,double";
 407 static const char SIG_LOADED_DETAIL[] = "loaded,detail";
 408 static const char SIG_LOAD_DETAIL[] = "load,detail";
 409 static const char SIG_LONGPRESSED[] = "longpressed";
 410 static const char SIG_PRESS[] = "press";
 411 static const char SIG_SCROLL[] = "scroll";
 412 static const char SIG_SCROLL_DRAG_START[] = "scroll,drag,start";
 413 static const char SIG_SCROLL_DRAG_STOP[] = "scroll,drag,stop";
 414 static const char SIG_SCROLL_ANIM_START[] = "scroll,anim,start";
 415 static const char SIG_SCROLL_ANIM_STOP[] = "scroll,anim,stop";
 416 static const char SIG_ZOOM_CHANGE[] = "zoom,change";
 417 static const char SIG_ZOOM_START[] = "zoom,start";
 418 static const char SIG_ZOOM_STOP[] = "zoom,stop";
 419 static const char SIG_DOWNLOADED[] = "downloaded";
 420 static const char SIG_ROUTE_LOAD[] = "route,load";
 421 static const char SIG_ROUTE_LOADED[] = "route,loaded";
 422 static const char SIG_NAME_LOAD[] = "name,load";
 423 static const char SIG_NAME_LOADED[] = "name,loaded";
 424 static const Evas_Smart_Cb_Description _signals[] = {
 425        {SIG_CHANGED, ""},
 426        {SIG_CLICKED, ""},
 427        {SIG_CLICKED_DOUBLE, ""},
 428        {SIG_LOADED_DETAIL, ""},
 429        {SIG_LOAD_DETAIL, ""},
 430        {SIG_LONGPRESSED, ""},
 431        {SIG_PRESS, ""},
 432        {SIG_SCROLL, ""},
 433        {SIG_SCROLL_DRAG_START, ""},
 434        {SIG_SCROLL_DRAG_STOP, ""},
 435        {SIG_SCROLL_ANIM_START, ""},
 436        {SIG_SCROLL_ANIM_STOP, ""},
 437        {SIG_ZOOM_CHANGE, ""},
 438        {SIG_ZOOM_START, ""},
 439        {SIG_ZOOM_STOP, ""},
 440        {SIG_DOWNLOADED, ""},
 441        {SIG_ROUTE_LOAD, ""},
 442        {SIG_ROUTE_LOADED, ""},
 443        {SIG_NAME_LOAD, ""},
 444        {SIG_NAME_LOADED, ""},
 445        {NULL, NULL}
 446 };
 447
 448 static Eina_Bool
 449 module_list_cb(Eina_Module *m, void *data)
 450 {
 451    EINA_SAFETY_ON_NULL_RETURN_VAL(data,EINA_FALSE);
 452    Widget_Data *wd = data;
 453
 454    Map_Sources_Tab *s;
 455    ElmMapModuleSourceFunc source;
 456    ElmMapModuleZoomMinFunc zoom_min;
 457    ElmMapModuleZoomMaxFunc zoom_max;
 458    ElmMapModuleUrlFunc url;
 459    ElmMapModuleRouteSourceFunc route_source;
 460    ElmMapModuleRouteUrlFunc route_url;
 461    ElmMapModuleNameUrlFunc name_url;
 462    ElmMapModuleGeoIntoCoordFunc geo_into_coord;
 463    ElmMapModuleCoordIntoGeoFunc coord_into_geo;
 464    const char *file;
 465
 466    file = eina_module_file_get(m);
 467    if (!eina_module_load(m))
 468      {
 469         ERR("could not load module \"%s\": %s", file,
 470             eina_error_msg_get(eina_error_get()));
 471         return EINA_FALSE;
 472      }
 473
 474    source = eina_module_symbol_get(m, "map_module_source_get");
 475    zoom_min = eina_module_symbol_get(m, "map_module_zoom_min_get");
 476    zoom_max = eina_module_symbol_get(m, "map_module_zoom_max_get");
 477    url = eina_module_symbol_get(m, "map_module_url_get");
 478    route_source = eina_module_symbol_get(m, "map_module_route_source_get");
 479    route_url = eina_module_symbol_get(m, "map_module_route_url_get");
 480    name_url = eina_module_symbol_get(m, "map_module_name_url_get");
 481    geo_into_coord = eina_module_symbol_get(m, "map_module_geo_into_coord");
 482    coord_into_geo = eina_module_symbol_get(m, "map_module_coord_into_geo");
 483    if ((!source) || (!zoom_min) || (!zoom_max) || (!url) || (!route_source) ||
 484        (!route_url) || (!name_url) || (!geo_into_coord) || (!coord_into_geo))
 485      {
 486         WRN("could not find map_module_source_get() in module \"%s\": %s",
 487             file, eina_error_msg_get(eina_error_get()));
 488         eina_module_unload(m);
 489         return EINA_FALSE;
 490      }
 491    s = ELM_NEW(Map_Sources_Tab);
 492    s->name = source();
 493    s->zoom_min = zoom_min();
 494    s->zoom_max = zoom_max();
 495    s->url_cb = url;
 496    s->route_source = route_source();
 497    s->route_url_cb = route_url;
 498    s->name_url_cb = name_url;
 499    s->geo_into_coord = geo_into_coord;
 500    s->coord_into_geo = coord_into_geo;
 501    wd->srcs = eina_list_append(wd->srcs, s);
 502
 503    eina_module_unload(m);
 504    return EINA_TRUE;
 505 }
 506
 507 static void
 508 source_init(Widget_Data *wd)
 509 {
 510    EINA_SAFETY_ON_NULL_RETURN(wd);
 511
 512    Map_Sources_Tab *s;
 513    unsigned int idx;
 514    Eina_Array *modules = NULL;
 515    Eina_List *l;
 516
 517    for (idx = 0; idx < (sizeof(default_map_sources_tab) / sizeof(Map_Sources_Tab)); idx++)
 518      {
 519         s = ELM_NEW(Map_Sources_Tab);
 520         s->name = default_map_sources_tab[idx].name;
 521         s->zoom_min = default_map_sources_tab[idx].zoom_min;
 522         s->zoom_max = default_map_sources_tab[idx].zoom_max;
 523         s->url_cb = default_map_sources_tab[idx].url_cb;
 524         s->route_source = default_map_sources_tab[idx].route_source;
 525         s->route_url_cb = default_map_sources_tab[idx].route_url_cb;
 526         s->name_url_cb = default_map_sources_tab[idx].name_url_cb;
 527         s->geo_into_coord = default_map_sources_tab[idx].geo_into_coord;
 528         s->coord_into_geo = default_map_sources_tab[idx].coord_into_geo;
 529         wd->srcs = eina_list_append(wd->srcs, s);
 530         if (!idx)
 531           {
 532              wd->src = s;
 533              wd->zoom_min = s->zoom_min;
 534              wd->zoom_max = s->zoom_max;
 535           }
 536      }
 537    modules = eina_module_list_get(modules, MODULES_PATH, 1, &module_list_cb, wd);
 538    eina_array_free(modules);
 539
 540    wd->src_names = calloc((eina_list_count(wd->srcs) + 1), sizeof(char *));
 541    idx = 0;
 542    EINA_LIST_FOREACH(wd->srcs, l, s)
 543      {
 544         eina_stringshare_replace(&wd->src_names[idx], s->name);
 545         INF("source : %s", wd->src_names[idx]);
 546         idx++;
 547      }
 548 }
 549
 550 static void
 551 _edj_marker_size_get(Widget_Data *wd, Evas_Coord *w, Evas_Coord *h)
 552 {
 553    EINA_SAFETY_ON_NULL_RETURN(wd);
 554    EINA_SAFETY_ON_NULL_RETURN(w);
 555    EINA_SAFETY_ON_NULL_RETURN(h);
 556
 557    Evas_Object *edj;
 558    const char *s;
 559
 560    edj = edje_object_add(evas_object_evas_get(wd->obj));
 561    _elm_theme_object_set(wd->obj, edj, "map/marker", "radio",
 562                          elm_widget_style_get(wd->obj));
 563    s = edje_object_data_get(edj, "size_w");
 564    if (s) *w = atoi(s);
 565    else   *w = 0;
 566    s = edje_object_data_get(edj, "size_h");
 567    if (s) *h = atoi(s);
 568    else   *h = 0;
 569    evas_object_del(edj);
 570 }
 571
 572 static void
 573 _coord_rotate(const Evas_Coord x, const Evas_Coord y, const Evas_Coord cx, const Evas_Coord cy, const double degree, Evas_Coord *xx, Evas_Coord *yy)
 574 {
 575    EINA_SAFETY_ON_NULL_RETURN(xx);
 576    EINA_SAFETY_ON_NULL_RETURN(yy);
 577
 578    double r = (degree * M_PI) / 180.0;
 579    double tx, ty, ttx, tty;
 580
 581    tx = x - cx;
 582    ty = y - cy;
 583
 584    ttx = tx * cos(r);
 585    tty = tx * sin(r);
 586    tx = ttx + (ty * cos(r + M_PI_2));
 587    ty = tty + (ty * sin(r + M_PI_2));
 588
 589    *xx = tx + cx;
 590    *yy = ty + cy;
 591 }
 592
 593 static void
 594 _viewport_size_get(Widget_Data *wd, Evas_Coord *vw, Evas_Coord *vh)
 595 {
 596    EINA_SAFETY_ON_NULL_RETURN(wd);
 597
 598    Evas_Coord x, y, w, h;
 599    evas_object_geometry_get(wd->pan_smart, &x, &y, &w, &h);
 600    if (vw) *vw = (x * 2) + w;
 601    if (vh) *vh = (y * 2) + h;
 602 }
 603
 604 static void
 605 _pan_geometry_get(Widget_Data *wd, Evas_Coord *px, Evas_Coord *py)
 606 {
 607    EINA_SAFETY_ON_NULL_RETURN(wd);
 608
 609    Evas_Coord x, y, vx, vy, vw, vh;
 610    elm_smart_scroller_child_pos_get(wd->scr, &x, &y);
 611    evas_object_geometry_get(wd->pan_smart, &vx, &vy, &vw, &vh);
 612    x = -x;
 613    y = -y;
 614    if (vw > wd->size.w) x += (((vw - wd->size.w) / 2) + vx);
 615    else x -= vx;
 616    if (vh > wd->size.h) y += (((vh - wd->size.h) / 2) + vy);
 617    else y -= vy;
 618    if (px) *px = x;
 619    if (py) *py = y;
 620  }
 621
 622 static void
 623 _obj_rotate(Widget_Data *wd, Evas_Object *obj)
 624 {
 625    Evas_Coord w, h, ow, oh;
 626    evas_map_util_points_populate_from_object(wd->map, obj);
 627
 628    evas_object_geometry_get(obj, NULL, NULL, &ow, &oh);
 629    evas_object_image_size_get(obj, &w, &h);
 630    if ((w > ow) || (h > oh))
 631      {
 632         evas_map_point_image_uv_set(wd->map, 0, 0, 0);
 633         evas_map_point_image_uv_set(wd->map, 1, w, 0);
 634         evas_map_point_image_uv_set(wd->map, 2, w, h);
 635         evas_map_point_image_uv_set(wd->map, 3, 0, h);
 636      }
 637    evas_map_util_rotate(wd->map, wd->rotate.d, wd->rotate.cx, wd->rotate.cy);
 638
 639    evas_object_map_set(obj, wd->map);
 640    evas_object_map_enable_set(obj, EINA_TRUE);
 641 }
 642
 643 static void
 644 _obj_place(Evas_Object *obj, Evas_Coord x, Evas_Coord y, Evas_Coord w, Evas_Coord h)
 645 {
 646    EINA_SAFETY_ON_NULL_RETURN(obj);
 647
 648    evas_object_move(obj, x, y);
 649    evas_object_resize(obj, w, h);
 650    evas_object_show(obj);
 651 }
 652
 653 static void
 654 _bubble_update(Marker_Bubble *bubble, Eina_List *contents)
 655 {
 656    EINA_SAFETY_ON_NULL_RETURN(bubble);
 657    EINA_SAFETY_ON_NULL_RETURN(contents);
 658
 659    Eina_List *l;
 660    Evas_Object *c;
 661
 662    elm_box_clear(bubble->bx);
 663    EINA_LIST_FOREACH(contents, l, c) elm_box_pack_end(bubble->bx, c);
 664 }
 665
 666 static void
 667 _bubble_place(Marker_Bubble *bubble)
 668 {
 669    EINA_SAFETY_ON_NULL_RETURN(bubble);
 670
 671    Evas_Coord x, y, w, h;
 672    Evas_Coord xx, yy, ww, hh;
 673    const char *s;
 674
 675    if ((!bubble->obj) || (!bubble->pobj)) return;
 676    evas_object_geometry_get(bubble->pobj, &x, &y, &w, NULL);
 677
 678    s = edje_object_data_get(bubble->obj, "size_w");
 679    if (s) ww = atoi(s);
 680    else ww = 0;
 681
 682    edje_object_size_min_calc(bubble->obj, NULL, &hh);
 683    s = edje_object_data_get(bubble->obj, "size_h");
 684    if (s) h = atoi(s);
 685    else h = 0;
 686    if (hh < h) hh = h;
 687
 688    xx = x + (w / 2) - (ww / 2);
 689    yy = y - hh;
 690
 691    _obj_place(bubble->obj, xx, yy, ww, hh);
 692    evas_object_raise(bubble->obj);
 693 }
 694
 695 static void
 696 _bubble_sc_hints_changed_cb(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
 697 {
 698    Marker_Bubble *bubble = data;
 699    EINA_SAFETY_ON_NULL_RETURN(bubble);
 700    _bubble_place(data);
 701 }
 702
 703 static void
 704 _bubble_mouse_up_cb(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
 705 {
 706    Marker_Bubble *bubble = data;
 707    EINA_SAFETY_ON_NULL_RETURN(bubble);
 708    _bubble_place(bubble);
 709 }
 710
 711 static void
 712 _bubble_hide_cb(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
 713 {
 714    Marker_Bubble *bubble = data;
 715    EINA_SAFETY_ON_NULL_RETURN(bubble);
 716    evas_object_hide(bubble->obj);
 717 }
 718
 719 static void
 720 _bubble_show_cb(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
 721 {
 722    Marker_Bubble *bubble = data;
 723    EINA_SAFETY_ON_NULL_RETURN(bubble);
 724    _bubble_place(bubble);
 725 }
 726
 727 static void
 728 _bubble_move_cb(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
 729 {
 730    Marker_Bubble *bubble = data;
 731    EINA_SAFETY_ON_NULL_RETURN(bubble);
 732    _bubble_place(bubble);
 733 }
 734
 735 static void
 736 _bubble_free(Marker_Bubble* bubble)
 737 {
 738    EINA_SAFETY_ON_NULL_RETURN(bubble);
 739
 740    evas_object_del(bubble->bx);
 741    evas_object_del(bubble->sc);
 742    evas_object_del(bubble->obj);
 743    free(bubble);
 744 }
 745
 746 static Marker_Bubble*
 747 _bubble_create(Evas_Object *pobj, Widget_Data *wd)
 748 {
 749    EINA_SAFETY_ON_NULL_RETURN_VAL(pobj, NULL);
 750    EINA_SAFETY_ON_NULL_RETURN_VAL(wd, NULL);
 751
 752    Marker_Bubble *bubble = ELM_NEW(Marker_Bubble);
 753    EINA_SAFETY_ON_NULL_RETURN_VAL(bubble, NULL);
 754
 755    bubble->wd = wd;
 756    bubble->pobj = pobj;
 757    evas_object_event_callback_add(pobj, EVAS_CALLBACK_HIDE, _bubble_hide_cb,
 758                                   bubble);
 759    evas_object_event_callback_add(pobj, EVAS_CALLBACK_SHOW, _bubble_show_cb,
 760                                   bubble);
 761    evas_object_event_callback_add(pobj, EVAS_CALLBACK_MOVE, _bubble_move_cb,
 762                                   bubble);
 763
 764    bubble->obj = edje_object_add(evas_object_evas_get(pobj));
 765    _elm_theme_object_set(wd->obj, bubble->obj , "map", "marker_bubble",
 766                          elm_widget_style_get(wd->obj));
 767    evas_object_event_callback_add(bubble->obj, EVAS_CALLBACK_MOUSE_UP,
 768                                   _bubble_mouse_up_cb, bubble);
 769
 770    bubble->sc = elm_scroller_add(bubble->obj);
 771    elm_widget_style_set(bubble->sc, "map_bubble");
 772    elm_scroller_content_min_limit(bubble->sc, EINA_FALSE, EINA_TRUE);
 773    elm_scroller_policy_set(bubble->sc, ELM_SCROLLER_POLICY_AUTO,
 774                            ELM_SCROLLER_POLICY_OFF);
 775    elm_scroller_bounce_set(bubble->sc, _elm_config->thumbscroll_bounce_enable,
 776                            EINA_FALSE);
 777    edje_object_part_swallow(bubble->obj, "elm.swallow.content", bubble->sc);
 778    evas_object_event_callback_add(bubble->sc, EVAS_CALLBACK_CHANGED_SIZE_HINTS,
 779                                   _bubble_sc_hints_changed_cb, bubble);
 780
 781    bubble->bx = elm_box_add(bubble->sc);
 782    evas_object_size_hint_align_set(bubble->bx, EVAS_HINT_FILL, EVAS_HINT_FILL);
 783    evas_object_size_hint_weight_set(bubble->bx, EVAS_HINT_EXPAND,
 784                                     EVAS_HINT_EXPAND);
 785    elm_box_horizontal_set(bubble->bx, EINA_TRUE);
 786    elm_object_content_set(bubble->sc, bubble->bx);
 787
 788    return bubble;
 789 }
 790
 791 static void
 792 _marker_group_update(Marker_Group* group, Elm_Map_Group_Class *clas, Eina_List *markers)
 793 {
 794    EINA_SAFETY_ON_NULL_RETURN(group);
 795    EINA_SAFETY_ON_NULL_RETURN(clas);
 796    EINA_SAFETY_ON_NULL_RETURN(markers);
 797    Widget_Data *wd = clas->wd;
 798    EINA_SAFETY_ON_NULL_RETURN(wd);
 799
 800    char buf[PATH_MAX];
 801    Eina_List *l;
 802    Elm_Map_Marker *marker;
 803    int cnt = 0;
 804    int sum_x = 0, sum_y = 0;
 805
 806    EINA_LIST_FOREACH(markers, l, marker)
 807      {
 808         sum_x += marker->x;
 809         sum_y += marker->y;
 810         cnt++;
 811      }
 812
 813    group->x = sum_x / cnt;
 814    group->y = sum_y / cnt;
 815    _edj_marker_size_get(wd, &group->w, &group->h);
 816    group->w *=2;
 817    group->h *=2;
 818    group->clas = clas;
 819    group->markers = markers;
 820
 821    if (clas->style) elm_layout_theme_set(group->obj, "map/marker", clas->style,
 822                                          elm_widget_style_get(wd->obj));
 823    else elm_layout_theme_set(group->obj, "map/marker", "radio",
 824                              elm_widget_style_get(wd->obj));
 825
 826
 827    if (clas->func.icon_get)
 828      {
 829         Evas_Object *icon = NULL;
 830
 831         icon = elm_object_part_content_get(group->obj, "elm.icon");
 832         if (icon) evas_object_del(icon);
 833
 834         icon = clas->func.icon_get(wd->obj, clas->data);
 835         elm_object_part_content_set(group->obj, "elm.icon", icon);
 836      }
 837    snprintf(buf, sizeof(buf), "%d", cnt);
 838    edje_object_part_text_set(elm_layout_edje_get(group->obj), "elm.text", buf);
 839
 840    if (group->bubble)
 841       {
 842          Eina_List *l;
 843          Elm_Map_Marker *marker;
 844          Eina_List *contents = NULL;
 845
 846          EINA_LIST_FOREACH(group->markers, l, marker)
 847            {
 848               Evas_Object *c = marker->clas->func.get(marker->wd->obj,
 849                                                       marker, marker->data);
 850               if (c) contents = eina_list_append(contents, c);
 851            }
 852          _bubble_update(group->bubble, contents);
 853       }
 854 }
 855
 856 static void
 857 _marker_group_bubble_open_cb(void *data, Evas_Object *obj __UNUSED__, const char *emission __UNUSED__, const char *soure __UNUSED__)
 858 {
 859    EINA_SAFETY_ON_NULL_RETURN(data);
 860    Marker_Group *group = data;
 861    Eina_List *l;
 862    Elm_Map_Marker *marker;
 863    Eina_List *contents = NULL;
 864
 865    if (!group->bubble) group->bubble = _bubble_create(group->obj, group->wd);
 866
 867    EINA_LIST_FOREACH(group->markers, l, marker)
 868      {
 869         if (group->wd->markers_max_num <= eina_list_count(contents)) break;
 870         Evas_Object *c = marker->clas->func.get(marker->wd->obj,
 871                                                 marker, marker->data);
 872         if (c) contents = eina_list_append(contents, c);
 873      }
 874    _bubble_update(group->bubble, contents);
 875    _bubble_place(group->bubble);
 876 }
 877
 878 static void
 879 _marker_group_bringin_cb(void *data, Evas_Object *obj __UNUSED__, const char *emission __UNUSED__, const char *soure __UNUSED__)
 880 {
 881    EINA_SAFETY_ON_NULL_RETURN(data);
 882
 883    double lon, lat;
 884    Marker_Group *group = data;
 885    elm_map_utils_convert_coord_into_geo(group->wd->obj, group->x, group->y,
 886                                         group->wd->size.w, &lon, &lat);
 887    elm_map_geo_region_bring_in(group->wd->obj, lon, lat);
 888 }
 889
 890 static void
 891 _marker_group_free(Marker_Group* group)
 892 {
 893    EINA_SAFETY_ON_NULL_RETURN(group);
 894
 895    if (group->bubble) _bubble_free(group->bubble);
 896
 897    eina_list_free(group->markers);
 898    evas_object_del(group->obj);
 899
 900    free(group);
 901 }
 902
 903 static Marker_Group*
 904 _marker_group_create(Widget_Data *wd)
 905 {
 906    EINA_SAFETY_ON_NULL_RETURN_VAL(wd, NULL);
 907
 908    Marker_Group *group = ELM_NEW(Marker_Group);
 909
 910    group->wd = wd;
 911    group->obj = elm_layout_add(wd->obj);
 912    evas_object_smart_member_add(group->obj, wd->pan_smart);
 913    evas_object_stack_above(group->obj, wd->sep_maps_markers);
 914    elm_layout_theme_set(group->obj, "map/marker", "radio",
 915                         elm_widget_style_get(wd->obj));
 916    edje_object_signal_callback_add(elm_layout_edje_get(group->obj),
 917                                    "open", "elm", _marker_group_bubble_open_cb,
 918                                    group);
 919    edje_object_signal_callback_add(elm_layout_edje_get(group->obj),
 920                                    "bringin", "elm", _marker_group_bringin_cb,
 921                                    group);
 922    return group;
 923 }
 924
 925 static void
 926 _marker_bringin_cb(void *data, Evas_Object *obj __UNUSED__, const char *emission __UNUSED__, const char *soure __UNUSED__)
 927 {
 928    Elm_Map_Marker *marker = data;
 929    EINA_SAFETY_ON_NULL_RETURN(marker);
 930    elm_map_geo_region_bring_in(marker->wd->obj, marker->longitude, marker->latitude);
 931 }
 932
 933 static void
 934 _marker_bubble_open_cb(void *data, Evas_Object *obj __UNUSED__, const char *emission __UNUSED__, const char *soure __UNUSED__)
 935 {
 936    EINA_SAFETY_ON_NULL_RETURN(data);
 937    Elm_Map_Marker *marker = data;
 938
 939    if (!marker->bubble) marker->bubble = _bubble_create(marker->obj, marker->wd);
 940    evas_object_smart_changed(marker->wd->pan_smart);
 941 }
 942
 943 static void
 944 _marker_update(Elm_Map_Marker *marker)
 945 {
 946    EINA_SAFETY_ON_NULL_RETURN(marker);
 947    Elm_Map_Marker_Class *clas = marker->clas;
 948    EINA_SAFETY_ON_NULL_RETURN(clas);
 949
 950    if (clas->style) elm_layout_theme_set(marker->obj, "map/marker", clas->style,
 951                                          elm_widget_style_get(marker->wd->obj));
 952    else elm_layout_theme_set(marker->obj, "map/marker", "radio",
 953                              elm_widget_style_get(marker->wd->obj));
 954
 955    if (clas->func.icon_get)
 956      {
 957         Evas_Object *icon = NULL;
 958
 959         icon = elm_object_part_content_get(marker->obj, "elm.icon");
 960         if (icon) evas_object_del(icon);
 961
 962         icon = clas->func.icon_get(marker->wd->obj, marker, marker->data);
 963         elm_object_part_content_set(marker->obj, "elm.icon", icon);
 964      }
 965
 966    elm_map_utils_convert_geo_into_coord(marker->wd->obj, marker->longitude,
 967                                         marker->latitude, marker->wd->size.w,
 968                                         &(marker->x), &(marker->y));
 969
 970     if (marker->bubble)
 971       {
 972          if (marker->content) evas_object_del(marker->content);
 973          if (marker->clas->func.get)
 974             marker->content = marker->clas->func.get(marker->wd->obj, marker,
 975                                                      marker->data);
 976         if (marker->content)
 977           {
 978              Eina_List *contents = NULL;
 979              contents = eina_list_append(contents, marker->content);
 980              _bubble_update(marker->bubble, contents);
 981           }
 982       }
 983 }
 984
 985
 986
 987 static void
 988 _marker_place(Widget_Data *wd)
 989 {
 990    EINA_SAFETY_ON_NULL_RETURN(wd);
 991
 992    Eina_List *l;
 993
 994    Elm_Map_Marker *marker;
 995    Elm_Map_Group_Class *group_clas;
 996
 997    Evas_Coord gw, gh;
 998    Evas_Coord px, py;
 999
1000    if (wd->paused_markers || (!eina_list_count(wd->markers))) return;
1001
1002    _pan_geometry_get(wd, &px, &py);
1003
1004    _edj_marker_size_get(wd, &gw, &gh);
1005    gw *= 2;
1006    gh *= 2;
1007
1008    EINA_LIST_FOREACH(wd->markers, l, marker)
1009      {
1010         _marker_update(marker);
1011         marker->grouped = EINA_FALSE;
1012         marker->leader = EINA_FALSE;
1013      }
1014
1015    EINA_LIST_FOREACH(wd->group_classes, l, group_clas)
1016      {
1017         Eina_List *ll;
1018         EINA_LIST_FOREACH(group_clas->markers, ll, marker)
1019           {
1020              Eina_List *lll;
1021              Elm_Map_Marker *mm;
1022              Eina_List *markers = NULL;
1023
1024              if (marker->grouped) continue;
1025              if (group_clas->zoom_grouped < wd->zoom)
1026                {
1027                   marker->grouped = EINA_FALSE;
1028                   continue;
1029                }
1030
1031              EINA_LIST_FOREACH(group_clas->markers, lll, mm)
1032                {
1033                   if (marker == mm || mm->grouped) continue;
1034                   if (ELM_RECTS_INTERSECT(mm->x, mm->y, mm->w, mm->h,
1035                                           marker->x, marker->y, gw, gh))
1036                     {
1037                        // mm is group follower.
1038                        mm->leader = EINA_FALSE;
1039                        mm->grouped = EINA_TRUE;
1040                        markers = eina_list_append(markers, mm);
1041                     }
1042                }
1043               if (eina_list_count(markers) >= 1)
1044                 {
1045                    // marker is group leader.
1046                    marker->leader = EINA_TRUE;
1047                    marker->grouped = EINA_TRUE;
1048                    markers = eina_list_append(markers, marker);
1049
1050                    if (!marker->group) marker->group = _marker_group_create(wd);
1051                    _marker_group_update(marker->group, group_clas, markers);
1052                 }
1053           }
1054      }
1055
1056    EINA_LIST_FOREACH(wd->markers, l, marker)
1057      {
1058
1059         if (marker->grouped ||
1060            (marker->group_clas &&
1061             (marker->group_clas->hide ||
1062              marker->group_clas->zoom_displayed > wd->zoom)))
1063            evas_object_hide(marker->obj);
1064         else
1065           {
1066              Evas_Coord x, y;
1067              _coord_rotate(marker->x + px, marker->y + py, wd->rotate.cx,
1068                            wd->rotate.cy, wd->rotate.d, &x, &y);
1069              _obj_place(marker->obj, x - (marker->w / 2), y - (marker->h / 2),
1070                          marker->w, marker->h);
1071           }
1072      }
1073
1074    EINA_LIST_FOREACH(wd->markers, l, marker)
1075      {
1076         Marker_Group *group = marker->group;
1077         if (!group) continue;
1078
1079         if (!marker->leader || (group->clas->hide) ||
1080             (group->clas->zoom_displayed > wd->zoom))
1081            evas_object_hide(group->obj);
1082         else
1083           {
1084              Evas_Coord x, y;
1085              _coord_rotate(group->x + px, group->y + py, wd->rotate.cx,
1086                            wd->rotate.cy, wd->rotate.d, &x, &y);
1087              _obj_place(group->obj, x - (group->w / 2), y - (group->h / 2),
1088                          group->w, group->h);
1089           }
1090      }
1091 }
1092
1093
1094 static void
1095 _grid_item_coord_get(Grid_Item *gi, int *x, int *y, int *w, int *h)
1096 {
1097    EINA_SAFETY_ON_NULL_RETURN(gi);
1098
1099    if (x) *x = gi->x * gi->wd->size.tile;
1100    if (y) *y = gi->y * gi->wd->size.tile;
1101    if (w) *w = gi->wd->size.tile;
1102    if (h) *h = gi->wd->size.tile;
1103 }
1104
1105 static Eina_Bool
1106 _grid_item_intersect(Grid_Item *gi)
1107 {
1108    EINA_SAFETY_ON_NULL_RETURN_VAL(gi, EINA_FALSE);
1109
1110    Evas_Coord px, py;
1111    Evas_Coord vw, vh;
1112    Evas_Coord x, y, w, h;
1113
1114    _pan_geometry_get(gi->wd, &px, &py);
1115    _viewport_size_get(gi->wd, &vw, &vh);
1116    _grid_item_coord_get(gi, &x, &y, &w, &h);
1117    return ELM_RECTS_INTERSECT(x + px, y + py, w, h, 0, 0, vw, vh);
1118 }
1119
1120 static void
1121 _grid_item_update(Grid_Item *gi)
1122 {
1123    evas_object_image_file_set(gi->img, gi->file, NULL);
1124    if (!gi->wd->zoom_timer && !gi->wd->scr_timer)
1125       evas_object_image_smooth_scale_set(gi->img, EINA_TRUE);
1126    else evas_object_image_smooth_scale_set(gi->img, EINA_FALSE);
1127
1128    Evas_Load_Error err = evas_object_image_load_error_get(gi->img);
1129    if (err != EVAS_LOAD_ERROR_NONE)
1130      {
1131         ERR("Image loading error (%s): %s", gi->file, evas_load_error_str(err));
1132         ecore_file_remove(gi->file);
1133         gi->file_have = EINA_FALSE;
1134      }
1135    else
1136      {
1137         Evas_Coord px, py;
1138         Evas_Coord x, y, w, h;
1139
1140         _pan_geometry_get(gi->wd, &px, &py);
1141         _grid_item_coord_get(gi, &x, &y, &w, &h);
1142
1143         _obj_place(gi->img, x + px, y + py, w, h);
1144         _obj_rotate(gi->wd, gi->img);
1145         gi->file_have = EINA_TRUE;
1146      }
1147 }
1148
1149 static void
1150 _grid_item_load(Grid_Item *gi)
1151 {
1152    EINA_SAFETY_ON_NULL_RETURN(gi);
1153    if (gi->file_have) _grid_item_update(gi);
1154    else if (!gi->job)
1155      {
1156         gi->wd->download_list = eina_list_remove(gi->wd->download_list, gi);
1157         gi->wd->download_list = eina_list_append(gi->wd->download_list, gi);
1158      }
1159 }
1160
1161 static void
1162 _grid_item_unload(Grid_Item *gi)
1163 {
1164    EINA_SAFETY_ON_NULL_RETURN(gi);
1165    if (gi->file_have)
1166      {
1167         evas_object_hide(gi->img);
1168         evas_object_image_file_set(gi->img, NULL, NULL);
1169      }
1170    else if (gi->job)
1171      {
1172         ecore_file_download_abort(gi->job);
1173         ecore_file_remove(gi->file);
1174         gi->job = NULL;
1175         gi->wd->try_num--;
1176      }
1177    else gi->wd->download_list = eina_list_remove(gi->wd->download_list, gi);
1178
1179 }
1180
1181 static Grid_Item *
1182 _grid_item_create(Grid *g, Evas_Coord x, Evas_Coord y)
1183 {
1184    EINA_SAFETY_ON_NULL_RETURN_VAL(g, NULL);
1185    char buf[PATH_MAX];
1186    char buf2[PATH_MAX];
1187    char *source;
1188    Grid_Item *gi;
1189
1190    gi = ELM_NEW(Grid_Item);
1191    gi->wd = g->wd;
1192    gi->g = g;
1193    gi->x = x;
1194    gi->y = y;
1195
1196    gi->file_have = EINA_FALSE;
1197    gi->job = NULL;
1198
1199    gi->img = evas_object_image_add(evas_object_evas_get(g->wd->obj));
1200    evas_object_image_smooth_scale_set(gi->img, EINA_FALSE);
1201    evas_object_image_scale_hint_set(gi->img, EVAS_IMAGE_SCALE_HINT_DYNAMIC);
1202    evas_object_image_filled_set(gi->img, 1);
1203    evas_object_smart_member_add(gi->img, g->wd->pan_smart);
1204    evas_object_pass_events_set(gi->img, EINA_TRUE);
1205    evas_object_stack_below(gi->img, g->wd->sep_maps_markers);
1206
1207    snprintf(buf, sizeof(buf), CACHE_PATH, g->wd->id, g->zoom, x);
1208    snprintf(buf2, sizeof(buf2), CACHE_FILE_PATH, buf, y);
1209    if (!ecore_file_exists(buf)) ecore_file_mkpath(buf);
1210
1211    eina_stringshare_replace(&gi->file, buf2);
1212    source = g->wd->src->url_cb(g->wd->obj, x, y, g->zoom);
1213    if ((!source) || (!strlen(source)))
1214      {
1215         eina_stringshare_replace(&gi->source, NULL);
1216         ERR("Getting source url failed: %s", gi->file);
1217      }
1218    else eina_stringshare_replace(&gi->source, source);
1219    if (source) free(source);
1220    eina_matrixsparse_data_idx_set(g->grid, y, x, gi);
1221    return gi;
1222 }
1223
1224 static void
1225 _grid_item_free(Grid_Item *gi)
1226 {
1227    EINA_SAFETY_ON_NULL_RETURN(gi);
1228
1229    _grid_item_unload(gi);
1230    if (gi->g && gi->g->grid) eina_matrixsparse_data_idx_set(gi->g->grid,
1231                                                             gi->y, gi->x, NULL);
1232    if (gi->source) eina_stringshare_del(gi->source);
1233    if (gi->file) eina_stringshare_del(gi->file);
1234    if (gi->img) evas_object_del(gi->img);
1235    if (gi->file_have) ecore_file_remove(gi->file);
1236    free(gi);
1237 }
1238
1239 static void
1240 _downloaded_cb(void *data, const char *file __UNUSED__, int status)
1241 {
1242    Grid_Item *gi = data;
1243
1244    if (status == 200)
1245      {
1246         DBG("Download success from %s to %s", gi->source, gi->file);
1247         _grid_item_update(gi);
1248         gi->wd->finish_num++;
1249      }
1250    else
1251      {
1252         WRN("Download failed from %s to %s (%d) ", gi->source, gi->file, status);
1253         ecore_file_remove(gi->file);
1254         gi->file_have = EINA_FALSE;
1255      }
1256
1257    gi->job = NULL;
1258    gi->wd->download_num--;
1259    evas_object_smart_callback_call(gi->wd->obj, SIG_DOWNLOADED, NULL);
1260
1261    if (!gi->wd->download_num)
1262      {
1263         edje_object_signal_emit(elm_smart_scroller_edje_object_get(gi->wd->scr),
1264                                 "elm,state,busy,stop", "elm");
1265         evas_object_smart_callback_call(gi->wd->obj, SIG_LOADED_DETAIL, NULL);
1266      }
1267 }
1268
1269 static Eina_Bool
1270 _download_job(void *data)
1271 {
1272    EINA_SAFETY_ON_NULL_RETURN_VAL(data, ECORE_CALLBACK_CANCEL);
1273    Widget_Data *wd = data;
1274
1275    Eina_List *l, *ll;
1276    Grid_Item *gi;
1277
1278    if (!eina_list_count(wd->download_list))
1279      {
1280         wd->download_idler = NULL;
1281         return ECORE_CALLBACK_CANCEL;
1282      }
1283
1284    EINA_LIST_REVERSE_FOREACH_SAFE(wd->download_list, l, ll, gi)
1285      {
1286         if (gi->g->zoom != wd->zoom || !_grid_item_intersect(gi))
1287           {
1288              wd->download_list = eina_list_remove(wd->download_list, gi);
1289              continue;
1290           }
1291         if (wd->download_num >= MAX_CONCURRENT_DOWNLOAD)
1292            return ECORE_CALLBACK_RENEW;
1293
1294         Eina_Bool ret = ecore_file_download_full(gi->source, gi->file,
1295                                                  _downloaded_cb, NULL,
1296                                                  gi, &(gi->job), wd->ua);
1297         if ((!ret) || (!gi->job))
1298            ERR("Can't start to download from %s to %s", gi->source, gi->file);
1299         else
1300           {
1301              wd->download_list = eina_list_remove(wd->download_list, gi);
1302
1303              wd->try_num++;
1304              wd->download_num++;
1305              if (wd->download_num == 1)
1306                edje_object_signal_emit(elm_smart_scroller_edje_object_get(wd->scr),
1307                                        "elm,state,busy,start", "elm");
1308           }
1309      }
1310    return ECORE_CALLBACK_RENEW;
1311 }
1312
1313 static void
1314 _grid_viewport_get(Grid *g, int *x, int *y, int *w, int *h)
1315 {
1316    EINA_SAFETY_ON_NULL_RETURN(g);
1317    int xx, yy, ww, hh;
1318    Evas_Coord px, py, vw, vh;
1319
1320    _pan_geometry_get(g->wd, &px, &py);
1321    _viewport_size_get(g->wd, &vw, &vh);
1322    if (px > 0) px = 0;
1323    if (py > 0) py = 0;
1324
1325    xx = (-px / g->wd->size.tile) - 1;
1326    if (xx < 0) xx = 0;
1327
1328    yy = (-py / g->wd->size.tile) - 1;
1329    if (yy < 0) yy = 0;
1330
1331    ww = (vw / g->wd->size.tile) + 3;
1332    if (xx + ww >= g->tw) ww = g->tw - xx;
1333
1334    hh = (vh / g->wd->size.tile) + 3;
1335    if (yy + hh >= g->th) hh = g->th - yy;
1336
1337    if (x) *x = xx;
1338    if (y) *y = yy;
1339    if (w) *w = ww;
1340    if (h) *h = hh;
1341 }
1342
1343 static void
1344 _grid_unload(Grid *g)
1345 {
1346    EINA_SAFETY_ON_NULL_RETURN(g);
1347    Eina_Iterator *it;
1348    Eina_Matrixsparse_Cell *cell;
1349    Grid_Item *gi;
1350
1351    it = eina_matrixsparse_iterator_new(g->grid);
1352    EINA_ITERATOR_FOREACH(it, cell)
1353      {
1354         gi = eina_matrixsparse_cell_data_get(cell);
1355         _grid_item_unload(gi);
1356      }
1357    eina_iterator_free(it);
1358 }
1359
1360 static void
1361 _grid_load(Grid *g)
1362 {
1363    EINA_SAFETY_ON_NULL_RETURN(g);
1364    int x, y, xx, yy, ww, hh;
1365    Eina_Iterator *it;
1366    Eina_Matrixsparse_Cell *cell;
1367    Grid_Item *gi;
1368
1369    it = eina_matrixsparse_iterator_new(g->grid);
1370    EINA_ITERATOR_FOREACH(it, cell)
1371      {
1372         gi = eina_matrixsparse_cell_data_get(cell);
1373         if (!_grid_item_intersect(gi)) _grid_item_unload(gi);
1374      }
1375    eina_iterator_free(it);
1376
1377    _grid_viewport_get(g, &xx, &yy, &ww, &hh);
1378    for (y = yy; y < yy + hh; y++)
1379      {
1380         for (x = xx; x < xx + ww; x++)
1381           {
1382              gi = eina_matrixsparse_data_idx_get(g->grid, y, x);
1383              if (!gi) gi = _grid_item_create(g, x, y);
1384              _grid_item_load(gi);
1385           }
1386      }
1387 }
1388
1389 static void
1390 _grid_place(Widget_Data *wd)
1391 {
1392    EINA_SAFETY_ON_NULL_RETURN(wd);
1393    Eina_List *l;
1394    Grid *g;
1395
1396    EINA_LIST_FOREACH(wd->grids, l, g)
1397      {
1398         if (wd->zoom == g->zoom) _grid_load(g);
1399         else _grid_unload(g);
1400      }
1401   if (!wd->download_idler) wd->download_idler = ecore_idler_add(_download_job, wd);
1402 }
1403
1404 static void
1405 _grid_all_create(Widget_Data *wd)
1406 {
1407    EINA_SAFETY_ON_NULL_RETURN(wd);
1408    EINA_SAFETY_ON_NULL_RETURN(wd->src);
1409
1410    int zoom;
1411    for (zoom = wd->src->zoom_min; zoom <= wd->src->zoom_max; zoom++)
1412      {
1413         Grid *g;
1414         int tnum;
1415         g = ELM_NEW(Grid);
1416         g->wd = wd;
1417         g->zoom = zoom;
1418         tnum =  pow(2.0, g->zoom);
1419         g->tw = tnum;
1420         g->th = tnum;
1421         g->grid = eina_matrixsparse_new(g->th, g->tw, NULL, NULL);
1422         wd->grids = eina_list_append(wd->grids, g);
1423      }
1424 }
1425
1426 static void
1427 _grid_all_clear(Widget_Data *wd)
1428 {
1429    EINA_SAFETY_ON_NULL_RETURN(wd);
1430
1431    Grid *g;
1432    EINA_LIST_FREE(wd->grids, g)
1433      {
1434         Grid_Item *gi;
1435         Eina_Iterator *it = eina_matrixsparse_iterator_new(g->grid);
1436         Eina_Matrixsparse_Cell *cell;
1437         EINA_ITERATOR_FOREACH(it, cell)
1438           {
1439              gi = eina_matrixsparse_cell_data_get(cell);
1440              if (gi) _grid_item_free(gi);
1441           }
1442         eina_iterator_free(it);
1443
1444         eina_matrixsparse_free(g->grid);
1445         free(g);
1446      }
1447    if (!ecore_file_recursive_rm(CACHE_ROOT_PATH))
1448       ERR("Deletion of %s failed", CACHE_ROOT_PATH);
1449 }
1450
1451 static void
1452 _track_place(Widget_Data *wd)
1453 {
1454 #ifdef ELM_EMAP
1455    EINA_SAFETY_ON_NULL_RETURN(wd);
1456
1457    Eina_List *l;
1458    Evas_Object *route;
1459    int xmin, xmax, ymin, ymax;
1460    Evas_Coord px, py, ow, oh;
1461    px = wd->pan_x;
1462    py = wd->pan_y;
1463    _viewport_size_get(wd, &ow, &oh);
1464
1465    Evas_Coord size = wd->size.w;
1466
1467    EINA_LIST_FOREACH(wd->track, l, route)
1468      {
1469         double lon_min, lon_max;
1470         double lat_min, lat_max;
1471         elm_route_longitude_min_max_get(route, &lon_min, &lon_max);
1472         elm_route_latitude_min_max_get(route, &lat_min, &lat_max);
1473         elm_map_utils_convert_geo_into_coord(wd->obj, lon_min, lat_max, size, &xmin, &ymin);
1474         elm_map_utils_convert_geo_into_coord(wd->obj, lon_max, lat_min, size, &xmax, &ymax);
1475
1476         if( !(xmin < px && xmax < px) && !(xmin > px+ow && xmax > px+ow))
1477         {
1478            if( !(ymin < py && ymax < py) && !(ymin > py+oh && ymax > py+oh))
1479            {
1480               //display the route
1481               evas_object_move(route, xmin - px, ymin - py);
1482               evas_object_resize(route, xmax - xmin, ymax - ymin);
1483
1484               evas_object_raise(route);
1485               _obj_rotate(wd, route);
1486               evas_object_show(route);
1487
1488               continue;
1489            }
1490         }
1491         //the route is not display
1492         evas_object_hide(route);
1493      }
1494 #else
1495    (void) wd;
1496 #endif
1497 }
1498 static void
1499 _route_place(Widget_Data *wd)
1500 {
1501    EINA_SAFETY_ON_NULL_RETURN(wd);
1502    Eina_List *lr, *lp, *ln;
1503    Path_Node *n;
1504    Evas_Object *p;
1505    Elm_Map_Route *r;
1506    int nodes;
1507    int x, y;
1508    double a;
1509    Evas_Coord ow, oh;
1510    Evas_Coord px, py;
1511
1512    px = wd->pan_x;
1513    py = wd->pan_y;
1514    _viewport_size_get(wd, &ow, &oh);
1515
1516    Evas_Coord size = wd->size.w;
1517
1518    EINA_LIST_FOREACH(wd->route, lr, r)
1519      {
1520         EINA_LIST_FOREACH(r->path, lp, p)
1521           {
1522              evas_object_polygon_points_clear(p);
1523           }
1524
1525         nodes = eina_list_count(r->nodes);
1526
1527         EINA_LIST_FOREACH(r->nodes, ln, n)
1528           {
1529              if ((!wd->zoom) || ((n->idx) &&
1530                  ((n->idx % (int)ceil((double)nodes/(double)size*100.0))))) continue;
1531              if (r->inbound)
1532                {
1533                   elm_map_utils_convert_geo_into_coord(wd->obj, n->pos.lon, n->pos.lat, size, &x, &y);
1534                   if ((x >= px - ow) && (x <= (px + ow*2)) &&
1535                       (y >= py - oh) && (y <= (py + oh*2)))
1536                     {
1537                        x = x - px;
1538                        y = y - py;
1539
1540                        p = eina_list_nth(r->path, n->idx);
1541                        a = (double)(y - r->y) / (double)(x - r->x);
1542                        if ((abs(a) >= 1) || (r->x == x))
1543                          {
1544                             evas_object_polygon_point_add(p, r->x - 3, r->y);
1545                             evas_object_polygon_point_add(p, r->x + 3, r->y);
1546                             evas_object_polygon_point_add(p, x + 3, y);
1547                             evas_object_polygon_point_add(p, x - 3, y);
1548                          }
1549                        else
1550                          {
1551                             evas_object_polygon_point_add(p, r->x, r->y - 3);
1552                             evas_object_polygon_point_add(p, r->x, r->y + 3);
1553                             evas_object_polygon_point_add(p, x, y + 3);
1554                             evas_object_polygon_point_add(p, x, y - 3);
1555                          }
1556
1557                        evas_object_color_set(p, r->color.r, r->color.g, r->color.b, r->color.a);
1558                        evas_object_raise(p);
1559                        _obj_rotate(wd, p);
1560                        evas_object_show(p);
1561                        r->x = x;
1562                        r->y = y;
1563                     }
1564                   else r->inbound = EINA_FALSE;
1565                }
1566              else
1567                {
1568                   elm_map_utils_convert_geo_into_coord(wd->obj, n->pos.lon, n->pos.lat, size, &x, &y);
1569                   if ((x >= px - ow) && (x <= (px + ow*2)) &&
1570                       (y >= py - oh) && (y <= (py + oh*2)))
1571                     {
1572                        r->x = x - px;
1573                        r->y = y - py;
1574                        r->inbound = EINA_TRUE;
1575                     }
1576                   else r->inbound = EINA_FALSE;
1577                }
1578           }
1579           r->inbound = EINA_FALSE;
1580      }
1581 }
1582
1583 static void
1584 _delayed_do(Widget_Data *wd)
1585 {
1586    Delayed_Data *dd;
1587    dd = eina_list_nth(wd->delayed_jobs, 0);
1588    if (dd && !dd->wd->zoom_animator)
1589      {
1590         dd->func(dd);
1591         wd->delayed_jobs = eina_list_remove(wd->delayed_jobs, dd);
1592         free(dd);
1593      }
1594 }
1595
1596 static void
1597 _smooth_update(Widget_Data *wd)
1598 {
1599    EINA_SAFETY_ON_NULL_RETURN(wd);
1600    Eina_List *l;
1601    Grid *g;
1602
1603    EINA_LIST_FOREACH(wd->grids, l, g)
1604      {
1605         Eina_Iterator *it = eina_matrixsparse_iterator_new(g->grid);
1606         Eina_Matrixsparse_Cell *cell;
1607
1608         EINA_ITERATOR_FOREACH(it, cell)
1609           {
1610              Grid_Item *gi = eina_matrixsparse_cell_data_get(cell);
1611              if (_grid_item_intersect(gi))
1612                 evas_object_image_smooth_scale_set(gi->img, EINA_TRUE);
1613           }
1614         eina_iterator_free(it);
1615      }
1616 }
1617
1618 static Eina_Bool
1619 _zoom_timeout(void *data)
1620 {
1621    EINA_SAFETY_ON_NULL_RETURN_VAL(data, ECORE_CALLBACK_CANCEL);
1622    Widget_Data *wd = data;
1623    _smooth_update(wd);
1624    wd->zoom_timer = NULL;
1625    evas_object_smart_callback_call(wd->obj, SIG_ZOOM_STOP, NULL);
1626   return ECORE_CALLBACK_CANCEL;
1627 }
1628
1629 static void
1630 zoom_do(Widget_Data *wd, double zoom)
1631 {
1632    EINA_SAFETY_ON_NULL_RETURN(wd);
1633    if (zoom > wd->zoom_max) zoom = wd->zoom_max;
1634    else if (zoom < wd->zoom_min) zoom = wd->zoom_min;
1635
1636    Evas_Coord px, py, vw, vh;
1637    Evas_Coord ow, oh;
1638
1639    wd->zoom = ROUND(zoom);
1640    wd->zoom_detail = zoom;
1641    ow = wd->size.w;
1642    oh = wd->size.h;
1643    wd->size.tile = pow(2.0, (zoom - wd->zoom)) * wd->tsize;
1644    wd->size.w = pow(2.0, wd->zoom) * wd->size.tile;
1645    wd->size.h = wd->size.w;;
1646
1647    // Fix to zooming with (viewport center px, py) as the center to prevent
1648    // from zooming with (0,0) as the cetner. (scroller default behavior)
1649    _pan_geometry_get(wd, &px, &py);
1650    _viewport_size_get(wd, &vw, &vh);
1651    if ((vw > 0) && (vh > 0) && (ow > 0) && (oh > 0))
1652      {
1653         Evas_Coord xx, yy;
1654         double sx, sy;
1655         if (vw > ow) sx = 0.5;
1656         else         sx = (double)(-px + (vw / 2)) / ow;
1657         if (vh > oh) sy = 0.5;
1658         else         sy = (double)(-py + (vh / 2)) / oh;
1659
1660         if (sx > 1.0) sx = 1.0;
1661         if (sy > 1.0) sy = 1.0;
1662
1663         xx = (sx * wd->size.w) - (vw / 2);
1664         yy = (sy * wd->size.h) - (vh / 2);
1665         if (xx < 0) xx = 0;
1666         else if (xx > (wd->size.w - vw)) xx = wd->size.w - vw;
1667         if (yy < 0) yy = 0;
1668         else if (yy > (wd->size.h - vh)) yy = wd->size.h - vh;
1669         elm_smart_scroller_child_region_show(wd->scr, xx, yy, vw, vh);
1670      }
1671
1672    if (wd->zoom_timer) ecore_timer_del(wd->zoom_timer);
1673    else evas_object_smart_callback_call(wd->obj, SIG_ZOOM_START, NULL);
1674    wd->zoom_timer = ecore_timer_add(0.25, _zoom_timeout, wd);
1675    evas_object_smart_callback_call(wd->obj, SIG_ZOOM_CHANGE, NULL);
1676
1677    evas_object_smart_callback_call(wd->pan_smart, SIG_CHANGED, NULL);
1678    evas_object_smart_changed(wd->pan_smart);
1679 }
1680
1681 static Eina_Bool
1682 _zoom_anim(void *data)
1683 {
1684    Widget_Data *wd = data;
1685    EINA_SAFETY_ON_NULL_RETURN_VAL(wd, ECORE_CALLBACK_CANCEL);
1686
1687    if (wd->ani.cnt <= 0)
1688      {
1689         wd->zoom_animator = NULL;
1690         evas_object_smart_changed(wd->pan_smart);
1691         return ECORE_CALLBACK_CANCEL;
1692      }
1693    else
1694      {
1695         wd->ani.zoom += wd->ani.diff;
1696         wd->ani.cnt--;
1697         zoom_do(wd, wd->ani.zoom);
1698         return ECORE_CALLBACK_RENEW;
1699      }
1700 }
1701
1702 static void
1703 zoom_with_animation(Widget_Data *wd, double zoom, int cnt)
1704 {
1705    EINA_SAFETY_ON_NULL_RETURN(wd);
1706    if (cnt == 0) return;
1707
1708    wd->ani.cnt = cnt;
1709    wd->ani.zoom = wd->zoom;
1710    wd->ani.diff = (double)(zoom - wd->zoom) / cnt;
1711    if (wd->zoom_animator) ecore_animator_del(wd->zoom_animator);
1712    wd->zoom_animator = ecore_animator_add(_zoom_anim, wd);
1713 }
1714
1715 static void
1716 _sizing_eval(Widget_Data *wd)
1717 {
1718    EINA_SAFETY_ON_NULL_RETURN(wd);
1719
1720    Evas_Coord maxw = -1, maxh = -1;
1721
1722    evas_object_size_hint_max_get(wd->scr, &maxw, &maxh);
1723    evas_object_size_hint_max_set(wd->obj, maxw, maxh);
1724 }
1725
1726 static void
1727 _changed_size_hints(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
1728 {
1729    _sizing_eval(data);
1730 }
1731
1732 static Eina_Bool
1733 _scr_timeout(void *data)
1734 {
1735    EINA_SAFETY_ON_NULL_RETURN_VAL(data, ECORE_CALLBACK_CANCEL);
1736    Widget_Data *wd = data;
1737    _smooth_update(wd);
1738    wd->scr_timer = NULL;
1739    evas_object_smart_callback_call(wd->obj, SIG_SCROLL_DRAG_STOP, NULL);
1740    return ECORE_CALLBACK_CANCEL;
1741 }
1742
1743 static void
1744 _scr(void *data, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
1745 {
1746    EINA_SAFETY_ON_NULL_RETURN(data);
1747    Widget_Data *wd = data;
1748
1749    if (wd->scr_timer) ecore_timer_del(wd->scr_timer);
1750    else evas_object_smart_callback_call(wd->obj, SIG_SCROLL_DRAG_START, NULL);
1751    wd->scr_timer = ecore_timer_add(0.25, _scr_timeout, wd);
1752    evas_object_smart_callback_call(wd->obj, SIG_SCROLL, NULL);
1753 }
1754
1755 static void
1756 _scr_anim_start(void *data, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
1757 {
1758    EINA_SAFETY_ON_NULL_RETURN(data);
1759    Widget_Data *wd = data;
1760    evas_object_smart_callback_call(wd->obj, SIG_SCROLL_ANIM_START, NULL);
1761 }
1762
1763 static void
1764 _scr_anim_stop(void *data, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
1765 {
1766    EINA_SAFETY_ON_NULL_RETURN(data);
1767    Widget_Data *wd = data;
1768    evas_object_smart_callback_call(wd->obj, SIG_SCROLL_ANIM_STOP, NULL);
1769 }
1770
1771 static Eina_Bool
1772 _long_press(void *data)
1773 {
1774    EINA_SAFETY_ON_NULL_RETURN_VAL(data, ECORE_CALLBACK_CANCEL);
1775    Widget_Data *wd = data;
1776
1777    wd->long_timer = NULL;
1778    evas_object_smart_callback_call(wd->obj, SIG_LONGPRESSED, &wd->ev);
1779    return ECORE_CALLBACK_CANCEL;
1780 }
1781
1782 static void
1783 _mouse_down(void *data, Evas *evas __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info)
1784 {
1785    EINA_SAFETY_ON_NULL_RETURN(data);
1786    Widget_Data *wd = data;
1787    Evas_Event_Mouse_Down *ev = event_info;
1788
1789    if (ev->button != 1) return;
1790
1791    if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD) wd->on_hold = EINA_TRUE;
1792    else wd->on_hold = EINA_FALSE;
1793
1794    if (ev->flags & EVAS_BUTTON_DOUBLE_CLICK)
1795      evas_object_smart_callback_call(wd->obj, SIG_CLICKED_DOUBLE, ev);
1796    else evas_object_smart_callback_call(wd->obj, SIG_PRESS, ev);
1797
1798    if (wd->long_timer) ecore_timer_del(wd->long_timer);
1799    wd->ev = *ev;
1800    wd->long_timer = ecore_timer_add(_elm_config->longpress_timeout, _long_press, wd);
1801 }
1802
1803 static void
1804 _mouse_up(void *data, Evas *evas __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info)
1805 {
1806    EINA_SAFETY_ON_NULL_RETURN(data);
1807    Widget_Data *wd = data;
1808
1809    Evas_Event_Mouse_Up *ev = event_info;
1810    EINA_SAFETY_ON_NULL_RETURN(ev);
1811
1812    if (ev->button != 1) return;
1813    if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD) wd->on_hold = EINA_TRUE;
1814    else wd->on_hold = EINA_FALSE;
1815    if (wd->long_timer)
1816      {
1817         ecore_timer_del(wd->long_timer);
1818         wd->long_timer = NULL;
1819      }
1820    if (!wd->on_hold) evas_object_smart_callback_call(wd->obj, SIG_CLICKED, ev);
1821    wd->on_hold = EINA_FALSE;
1822 }
1823
1824 static void
1825 _mouse_wheel_cb(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info)
1826 {
1827    EINA_SAFETY_ON_NULL_RETURN(data);
1828    Widget_Data *wd = data;
1829
1830    if (!wd->paused)
1831      {
1832         Evas_Event_Mouse_Wheel *ev = (Evas_Event_Mouse_Wheel*) event_info;
1833         zoom_do(wd, wd->zoom_detail - ((double)ev->z / 10));
1834     }
1835 }
1836
1837 static void
1838 _pan_set(Evas_Object *obj, Evas_Coord x, Evas_Coord y)
1839 {
1840    Pan *sd = evas_object_smart_data_get(obj);
1841    EINA_SAFETY_ON_NULL_RETURN(sd);
1842    if ((x == sd->wd->pan_x) && (y == sd->wd->pan_y)) return;
1843
1844    sd->wd->pan_x = x;
1845    sd->wd->pan_y = y;
1846    evas_object_smart_changed(obj);
1847 }
1848
1849 static void
1850 _pan_get(Evas_Object *obj, Evas_Coord *x, Evas_Coord *y)
1851 {
1852    Pan *sd = evas_object_smart_data_get(obj);
1853    EINA_SAFETY_ON_NULL_RETURN(sd);
1854    if (x) *x = sd->wd->pan_x;
1855    if (y) *y = sd->wd->pan_y;
1856 }
1857
1858 static void
1859 _pan_max_get(Evas_Object *obj, Evas_Coord *x, Evas_Coord *y)
1860 {
1861    Pan *sd = evas_object_smart_data_get(obj);
1862    EINA_SAFETY_ON_NULL_RETURN(sd);
1863    Evas_Coord ow, oh;
1864    evas_object_geometry_get(obj, NULL, NULL, &ow, &oh);
1865    ow = sd->wd->size.w - ow;
1866    oh = sd->wd->size.h - oh;
1867    if (ow < 0) ow = 0;
1868    if (oh < 0) oh = 0;
1869    if (x) *x = ow;
1870    if (y) *y = oh;
1871 }
1872
1873 static void
1874 _pan_min_get(Evas_Object *obj __UNUSED__, Evas_Coord *x, Evas_Coord *y)
1875 {
1876    if (x) *x = 0;
1877    if (y) *y = 0;
1878 }
1879
1880 static void
1881 _pan_child_size_get(Evas_Object *obj, Evas_Coord *w, Evas_Coord *h)
1882 {
1883    Pan *sd = evas_object_smart_data_get(obj);
1884    EINA_SAFETY_ON_NULL_RETURN(sd);
1885    if (w) *w = sd->wd->size.w;
1886    if (h) *h = sd->wd->size.h;
1887 }
1888
1889 static void
1890 _pan_add(Evas_Object *obj)
1891 {
1892    Pan *sd;
1893    Evas_Object_Smart_Clipped_Data *cd;
1894    parent_sc.add(obj);
1895    cd = evas_object_smart_data_get(obj);
1896    EINA_SAFETY_ON_NULL_RETURN(cd);
1897    sd = ELM_NEW(Pan);
1898    sd->__clipped_data = *cd;
1899    free(cd);
1900    evas_object_smart_data_set(obj, sd);
1901 }
1902
1903 static void
1904 _pan_resize(Evas_Object *obj, Evas_Coord w __UNUSED__, Evas_Coord h __UNUSED__)
1905 {
1906    Pan *sd = evas_object_smart_data_get(obj);
1907    EINA_SAFETY_ON_NULL_RETURN(sd);
1908
1909    _sizing_eval(sd->wd);
1910    elm_map_zoom_mode_set(sd->wd->obj, sd->wd->mode);
1911    evas_object_smart_changed(obj);
1912 }
1913
1914 static void
1915 _pan_calculate(Evas_Object *obj)
1916 {
1917    Pan *sd = evas_object_smart_data_get(obj);
1918    EINA_SAFETY_ON_NULL_RETURN(sd);
1919
1920    Evas_Coord w, h;
1921    evas_object_geometry_get(sd->wd->pan_smart, NULL, NULL, &w, &h);
1922    if (w <= 0 || h <= 0) return;
1923
1924    _grid_place(sd->wd);
1925    _marker_place(sd->wd);
1926    _route_place(sd->wd);
1927    _track_place(sd->wd);
1928    _delayed_do(sd->wd);
1929 }
1930
1931 static void
1932 _pan_move(Evas_Object *obj, Evas_Coord x __UNUSED__, Evas_Coord y __UNUSED__)
1933 {
1934    EINA_SAFETY_ON_NULL_RETURN(obj);
1935    evas_object_smart_changed(obj);
1936 }
1937
1938 static void
1939 _hold_on(void *data, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
1940 {
1941    EINA_SAFETY_ON_NULL_RETURN(data);
1942    Widget_Data *wd = data;
1943    elm_smart_scroller_hold_set(wd->scr, 1);
1944 }
1945
1946 static void
1947 _hold_off(void *data, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
1948 {
1949    EINA_SAFETY_ON_NULL_RETURN(data);
1950    Widget_Data *wd = data;
1951    elm_smart_scroller_hold_set(wd->scr, 0);
1952 }
1953
1954 static void
1955 _freeze_on(void *data, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
1956 {
1957    EINA_SAFETY_ON_NULL_RETURN(data);
1958    Widget_Data *wd = data;
1959    elm_smart_scroller_freeze_set(wd->scr, 1);
1960 }
1961
1962 static void
1963 _freeze_off(void *data, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
1964 {
1965    EINA_SAFETY_ON_NULL_RETURN(data);
1966    Widget_Data *wd = data;
1967    elm_smart_scroller_freeze_set(wd->scr, 0);
1968 }
1969
1970 static void
1971 _on_focus_hook(void *data __UNUSED__, Evas_Object *obj)
1972 {
1973    ELM_CHECK_WIDTYPE(obj, widtype);
1974    Widget_Data *wd = elm_widget_data_get(obj);
1975    EINA_SAFETY_ON_NULL_RETURN(wd);
1976
1977    if (elm_widget_focus_get(obj))
1978      {
1979         edje_object_signal_emit(elm_smart_scroller_edje_object_get(wd->scr), "elm,action,focus", "elm");
1980         evas_object_focus_set(wd->obj, EINA_TRUE);
1981      }
1982    else
1983      {
1984         edje_object_signal_emit(elm_smart_scroller_edje_object_get(wd->scr), "elm,action,unfocus", "elm");
1985         evas_object_focus_set(wd->obj, EINA_FALSE);
1986      }
1987 }
1988
1989 static void
1990 _del_hook(Evas_Object *obj)
1991 {
1992    ELM_CHECK_WIDTYPE(obj, widtype);
1993    Widget_Data *wd = elm_widget_data_get(obj);
1994    EINA_SAFETY_ON_NULL_RETURN(wd);
1995
1996    Eina_List *l, *ll;
1997    Evas_Object *p;
1998    Path_Node *n;
1999    Path_Waypoint *w;
2000    Ecore_Event_Handler *h;
2001    Elm_Map_Route *r;
2002    Elm_Map_Name *na;
2003    Evas_Object *route;
2004    Elm_Map_Marker *marker;
2005    Elm_Map_Group_Class *group_clas;
2006    Elm_Map_Marker_Class *clas;
2007    Delayed_Data *dd;
2008    int idx = 0;
2009    Map_Sources_Tab *s;
2010
2011    EINA_LIST_FOREACH(wd->route, l, r)
2012      {
2013         EINA_LIST_FREE(r->path, p)
2014           {
2015              evas_object_del(p);
2016           }
2017
2018         EINA_LIST_FREE(r->waypoint, w)
2019           {
2020              if (w->point) eina_stringshare_del(w->point);
2021              free(w);
2022           }
2023
2024         EINA_LIST_FREE(r->nodes, n)
2025           {
2026              if (n->pos.address) eina_stringshare_del(n->pos.address);
2027              free(n);
2028           }
2029
2030         EINA_LIST_FREE(r->handlers, h)
2031           {
2032              ecore_event_handler_del(h);
2033           }
2034
2035         if (r->con_url) ecore_con_url_free(r->con_url);
2036         if (r->info.nodes) eina_stringshare_del(r->info.nodes);
2037         if (r->info.waypoints) eina_stringshare_del(r->info.waypoints);
2038      }
2039
2040    EINA_LIST_FREE(wd->names, na)
2041      {
2042         if (na->address) free(na->address);
2043         if (na->handler) ecore_event_handler_del(na->handler);
2044         if (na->ud.fname)
2045           {
2046              ecore_file_remove(na->ud.fname);
2047              free(na->ud.fname);
2048              na->ud.fname = NULL;
2049           }
2050      }
2051
2052    EINA_LIST_FREE(wd->track, route)
2053      {
2054         evas_object_del(route);
2055      }
2056
2057
2058    EINA_LIST_FOREACH_SAFE(wd->markers, l, ll, marker)
2059       elm_map_marker_remove(marker);
2060    eina_list_free(wd->markers);
2061
2062    EINA_LIST_FREE(wd->group_classes, group_clas)
2063      {
2064         eina_list_free(group_clas->markers);
2065         if (group_clas->style) eina_stringshare_del(group_clas->style);
2066         free(group_clas);
2067      }
2068
2069    EINA_LIST_FREE(wd->marker_classes, clas)
2070      {
2071         if (clas->style) eina_stringshare_del(clas->style);
2072         free(clas);
2073      }
2074
2075    if (wd->scr_timer) ecore_timer_del(wd->scr_timer);
2076    if (wd->long_timer) ecore_timer_del(wd->long_timer);
2077
2078    if (wd->delayed_jobs) EINA_LIST_FREE(wd->delayed_jobs, dd) free(dd);
2079
2080    if (wd->user_agent) eina_stringshare_del(wd->user_agent);
2081    if (wd->ua) eina_hash_free(wd->ua);
2082    if (wd->download_idler) ecore_idler_del(wd->download_idler);
2083    eina_list_free(wd->download_list);
2084
2085    if (wd->zoom_timer) ecore_timer_del(wd->zoom_timer);
2086    if (wd->zoom_animator) ecore_animator_del(wd->zoom_animator);
2087
2088    _grid_all_clear(wd);
2089
2090    for (idx = 0; wd->src_names[idx]; idx++)
2091       eina_stringshare_del(wd->src_names[idx]);
2092
2093    EINA_LIST_FREE(wd->srcs, s) free(s);
2094
2095    if (wd->map) evas_map_free(wd->map);
2096
2097    free(wd);
2098 }
2099
2100 static void
2101 _del_pre_hook(Evas_Object *obj)
2102 {
2103    ELM_CHECK_WIDTYPE(obj, widtype);
2104    Widget_Data *wd = elm_widget_data_get(obj);
2105    EINA_SAFETY_ON_NULL_RETURN(wd);
2106 }
2107
2108 static void
2109 _theme_hook(Evas_Object *obj)
2110 {
2111    ELM_CHECK_WIDTYPE(obj, widtype);
2112    Widget_Data *wd = elm_widget_data_get(obj);
2113    EINA_SAFETY_ON_NULL_RETURN(wd);
2114
2115    elm_smart_scroller_object_theme_set(obj, wd->scr, "map", "base", elm_widget_style_get(obj));
2116    _sizing_eval(wd);
2117 }
2118
2119 static Eina_Bool
2120 _event_hook(Evas_Object *obj, Evas_Object *src __UNUSED__, Evas_Callback_Type type, void *event_info)
2121 {
2122    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
2123    Widget_Data *wd = elm_widget_data_get(obj);
2124    EINA_SAFETY_ON_NULL_RETURN_VAL(wd, EINA_FALSE);
2125
2126    Evas_Coord x, y;
2127    Evas_Coord vh;
2128    Evas_Coord step_x, step_y, page_x, page_y;
2129
2130    if (type != EVAS_CALLBACK_KEY_DOWN) return EINA_FALSE;
2131    Evas_Event_Key_Down *ev = event_info;
2132    if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD) return EINA_FALSE;
2133
2134    elm_smart_scroller_child_pos_get(wd->scr, &x, &y);
2135    elm_smart_scroller_step_size_get(wd->scr, &step_x, &step_y);
2136    elm_smart_scroller_page_size_get(wd->scr, &page_x, &page_y);
2137    _viewport_size_get(wd, NULL, &vh);
2138
2139    if ((!strcmp(ev->keyname, "Left")) || (!strcmp(ev->keyname, "KP_Left")))
2140      {
2141         x -= step_x;
2142      }
2143    else if ((!strcmp(ev->keyname, "Right")) || (!strcmp(ev->keyname, "KP_Right")))
2144      {
2145         x += step_x;
2146      }
2147    else if ((!strcmp(ev->keyname, "Up"))  || (!strcmp(ev->keyname, "KP_Up")))
2148      {
2149         y -= step_y;
2150      }
2151    else if ((!strcmp(ev->keyname, "Down")) || (!strcmp(ev->keyname, "KP_Down")))
2152      {
2153         y += step_y;
2154      }
2155    else if ((!strcmp(ev->keyname, "Prior")) || (!strcmp(ev->keyname, "KP_Prior")))
2156      {
2157         if (page_y < 0)
2158           y -= -(page_y * vh) / 100;
2159         else
2160           y -= page_y;
2161      }
2162    else if ((!strcmp(ev->keyname, "Next")) || (!strcmp(ev->keyname, "KP_Next")))
2163      {
2164         if (page_y < 0)
2165           y += -(page_y * vh) / 100;
2166         else
2167           y += page_y;
2168      }
2169    else if (!strcmp(ev->keyname, "KP_Add"))
2170      {
2171         zoom_with_animation(wd, wd->zoom + 1, 10);
2172         return EINA_TRUE;
2173      }
2174    else if (!strcmp(ev->keyname, "KP_Subtract"))
2175      {
2176         zoom_with_animation(wd, wd->zoom - 1, 10);
2177         return EINA_TRUE;
2178      }
2179    else return EINA_FALSE;
2180
2181    ev->event_flags |= EVAS_EVENT_FLAG_ON_HOLD;
2182    elm_smart_scroller_child_pos_set(wd->scr, x, y);
2183
2184    return EINA_TRUE;
2185 }
2186
2187 static Eina_Bool
2188 cb_dump_name_attrs(void *data, const char *key, const char *value)
2189 {
2190    Name_Dump *dump = (Name_Dump*)data;
2191    if (!dump) return EINA_FALSE;
2192
2193    if (!strncmp(key, NOMINATIM_ATTR_LON, sizeof(NOMINATIM_ATTR_LON))) dump->lon = atof(value);
2194    else if (!strncmp(key, NOMINATIM_ATTR_LAT, sizeof(NOMINATIM_ATTR_LAT))) dump->lat = atof(value);
2195
2196    return EINA_TRUE;
2197 }
2198
2199 static Eina_Bool
2200 cb_route_dump(void *data, Eina_Simple_XML_Type type, const char *value, unsigned offset __UNUSED__, unsigned length)
2201 {
2202    Route_Dump *dump = data;
2203    if (!dump) return EINA_FALSE;
2204
2205    switch (type)
2206      {
2207       case EINA_SIMPLE_XML_OPEN:
2208       case EINA_SIMPLE_XML_OPEN_EMPTY:
2209         {
2210            const char *attrs;
2211
2212            attrs = eina_simple_xml_tag_attributes_find(value, length);
2213            if (!attrs)
2214              {
2215                 if (!strncmp(value, YOURS_DISTANCE, length)) dump->id = ROUTE_XML_DISTANCE;
2216                 else if (!strncmp(value, YOURS_DESCRIPTION, length)) dump->id = ROUTE_XML_DESCRIPTION;
2217                 else if (!strncmp(value, YOURS_COORDINATES, length)) dump->id = ROUTE_XML_COORDINATES;
2218                 else dump->id = ROUTE_XML_NONE;
2219              }
2220          }
2221         break;
2222       case EINA_SIMPLE_XML_DATA:
2223         {
2224            char *buf = malloc(length);
2225            if (!buf) return EINA_FALSE;
2226            snprintf(buf, length, "%s", value);
2227            if (dump->id == ROUTE_XML_DISTANCE) dump->distance = atof(buf);
2228            else if (!(dump->description) && (dump->id == ROUTE_XML_DESCRIPTION)) dump->description = strdup(buf);
2229            else if (dump->id == ROUTE_XML_COORDINATES) dump->coordinates = strdup(buf);
2230            free(buf);
2231         }
2232         break;
2233       default:
2234         break;
2235      }
2236
2237    return EINA_TRUE;
2238 }
2239
2240 static Eina_Bool
2241 cb_name_dump(void *data, Eina_Simple_XML_Type type, const char *value, unsigned offset __UNUSED__, unsigned length)
2242 {
2243    Name_Dump *dump = data;
2244    if (!dump) return EINA_FALSE;
2245
2246    switch (type)
2247      {
2248       case EINA_SIMPLE_XML_OPEN:
2249       case EINA_SIMPLE_XML_OPEN_EMPTY:
2250         {
2251            const char *attrs;
2252            attrs = eina_simple_xml_tag_attributes_find(value, length);
2253            if (attrs)
2254              {
2255                 if (!strncmp(value, NOMINATIM_RESULT, sizeof(NOMINATIM_RESULT) - 1)) dump->id = NAME_XML_NAME;
2256                 else dump->id = NAME_XML_NONE;
2257
2258                 eina_simple_xml_attributes_parse
2259                   (attrs, length - (attrs - value), cb_dump_name_attrs, dump);
2260              }
2261         }
2262         break;
2263       case EINA_SIMPLE_XML_DATA:
2264         {
2265            char *buf = malloc(length + 1);
2266            if (!buf) return EINA_FALSE;
2267            snprintf(buf, length + 1, "%s", value);
2268            if (dump->id == NAME_XML_NAME) dump->address = strdup(buf);
2269            free(buf);
2270         }
2271         break;
2272       default:
2273         break;
2274      }
2275
2276    return EINA_TRUE;
2277 }
2278
2279 static void
2280 _parse_kml(void *data)
2281 {
2282    Elm_Map_Route *r = (Elm_Map_Route*)data;
2283    if (!r || !r->ud.fname) return;
2284
2285    FILE *f;
2286    char **str;
2287    unsigned int ele, idx;
2288    double lon, lat;
2289    Evas_Object *path;
2290
2291    Route_Dump dump = {0, r->ud.fname, 0.0, NULL, NULL};
2292
2293    f = fopen(r->ud.fname, "rb");
2294    if (f)
2295      {
2296         long sz;
2297
2298         fseek(f, 0, SEEK_END);
2299         sz = ftell(f);
2300         if (sz > 0)
2301           {
2302              char *buf;
2303
2304              fseek(f, 0, SEEK_SET);
2305              buf = malloc(sz);
2306              if (buf)
2307                {
2308                   if (fread(buf, 1, sz, f))
2309                     {
2310                        eina_simple_xml_parse(buf, sz, EINA_TRUE, cb_route_dump, &dump);
2311                        free(buf);
2312                     }
2313                }
2314           }
2315         fclose(f);
2316
2317         if (dump.distance) r->info.distance = dump.distance;
2318         if (dump.description)
2319           {
2320              eina_stringshare_replace(&r->info.waypoints, dump.description);
2321              str = eina_str_split_full(dump.description, "\n", 0, &ele);
2322              r->info.waypoint_count = ele;
2323              for (idx = 0; idx < ele; idx++)
2324                {
2325                   Path_Waypoint *wp = ELM_NEW(Path_Waypoint);
2326                   if (wp)
2327                     {
2328                        wp->wd = r->wd;
2329                        wp->point = eina_stringshare_add(str[idx]);
2330                        DBG("%s", str[idx]);
2331                        r->waypoint = eina_list_append(r->waypoint, wp);
2332                     }
2333                }
2334              if (str && str[0])
2335                {
2336                   free(str[0]);
2337                   free(str);
2338                }
2339           }
2340         else WRN("description is not found !");
2341
2342         if (dump.coordinates)
2343           {
2344              eina_stringshare_replace(&r->info.nodes, dump.coordinates);
2345              str = eina_str_split_full(dump.coordinates, "\n", 0, &ele);
2346              r->info.node_count = ele;
2347              for (idx = 0; idx < ele; idx++)
2348                {
2349                   sscanf(str[idx], "%lf,%lf", &lon, &lat);
2350                   Path_Node *n = ELM_NEW(Path_Node);
2351                   if (n)
2352                     {
2353                        n->wd = r->wd;
2354                        n->pos.lon = lon;
2355                        n->pos.lat = lat;
2356                        n->idx = idx;
2357                        DBG("%lf:%lf", lon, lat);
2358                        n->pos.address = NULL;
2359                        r->nodes = eina_list_append(r->nodes, n);
2360
2361                        path = evas_object_polygon_add(evas_object_evas_get(r->wd->obj));
2362                        evas_object_smart_member_add(path, r->wd->pan_smart);
2363                        r->path = eina_list_append(r->path, path);
2364                     }
2365                }
2366              if (str && str[0])
2367                {
2368                   free(str[0]);
2369                   free(str);
2370                }
2371           }
2372      }
2373 }
2374
2375 static void
2376 _parse_name(void *data)
2377 {
2378    Elm_Map_Name *n = (Elm_Map_Name*)data;
2379    if (!n || !n->ud.fname) return;
2380
2381    FILE *f;
2382
2383    Name_Dump dump = {0, NULL, 0.0, 0.0};
2384
2385    f = fopen(n->ud.fname, "rb");
2386    if (f)
2387      {
2388         long sz;
2389
2390         fseek(f, 0, SEEK_END);
2391         sz = ftell(f);
2392         if (sz > 0)
2393           {
2394              char *buf;
2395
2396              fseek(f, 0, SEEK_SET);
2397              buf = malloc(sz);
2398              if (buf)
2399                {
2400                   if (fread(buf, 1, sz, f))
2401                     {
2402                        eina_simple_xml_parse(buf, sz, EINA_TRUE, cb_name_dump, &dump);
2403                        free(buf);
2404                     }
2405                }
2406           }
2407         fclose(f);
2408
2409         if (dump.address)
2410           {
2411              INF("[%lf : %lf] ADDRESS : %s", n->lon, n->lat, dump.address);
2412              n->address = strdup(dump.address);
2413           }
2414         n->lon = dump.lon;
2415         n->lat = dump.lat;
2416      }
2417 }
2418
2419 Grid *_get_current_grid(Widget_Data *wd)
2420 {
2421    EINA_SAFETY_ON_NULL_RETURN_VAL(wd, NULL);
2422    Eina_List *l;
2423    Grid *g = NULL, *ret = NULL;
2424    EINA_LIST_FOREACH(wd->grids, l, g)
2425      {
2426         if (wd->zoom == g->zoom)
2427           {
2428              ret = g;
2429              break;
2430           }
2431      }
2432    return ret;
2433 }
2434
2435 static Eina_Bool
2436 _route_complete_cb(void *data, int ev_type __UNUSED__, void *event)
2437 {
2438    Ecore_Con_Event_Url_Complete *ev = event;
2439    Elm_Map_Route *r = (Elm_Map_Route*)data;
2440    Widget_Data *wd = r->wd;
2441
2442    if ((!r) || (!ev)) return EINA_TRUE;
2443    Elm_Map_Route *rr = ecore_con_url_data_get(r->con_url);
2444    ecore_con_url_data_set(r->con_url, NULL);
2445    if (r!=rr) return EINA_TRUE;
2446
2447    if (r->ud.fd) fclose(r->ud.fd);
2448    _parse_kml(r);
2449
2450    _route_place(wd);
2451
2452    edje_object_signal_emit(elm_smart_scroller_edje_object_get(wd->scr),
2453                            "elm,state,busy,stop", "elm");
2454    evas_object_smart_callback_call(wd->obj, SIG_ROUTE_LOADED, NULL);
2455    return EINA_TRUE;
2456 }
2457
2458 static Eina_Bool
2459 _name_complete_cb(void *data, int ev_type __UNUSED__, void *event)
2460 {
2461    Ecore_Con_Event_Url_Complete *ev = event;
2462    Elm_Map_Name *n = (Elm_Map_Name*)data;
2463    Widget_Data *wd = n->wd;
2464
2465    if ((!n) || (!ev)) return EINA_TRUE;
2466    Elm_Map_Name *nn = ecore_con_url_data_get(n->con_url);
2467    ecore_con_url_data_set(n->con_url, NULL);
2468    if (n!=nn) return EINA_TRUE;
2469
2470    if (n->ud.fd) fclose(n->ud.fd);
2471    _parse_name(n);
2472
2473    edje_object_signal_emit(elm_smart_scroller_edje_object_get(wd->scr),
2474                            "elm,state,busy,stop", "elm");
2475    evas_object_smart_callback_call(wd->obj, SIG_NAME_LOADED, NULL);
2476    return EINA_TRUE;
2477 }
2478
2479 static Elm_Map_Name *
2480 _utils_convert_name(const Evas_Object *obj, int method, char *address, double lon, double lat)
2481 {
2482    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
2483    Widget_Data *wd = elm_widget_data_get(obj);
2484    char buf[PATH_MAX];
2485    char *source;
2486    int fd;
2487
2488    if ((!wd) || (!wd->src)) return NULL;
2489    Elm_Map_Name *name = ELM_NEW(Elm_Map_Name);
2490
2491    snprintf(buf, sizeof(buf), DEST_NAME_XML_FILE);
2492    fd = mkstemp(buf);
2493    if (fd < 0)
2494      {
2495         free(name);
2496         return NULL;
2497      }
2498
2499    name->con_url = ecore_con_url_new(NULL);
2500    name->ud.fname = strdup(buf);
2501    INF("xml file : %s", name->ud.fname);
2502
2503    name->ud.fd = fdopen(fd, "w+");
2504    if ((!name->con_url) || (!name->ud.fd))
2505      {
2506         ecore_con_url_free(name->con_url);
2507         free(name);
2508         return NULL;
2509      }
2510
2511    name->wd = wd;
2512    name->handler = ecore_event_handler_add (ECORE_CON_EVENT_URL_COMPLETE, _name_complete_cb, name);
2513    name->method = method;
2514    if (method == ELM_MAP_NAME_METHOD_SEARCH) name->address = strdup(address);
2515    else if (method == ELM_MAP_NAME_METHOD_REVERSE) name->address = NULL;
2516    name->lon = lon;
2517    name->lat = lat;
2518
2519    source = wd->src->name_url_cb(wd->obj, method, address, lon, lat);
2520    INF("name url = %s", source);
2521
2522    wd->names = eina_list_append(wd->names, name);
2523    ecore_con_url_url_set(name->con_url, source);
2524    ecore_con_url_fd_set(name->con_url, fileno(name->ud.fd));
2525    ecore_con_url_data_set(name->con_url, name);
2526
2527    edje_object_signal_emit(elm_smart_scroller_edje_object_get(wd->scr),
2528                            "elm,state,busy,start", "elm");
2529    evas_object_smart_callback_call(wd->obj, SIG_NAME_LOAD, NULL);
2530    ecore_con_url_get(name->con_url);
2531    if (source) free(source);
2532
2533    return name;
2534
2535 }
2536
2537 static Evas_Event_Flags
2538 _pinch_zoom_start_cb(void *data, void *event_info __UNUSED__)
2539 {
2540    EINA_SAFETY_ON_NULL_RETURN_VAL(data, EVAS_EVENT_FLAG_NONE);
2541    Widget_Data *wd = data;
2542
2543    wd->pinch_zoom = wd->zoom_detail;
2544    return EVAS_EVENT_FLAG_NONE;
2545 }
2546
2547 static Evas_Event_Flags
2548 _pinch_zoom_cb(void *data, void *event_info)
2549 {
2550    Widget_Data *wd = data;
2551    EINA_SAFETY_ON_NULL_RETURN_VAL(wd, EVAS_EVENT_FLAG_NONE);
2552
2553    if (!wd->paused)
2554      {
2555         Elm_Gesture_Zoom_Info *ei = event_info;
2556         zoom_do(wd, wd->pinch_zoom + ei->zoom - 1);
2557      }
2558    return EVAS_EVENT_FLAG_NONE;
2559 }
2560
2561 static Evas_Event_Flags
2562 _pinch_rotate_cb(void *data, void *event_info)
2563 {
2564    Widget_Data *wd = data;
2565    EINA_SAFETY_ON_NULL_RETURN_VAL(wd, EVAS_EVENT_FLAG_NONE);
2566
2567    if (!wd->paused)
2568      {
2569         int x, y, w, h;
2570         Elm_Gesture_Rotate_Info *ei = event_info;
2571         evas_object_geometry_get(wd->obj, &x, &y, &w, &h);
2572
2573         wd->rotate.d = wd->rotate.a + ei->angle - ei->base_angle;
2574         wd->rotate.cx = x + ((double)w * 0.5);
2575         wd->rotate.cy = y + ((double)h * 0.5);
2576
2577         evas_object_smart_changed(wd->pan_smart);
2578      }
2579    return EVAS_EVENT_FLAG_NONE;
2580 }
2581
2582 static Evas_Event_Flags
2583 _pinch_rotate_end_cb(void *data, void *event_info __UNUSED__)
2584 {
2585    Widget_Data *wd = data;
2586    EINA_SAFETY_ON_NULL_RETURN_VAL(wd, EVAS_EVENT_FLAG_NONE);
2587
2588    wd->rotate.a = wd->rotate.d;
2589
2590    return EVAS_EVENT_FLAG_NONE;
2591 }
2592
2593 static void
2594 _zoom_mode_set(void *data)
2595 {
2596    EINA_SAFETY_ON_NULL_RETURN(data);
2597    Delayed_Data *dd = data;
2598
2599    dd->wd->mode = dd->mode;
2600    if (dd->mode != ELM_MAP_ZOOM_MODE_MANUAL)
2601      {
2602         Evas_Coord w, h;
2603         Evas_Coord vw, vh;
2604
2605         double zoom;
2606         double diff;
2607
2608         w = dd->wd->size.w;
2609         h = dd->wd->size.h;
2610         zoom = dd->wd->zoom_detail;
2611         _viewport_size_get(dd->wd, &vw, &vh);
2612
2613         if (dd->mode == ELM_MAP_ZOOM_MODE_AUTO_FIT)
2614           {
2615              if ((w < vw) && (h < vh))
2616                {
2617                   diff = 0.01;
2618                   while ((w < vw) && (h < vh))
2619                   {
2620                      zoom += diff;
2621                      w = pow(2.0, zoom) * dd->wd->tsize;
2622                      h = pow(2.0, zoom) * dd->wd->tsize;
2623                   }
2624                }
2625              else
2626                {
2627                   diff = -0.01;
2628                   while ((w > vw) || (h > vh))
2629                   {
2630                      zoom += diff;
2631                      w = pow(2.0, zoom) * dd->wd->tsize;
2632                      h = pow(2.0, zoom) * dd->wd->tsize;
2633                   }
2634                }
2635
2636           }
2637         else if (dd->mode == ELM_MAP_ZOOM_MODE_AUTO_FILL)
2638           {
2639              if ((w < vw) || (h < vh))
2640                {
2641                   diff = 0.01;
2642                   while ((w < vw) || (h < vh))
2643                   {
2644                      zoom += diff;
2645                      w = pow(2.0, zoom) * dd->wd->tsize;
2646                      h = pow(2.0, zoom) * dd->wd->tsize;
2647                   }
2648                }
2649              else
2650                {
2651                   diff = -0.01;
2652                   while ((w > vw) && (h > vh))
2653                   {
2654                      zoom += diff;
2655                      w = pow(2.0, zoom) * dd->wd->tsize;
2656                      h = pow(2.0, zoom) * dd->wd->tsize;
2657                   }
2658                }
2659           }
2660        zoom_with_animation(dd->wd, zoom, 10);
2661      }
2662 }
2663
2664 static void
2665 _zoom_set(void *data)
2666 {
2667    EINA_SAFETY_ON_NULL_RETURN(data);
2668    Delayed_Data *dd = data;
2669
2670    if (dd->wd->paused) zoom_do(dd->wd, dd->zoom);
2671    else zoom_with_animation(dd->wd, dd->zoom, 10);
2672    evas_object_smart_changed(dd->wd->pan_smart);
2673 }
2674
2675 static void
2676 _region_bring_in(void *data)
2677 {
2678    EINA_SAFETY_ON_NULL_RETURN(data);
2679    Delayed_Data *dd = data;
2680    int x, y, w, h;
2681
2682    elm_map_utils_convert_geo_into_coord(dd->wd->obj, dd->lon, dd->lat,
2683                                         dd->wd->size.w, &x, &y);
2684    _viewport_size_get(dd->wd, &w, &h);
2685    x = x - (w / 2);
2686    y = y - (h / 2);
2687    elm_smart_scroller_region_bring_in(dd->wd->scr, x, y, w, h);
2688    evas_object_smart_changed(dd->wd->pan_smart);
2689 }
2690
2691 static void
2692 _region_show(void *data)
2693 {
2694    EINA_SAFETY_ON_NULL_RETURN(data);
2695    Delayed_Data *dd = data;
2696    int x, y, w, h;
2697
2698    elm_map_utils_convert_geo_into_coord(dd->wd->obj, dd->lon, dd->lat,
2699                                         dd->wd->size.w, &x, &y);
2700    _viewport_size_get(dd->wd, &w, &h);
2701    x = x - (w / 2);
2702    y = y - (h / 2);
2703    elm_smart_scroller_child_region_show(dd->wd->scr, x, y, w, h);
2704    evas_object_smart_changed(dd->wd->pan_smart);
2705 }
2706
2707 static void
2708 _marker_list_show(void *data)
2709 {
2710    EINA_SAFETY_ON_NULL_RETURN(data);
2711    Delayed_Data *dd = data;
2712    int zoom;
2713    double max_lon = -180, min_lon = 180;
2714    double max_lat = -90, min_lat = 90;
2715    Evas_Coord vw, vh;
2716    Elm_Map_Marker *marker;
2717
2718    EINA_LIST_FREE(dd->markers, marker)
2719      {
2720         if (marker->longitude > max_lon) max_lon = marker->longitude;
2721         if (marker->longitude < min_lon) min_lon = marker->longitude;
2722         if (marker->latitude > max_lat) max_lat = marker->latitude;
2723         if (marker->latitude < min_lat) min_lat = marker->latitude;
2724      }
2725    dd->lon = (max_lon + min_lon) / 2;
2726    dd->lat = (max_lat + min_lat) / 2;
2727
2728    zoom = dd->wd->src->zoom_min;
2729    _viewport_size_get(dd->wd, &vw, &vh);
2730    while (zoom <= dd->wd->src->zoom_max)
2731      {
2732         Evas_Coord size, max_x, max_y, min_x, min_y;
2733         size = pow(2.0, zoom) * dd->wd->tsize;
2734         elm_map_utils_convert_geo_into_coord(dd->wd->obj, min_lon, max_lat, size, &min_x, &max_y);
2735         elm_map_utils_convert_geo_into_coord(dd->wd->obj, max_lon, min_lat, size, &max_x, &min_y);
2736         if ((max_x - min_x) > vw || (max_y - min_y) > vh) break;
2737         zoom++;
2738      }
2739    zoom--;
2740
2741    zoom_do(dd->wd, zoom);
2742    _region_show(dd);
2743    evas_object_smart_changed(dd->wd->pan_smart);
2744 }
2745
2746 static char *
2747 _mapnik_url_cb(Evas_Object *obj __UNUSED__, int x, int y, int zoom)
2748 {
2749    char buf[PATH_MAX];
2750    // ((x+y+zoom)%3)+'a' is requesting map images from distributed tile servers (eg., a, b, c)
2751    snprintf(buf, sizeof(buf), "http://%c.tile.openstreetmap.org/%d/%d/%d.png",
2752             ((x + y + zoom) % 3) + 'a', zoom, x, y);
2753    return strdup(buf);
2754 }
2755
2756 static char *
2757 _osmarender_url_cb(Evas_Object *obj __UNUSED__, int x, int y, int zoom)
2758 {
2759    char buf[PATH_MAX];
2760    snprintf(buf, sizeof(buf),
2761             "http://%c.tah.openstreetmap.org/Tiles/tile/%d/%d/%d.png",
2762             ((x + y + zoom) % 3) + 'a', zoom, x, y);
2763    return strdup(buf);
2764 }
2765
2766 static char *
2767 _cyclemap_url_cb(Evas_Object *obj __UNUSED__, int x, int y, int zoom)
2768 {
2769    char buf[PATH_MAX];
2770    snprintf(buf, sizeof(buf),
2771             "http://%c.tile.opencyclemap.org/cycle/%d/%d/%d.png",
2772             (( x + y + zoom) % 3) + 'a', zoom, x, y);
2773    return strdup(buf);
2774 }
2775
2776 static char *
2777 _mapquest_url_cb(Evas_Object *obj __UNUSED__, int x, int y, int zoom)
2778 {
2779    char buf[PATH_MAX];
2780    snprintf(buf, sizeof(buf),
2781             "http://otile%d.mqcdn.com/tiles/1.0.0/osm/%d/%d/%d.png",
2782             ((x + y + zoom) % 4) + 1, zoom, x, y);
2783    return strdup(buf);
2784 }
2785
2786 static char *
2787 _mapquest_aerial_url_cb(Evas_Object *obj __UNUSED__, int x, int y, int zoom)
2788 {
2789    char buf[PATH_MAX];
2790    snprintf(buf, sizeof(buf), "http://oatile%d.mqcdn.com/naip/%d/%d/%d.png",
2791            ((x + y + zoom) % 4) + 1, zoom, x, y);
2792    return strdup(buf);
2793 }
2794
2795 static char *_yours_url_cb(Evas_Object *obj __UNUSED__, char *type_name, int method, double flon, double flat, double tlon, double tlat)
2796 {
2797    char buf[PATH_MAX];
2798    snprintf(buf, sizeof(buf),
2799             "%s?flat=%lf&flon=%lf&tlat=%lf&tlon=%lf&v=%s&fast=%d&instructions=1",
2800             ROUTE_YOURS_URL, flat, flon, tlat, tlon, type_name, method);
2801
2802    return strdup(buf);
2803 }
2804
2805 // TODO: fix monav api
2806 /*
2807 static char *_monav_url_cb(Evas_Object *obj __UNUSED__, char *type_name, int method, double flon, double flat, double tlon, double tlat)
2808 {
2809    char buf[PATH_MAX];
2810    snprintf(buf, sizeof(buf),
2811             "%s?flat=%f&flon=%f&tlat=%f&tlon=%f&v=%s&fast=%d&instructions=1",
2812             ROUTE_MONAV_URL, flat, flon, tlat, tlon, type_name, method);
2813
2814    return strdup(buf);
2815 }
2816 */
2817
2818 // TODO: fix ors api
2819 /*
2820 static char *_ors_url_cb(Evas_Object *obj __UNUSED__, char *type_name, int method, double flon, double flat, double tlon, double tlat)
2821 {
2822    char buf[PATH_MAX];
2823    snprintf(buf, sizeof(buf),
2824             "%s?flat=%f&flon=%f&tlat=%f&tlon=%f&v=%s&fast=%d&instructions=1",
2825             ROUTE_ORS_URL, flat, flon, tlat, tlon, type_name, method);
2826
2827    return strdup(buf);
2828 }
2829 */
2830
2831 static char *
2832 _nominatim_url_cb(Evas_Object *obj, int method, char *name, double lon, double lat)
2833 {
2834    ELM_CHECK_WIDTYPE(obj, widtype) strdup("");
2835    Widget_Data *wd = elm_widget_data_get(obj);
2836    EINA_SAFETY_ON_NULL_RETURN_VAL(wd, strdup(""));
2837
2838    char **str;
2839    unsigned int ele, idx;
2840    char search_url[PATH_MAX];
2841    char buf[PATH_MAX];
2842
2843    if (method == ELM_MAP_NAME_METHOD_SEARCH)
2844      {
2845         search_url[0] = '\0';
2846         str = eina_str_split_full(name, " ", 0, &ele);
2847         for (idx = 0; idx < ele; idx++)
2848           {
2849              eina_strlcat(search_url, str[idx], sizeof(search_url));
2850              if (!(idx == (ele-1)))
2851                 eina_strlcat(search_url, "+", sizeof(search_url));
2852           }
2853         snprintf(buf, sizeof(buf),
2854                  "%s/search?q=%s&format=xml&polygon=0&addressdetails=0",
2855                  NAME_NOMINATIM_URL, search_url);
2856
2857         if (str && str[0])
2858           {
2859              free(str[0]);
2860              free(str);
2861           }
2862      }
2863    else if (method == ELM_MAP_NAME_METHOD_REVERSE)
2864       snprintf(buf, sizeof(buf),
2865                "%s/reverse?format=xml&lat=%lf&lon=%lf&zoom=%d&addressdetails=0",
2866                NAME_NOMINATIM_URL, lat, lon, (int)wd->zoom);
2867    else strcpy(buf, "");
2868
2869    return strdup(buf);
2870 }
2871
2872 #endif
2873
2874 EAPI Evas_Object *
2875 elm_map_add(Evas_Object *parent)
2876 {
2877 #ifdef HAVE_ELEMENTARY_ECORE_CON
2878    Evas *e;
2879    Widget_Data *wd;
2880    Evas_Object *obj;
2881    Evas_Coord minw, minh;
2882
2883    ELM_WIDGET_STANDARD_SETUP(wd, Widget_Data, parent, e, obj, NULL);
2884    ELM_SET_WIDTYPE(widtype, "map");
2885    elm_widget_type_set(obj, "map");
2886    elm_widget_sub_object_add(parent, obj);
2887    elm_widget_data_set(obj, wd);
2888    elm_widget_can_focus_set(obj, EINA_TRUE);
2889    elm_widget_on_focus_hook_set(obj, _on_focus_hook, NULL);
2890    elm_widget_del_hook_set(obj, _del_hook);
2891    elm_widget_del_pre_hook_set(obj, _del_pre_hook);
2892    elm_widget_theme_hook_set(obj, _theme_hook);
2893    elm_widget_event_hook_set(obj, _event_hook);
2894    evas_object_smart_callback_add(obj, "scroll-hold-on", _hold_on, wd);
2895    evas_object_smart_callback_add(obj, "scroll-hold-off", _hold_off, wd);
2896    evas_object_smart_callback_add(obj, "scroll-freeze-on", _freeze_on, wd);
2897    evas_object_smart_callback_add(obj, "scroll-freeze-off", _freeze_off, wd);
2898    evas_object_event_callback_add(obj, EVAS_CALLBACK_MOUSE_DOWN,
2899                                   _mouse_down, wd);
2900    evas_object_event_callback_add(obj, EVAS_CALLBACK_MOUSE_UP,
2901                                   _mouse_up, wd);
2902    evas_object_event_callback_add(obj, EVAS_CALLBACK_MOUSE_WHEEL,
2903                                   _mouse_wheel_cb,wd);
2904    wd->obj = obj;
2905
2906    wd->scr = elm_smart_scroller_add(e);
2907    elm_widget_sub_object_add(obj, wd->scr);
2908    elm_smart_scroller_widget_set(wd->scr, obj);
2909    elm_smart_scroller_object_theme_set(obj, wd->scr, "map", "base", "default");
2910    elm_widget_resize_object_set(obj, wd->scr);
2911    elm_smart_scroller_wheel_disabled_set(wd->scr, EINA_TRUE);
2912    elm_smart_scroller_bounce_allow_set(wd->scr,
2913                                        _elm_config->thumbscroll_bounce_enable,
2914                                        _elm_config->thumbscroll_bounce_enable);
2915    evas_object_event_callback_add(wd->scr, EVAS_CALLBACK_CHANGED_SIZE_HINTS,
2916                                   _changed_size_hints, wd);
2917    evas_object_smart_callback_add(wd->scr, "scroll", _scr, wd);
2918    evas_object_smart_callback_add(wd->scr, "drag", _scr, wd);
2919    evas_object_smart_callback_add(wd->scr, "animate,start", _scr_anim_start, wd);
2920    evas_object_smart_callback_add(wd->scr, "animate,stop", _scr_anim_stop, wd);
2921
2922    if (!smart)
2923      {
2924         evas_object_smart_clipped_smart_set(&parent_sc);
2925         sc = parent_sc;
2926         sc.name = "elm_map_pan";
2927         sc.version = EVAS_SMART_CLASS_VERSION;
2928         sc.add = _pan_add;
2929         sc.resize = _pan_resize;
2930         sc.move = _pan_move;
2931         sc.calculate = _pan_calculate;
2932         smart = evas_smart_class_new(&sc);
2933      }
2934    if (smart)
2935      {
2936         Pan *pan;
2937         wd->pan_smart = evas_object_smart_add(e, smart);
2938         pan = evas_object_smart_data_get(wd->pan_smart);
2939         pan->wd = wd;
2940      }
2941    elm_widget_sub_object_add(obj, wd->pan_smart);
2942
2943    elm_smart_scroller_extern_pan_set(wd->scr, wd->pan_smart,
2944                                      _pan_set, _pan_get, _pan_max_get,
2945                                      _pan_min_get, _pan_child_size_get);
2946    edje_object_size_min_calc(elm_smart_scroller_edje_object_get(wd->scr),
2947                              &minw, &minh);
2948    evas_object_size_hint_min_set(obj, minw, minh);
2949
2950    wd->ges = elm_gesture_layer_add(obj);
2951    if (!wd->ges) ERR("elm_gesture_layer_add() failed");
2952    elm_gesture_layer_attach(wd->ges, obj);
2953    elm_gesture_layer_cb_set(wd->ges, ELM_GESTURE_ZOOM, ELM_GESTURE_STATE_START,
2954                             _pinch_zoom_start_cb, wd);
2955    elm_gesture_layer_cb_set(wd->ges, ELM_GESTURE_ZOOM, ELM_GESTURE_STATE_MOVE,
2956                             _pinch_zoom_cb, wd);
2957    elm_gesture_layer_cb_set(wd->ges, ELM_GESTURE_ROTATE, ELM_GESTURE_STATE_MOVE,
2958                             _pinch_rotate_cb, wd);
2959    elm_gesture_layer_cb_set(wd->ges, ELM_GESTURE_ROTATE, ELM_GESTURE_STATE_END,
2960                             _pinch_rotate_end_cb, wd);
2961    elm_gesture_layer_cb_set(wd->ges, ELM_GESTURE_ROTATE, ELM_GESTURE_STATE_ABORT,
2962                             _pinch_rotate_end_cb, wd);
2963
2964    wd->sep_maps_markers = evas_object_rectangle_add(evas_object_evas_get(obj));
2965    elm_widget_sub_object_add(obj, wd->sep_maps_markers);
2966    evas_object_smart_member_add(wd->sep_maps_markers, wd->pan_smart);
2967
2968    wd->map = evas_map_new(EVAS_MAP_POINT);
2969
2970    source_init(wd);
2971    wd->tsize = DEFAULT_TILE_SIZE; // FIXME: It should be hard-coded ? or can get from provider?
2972
2973    wd->id = ((int)getpid() << 16) | idnum;
2974    idnum++;
2975    _grid_all_create(wd);
2976
2977    zoom_do(wd, 0);
2978
2979    wd->mode = ELM_MAP_ZOOM_MODE_MANUAL;
2980    wd->markers_max_num = MARER_MAX_NUMBER;
2981
2982    // TODO: convert Elementary to subclassing of Evas_Smart_Class
2983    // TODO: and save some bytes, making descriptions per-class and not instance!
2984    evas_object_smart_callbacks_descriptions_set(obj, _signals);
2985
2986    if (!ecore_file_download_protocol_available("http://"))
2987       ERR("Ecore must be built with curl support for the map widget!");
2988
2989    return obj;
2990 #else
2991    (void) parent;
2992    return NULL;
2993 #endif
2994 }
2995
2996 EAPI void
2997 elm_map_zoom_set(Evas_Object *obj, int zoom)
2998 {
2999 #ifdef HAVE_ELEMENTARY_ECORE_CON
3000    ELM_CHECK_WIDTYPE(obj, widtype);
3001    Widget_Data *wd = elm_widget_data_get(obj);
3002    EINA_SAFETY_ON_NULL_RETURN(wd);
3003    EINA_SAFETY_ON_NULL_RETURN(wd->src);
3004
3005    if (wd->mode != ELM_MAP_ZOOM_MODE_MANUAL) return;
3006    if (zoom < 0) zoom = 0;
3007    if (wd->zoom == zoom) return;
3008    if (zoom > wd->src->zoom_max) zoom = wd->src->zoom_max;
3009    if (zoom < wd->src->zoom_min) zoom = wd->src->zoom_min;
3010
3011    Delayed_Data *data = ELM_NEW(Delayed_Data);
3012    data->func = _zoom_set;
3013    data->wd = wd;
3014    data->zoom = zoom;
3015    data->wd->delayed_jobs = eina_list_append(data->wd->delayed_jobs, data);
3016    evas_object_smart_changed(data->wd->pan_smart);
3017 #else
3018    (void) obj;
3019    (void) zoom;
3020 #endif
3021 }
3022
3023 EAPI int
3024 elm_map_zoom_get(const Evas_Object *obj)
3025 {
3026 #ifdef HAVE_ELEMENTARY_ECORE_CON
3027    ELM_CHECK_WIDTYPE(obj, widtype) 0;
3028    Widget_Data *wd = elm_widget_data_get(obj);
3029
3030    EINA_SAFETY_ON_NULL_RETURN_VAL(wd, 0);
3031    return wd->zoom;
3032 #else
3033    (void) obj;
3034    return 0;
3035 #endif
3036 }
3037
3038 EAPI void
3039 elm_map_zoom_mode_set(Evas_Object *obj, Elm_Map_Zoom_Mode mode)
3040 {
3041 #ifdef HAVE_ELEMENTARY_ECORE_CON
3042    ELM_CHECK_WIDTYPE(obj, widtype);
3043    Widget_Data *wd = elm_widget_data_get(obj);
3044    EINA_SAFETY_ON_NULL_RETURN(wd);
3045
3046    Delayed_Data *data = ELM_NEW(Delayed_Data);
3047    data->mode = mode;
3048    data->func = _zoom_mode_set;
3049    data->wd = wd;
3050    data->wd->delayed_jobs = eina_list_append(data->wd->delayed_jobs, data);
3051    evas_object_smart_changed(data->wd->pan_smart);
3052 #else
3053    (void) obj;
3054    (void) mode;
3055 #endif
3056 }
3057
3058 EAPI Elm_Map_Zoom_Mode
3059 elm_map_zoom_mode_get(const Evas_Object *obj)
3060 {
3061 #ifdef HAVE_ELEMENTARY_ECORE_CON
3062    ELM_CHECK_WIDTYPE(obj, widtype) ELM_MAP_ZOOM_MODE_MANUAL;
3063    Widget_Data *wd = elm_widget_data_get(obj);
3064    EINA_SAFETY_ON_NULL_RETURN_VAL(wd, ELM_MAP_ZOOM_MODE_MANUAL);
3065
3066    return wd->mode;
3067 #else
3068    (void) obj;
3069    return ELM_MAP_ZOOM_MODE_MANUAL;
3070 #endif
3071 }
3072
3073 EAPI void
3074 elm_map_geo_region_bring_in(Evas_Object *obj, double lon, double lat)
3075 {
3076 #ifdef HAVE_ELEMENTARY_ECORE_CON
3077    ELM_CHECK_WIDTYPE(obj, widtype);
3078    Widget_Data *wd = elm_widget_data_get(obj);
3079
3080    Delayed_Data *data = ELM_NEW(Delayed_Data);
3081    data->func = _region_bring_in;
3082    data->wd = wd;
3083    data->lon = lon;
3084    data->lat = lat;
3085    data->wd->delayed_jobs = eina_list_append(data->wd->delayed_jobs, data);
3086    evas_object_smart_changed(data->wd->pan_smart);
3087 #else
3088    (void) obj;
3089    (void) lon;
3090    (void) lat;
3091 #endif
3092 }
3093
3094 EAPI void
3095 elm_map_geo_region_show(Evas_Object *obj, double lon, double lat)
3096 {
3097 #ifdef HAVE_ELEMENTARY_ECORE_CON
3098    ELM_CHECK_WIDTYPE(obj, widtype);
3099    Widget_Data *wd = elm_widget_data_get(obj);
3100
3101    Delayed_Data *data = ELM_NEW(Delayed_Data);
3102    data->func = _region_show;
3103    data->wd = wd;
3104    data->lon = lon;
3105    data->lat = lat;
3106    data->wd->delayed_jobs = eina_list_append(data->wd->delayed_jobs, data);
3107    evas_object_smart_changed(data->wd->pan_smart);
3108 #else
3109    (void) obj;
3110    (void) lon;
3111    (void) lat;
3112 #endif
3113 }
3114
3115 EAPI void
3116 elm_map_geo_region_get(const Evas_Object *obj, double *lon, double *lat)
3117 {
3118 #ifdef HAVE_ELEMENTARY_ECORE_CON
3119    ELM_CHECK_WIDTYPE(obj, widtype);
3120    Widget_Data *wd = elm_widget_data_get(obj);
3121    EINA_SAFETY_ON_NULL_RETURN(wd);
3122
3123    double tlon, tlat;
3124    Evas_Coord px, py, vw, vh;
3125
3126    _pan_geometry_get(wd, &px, &py);
3127    _viewport_size_get(wd, &vw, &vh);
3128    elm_map_utils_convert_coord_into_geo(obj, vw/2 - px, vh/2 -py, wd->size.w,
3129                                         &tlon, &tlat);
3130    if (lon) *lon = tlon;
3131    if (lat) *lat = tlat;
3132 #else
3133    (void) obj;
3134    (void) lon;
3135    (void) lat;
3136 #endif
3137 }
3138
3139 EAPI void
3140 elm_map_paused_set(Evas_Object *obj, Eina_Bool paused)
3141 {
3142 #ifdef HAVE_ELEMENTARY_ECORE_CON
3143    ELM_CHECK_WIDTYPE(obj, widtype);
3144    Widget_Data *wd = elm_widget_data_get(obj);
3145    EINA_SAFETY_ON_NULL_RETURN(wd);
3146
3147    if (wd->paused == !!paused) return;
3148    wd->paused = !!paused;
3149    if (wd->paused)
3150      {
3151         if (wd->zoom_animator)
3152           {
3153              if (wd->zoom_animator) ecore_animator_del(wd->zoom_animator);
3154              wd->zoom_animator = NULL;
3155              zoom_do(wd, wd->zoom);
3156           }
3157         edje_object_signal_emit(elm_smart_scroller_edje_object_get(wd->scr),
3158                                 "elm,state,busy,stop", "elm");
3159      }
3160    else
3161      {
3162         if (wd->download_num >= 1)
3163            edje_object_signal_emit(elm_smart_scroller_edje_object_get(wd->scr),
3164                                    "elm,state,busy,start", "elm");
3165      }
3166 #else
3167    (void) obj;
3168    (void) paused;
3169 #endif
3170 }
3171
3172 EAPI void
3173 elm_map_paused_markers_set(Evas_Object *obj, Eina_Bool paused)
3174 {
3175 #ifdef HAVE_ELEMENTARY_ECORE_CON
3176    ELM_CHECK_WIDTYPE(obj, widtype);
3177    Widget_Data *wd = elm_widget_data_get(obj);
3178    EINA_SAFETY_ON_NULL_RETURN(wd);
3179
3180    if (wd->paused_markers == !!paused) return;
3181    wd->paused_markers = paused;
3182 #else
3183    (void) obj;
3184    (void) paused;
3185 #endif
3186 }
3187
3188 EAPI Eina_Bool
3189 elm_map_paused_get(const Evas_Object *obj)
3190 {
3191 #ifdef HAVE_ELEMENTARY_ECORE_CON
3192    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
3193    Widget_Data *wd = elm_widget_data_get(obj);
3194    EINA_SAFETY_ON_NULL_RETURN_VAL(wd, EINA_FALSE);
3195
3196    return wd->paused;
3197 #else
3198    (void) obj;
3199    return EINA_FALSE;
3200 #endif
3201 }
3202
3203 EAPI Eina_Bool
3204 elm_map_paused_markers_get(const Evas_Object *obj)
3205 {
3206 #ifdef HAVE_ELEMENTARY_ECORE_CON
3207    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
3208    Widget_Data *wd = elm_widget_data_get(obj);
3209    EINA_SAFETY_ON_NULL_RETURN_VAL(wd, EINA_FALSE);
3210
3211    return wd->paused_markers;
3212 #else
3213    (void) obj;
3214    return EINA_FALSE;
3215 #endif
3216 }
3217
3218 EAPI void
3219 elm_map_utils_downloading_status_get(const Evas_Object *obj, int *try_num, int *finish_num)
3220 {
3221 #ifdef HAVE_ELEMENTARY_ECORE_CON
3222    ELM_CHECK_WIDTYPE(obj, widtype);
3223    Widget_Data *wd = elm_widget_data_get(obj);
3224    EINA_SAFETY_ON_NULL_RETURN(wd);
3225
3226    if (try_num) *try_num = wd->try_num;
3227    if (finish_num) *finish_num = wd->finish_num;
3228 #else
3229    (void) obj;
3230    (void) try_num;
3231    (void) finish_num;
3232 #endif
3233 }
3234
3235 EAPI void
3236 elm_map_utils_convert_coord_into_geo(const Evas_Object *obj, int x, int y, int size, double *lon, double *lat)
3237 {
3238 #ifdef HAVE_ELEMENTARY_ECORE_CON
3239    ELM_CHECK_WIDTYPE(obj, widtype);
3240    Widget_Data *wd = elm_widget_data_get(obj);
3241    EINA_SAFETY_ON_NULL_RETURN(wd);
3242
3243    int zoom = floor(log(size / 256) / log(2));
3244    if ((wd->src) && (wd->src->coord_into_geo))
3245      {
3246         if (wd->src->coord_into_geo(obj, zoom, x, y, size, lon, lat)) return;
3247      }
3248
3249    if (lon) *lon = (x / (double)size * 360.0) - 180;
3250    if (lat)
3251      {
3252         double n = ELM_PI - (2.0 * ELM_PI * y / size);
3253         *lat = 180.0 / ELM_PI * atan(0.5 * (exp(n) - exp(-n)));
3254      }
3255 #else
3256    (void) obj;
3257    (void) x;
3258    (void) y;
3259    (void) size;
3260    (void) lon;
3261    (void) lat;
3262 #endif
3263 }
3264
3265 EAPI void
3266 elm_map_utils_convert_geo_into_coord(const Evas_Object *obj, double lon, double lat, int size, int *x, int *y)
3267 {
3268 #ifdef HAVE_ELEMENTARY_ECORE_CON
3269    ELM_CHECK_WIDTYPE(obj, widtype);
3270    Widget_Data *wd = elm_widget_data_get(obj);
3271    EINA_SAFETY_ON_NULL_RETURN(wd);
3272
3273    int zoom = floor(log(size / 256) / log(2));
3274    if ((wd->src) && (wd->src->geo_into_coord))
3275      {
3276         if (wd->src->geo_into_coord(obj, zoom, lon, lat, size, x, y)) return;
3277      }
3278
3279    if (x) *x = floor((lon + 180.0) / 360.0 * size);
3280    if (y)
3281       *y = floor((1.0 - log(tan(lat * ELM_PI / 180.0) + (1.0 / cos(lat * ELM_PI / 180.0)))
3282                  / ELM_PI) / 2.0 * size);
3283 #else
3284    (void) obj;
3285    (void) lon;
3286    (void) lat;
3287    (void) size;
3288    (void) x;
3289    (void) y;
3290 #endif
3291 }
3292
3293 EAPI Elm_Map_Name *
3294 elm_map_utils_convert_coord_into_name(const Evas_Object *obj, double lon, double lat)
3295 {
3296 #ifdef HAVE_ELEMENTARY_ECORE_CON
3297    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
3298    return _utils_convert_name(obj, ELM_MAP_NAME_METHOD_REVERSE, NULL, lon, lat);
3299 #else
3300    (void) obj;
3301    (void) lon;
3302    (void) lat;
3303    return NULL;
3304 #endif
3305 }
3306
3307 EAPI Elm_Map_Name *
3308 elm_map_utils_convert_name_into_coord(const Evas_Object *obj, char *address)
3309 {
3310 #ifdef HAVE_ELEMENTARY_ECORE_CON
3311    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
3312    if (!address) return NULL;
3313    return _utils_convert_name(obj, ELM_MAP_NAME_METHOD_SEARCH, address, 0.0, 0.0);
3314 #else
3315    (void) obj;
3316    (void) address;
3317    return NULL;
3318 #endif
3319 }
3320
3321 EINA_DEPRECATED EAPI void
3322 elm_map_utils_rotate_coord(const Evas_Object *obj, const Evas_Coord x, const Evas_Coord y, const Evas_Coord cx, const Evas_Coord cy, const double degree, Evas_Coord *xx, Evas_Coord *yy)
3323 {
3324 #ifdef HAVE_ELEMENTARY_ECORE_CON
3325    ELM_CHECK_WIDTYPE(obj, widtype);
3326    _coord_rotate(x, y, cx, cy, degree, xx, yy);
3327 #else
3328    (void) x;
3329    (void) y;
3330    (void) cx;
3331    (void) cy;
3332    (void) degree;
3333    (void) xx;
3334    (void) yy;
3335 #endif
3336 }
3337
3338 EAPI void
3339 elm_map_canvas_to_geo_convert(const Evas_Object *obj, Evas_Coord x, Evas_Coord y, double *lon, double *lat)
3340 {
3341 #ifdef HAVE_ELEMENTARY_ECORE_CON
3342    ELM_CHECK_WIDTYPE(obj, widtype);
3343    Widget_Data *wd = elm_widget_data_get(obj);
3344    EINA_SAFETY_ON_NULL_RETURN(lon);
3345    EINA_SAFETY_ON_NULL_RETURN(lat);
3346    EINA_SAFETY_ON_NULL_RETURN(wd);
3347
3348    Evas_Coord px, py, vw, vh;
3349    _pan_geometry_get(wd, &px, &py);
3350    _viewport_size_get(wd, &vw, &vh);
3351    _coord_rotate(x - px, y - py, (vw / 2) - px, (vh / 2) - py, -wd->rotate.d,
3352                  &x, &y);
3353    elm_map_utils_convert_coord_into_geo(obj, x, y, wd->size.w, lon, lat);
3354 #else
3355    (void) obj;
3356    (void) x;
3357    (void) y;
3358    (void) lon;
3359    (void) lat;
3360 #endif
3361 }
3362
3363 EAPI Elm_Map_Marker *
3364 elm_map_marker_add(Evas_Object *obj, double lon, double lat, Elm_Map_Marker_Class *clas, Elm_Map_Group_Class *group_clas, void *data)
3365 {
3366 #ifdef HAVE_ELEMENTARY_ECORE_CON
3367    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
3368    Widget_Data *wd = elm_widget_data_get(obj);
3369
3370    EINA_SAFETY_ON_NULL_RETURN_VAL(wd, NULL);
3371    EINA_SAFETY_ON_NULL_RETURN_VAL(clas, NULL);
3372
3373    Elm_Map_Marker *marker = ELM_NEW(Elm_Map_Marker);
3374    marker->wd = wd;
3375    marker->clas = clas;
3376    marker->group_clas = group_clas;
3377    marker->longitude = lon;
3378    marker->latitude = lat;
3379    marker->data = data;
3380    marker->x = 0;
3381    marker->y = 0;
3382    _edj_marker_size_get(wd, &marker->w, &marker->h);
3383
3384    marker->obj = elm_layout_add(wd->obj);
3385    evas_object_smart_member_add(marker->obj, wd->pan_smart);
3386    evas_object_stack_above(marker->obj, wd->sep_maps_markers);
3387
3388    edje_object_signal_callback_add(elm_layout_edje_get(marker->obj),
3389                                    "open", "elm", _marker_bubble_open_cb,
3390                                    marker);
3391    edje_object_signal_callback_add(elm_layout_edje_get(marker->obj),
3392                                    "bringin", "elm", _marker_bringin_cb,
3393                                    marker);
3394
3395    wd->markers = eina_list_append(wd->markers, marker);
3396    if (marker->group_clas) group_clas->markers = eina_list_append(group_clas->markers,
3397                                                                   marker);
3398    evas_object_smart_changed(wd->pan_smart);
3399    return marker;
3400 #else
3401    (void) obj;
3402    (void) lon;
3403    (void) lat;
3404    (void) clas;
3405    (void) group_clas;
3406    (void) data;
3407    return NULL;
3408 #endif
3409 }
3410
3411 EAPI void
3412 elm_map_marker_remove(Elm_Map_Marker *marker)
3413 {
3414 #ifdef HAVE_ELEMENTARY_ECORE_CON
3415    EINA_SAFETY_ON_NULL_RETURN(marker);
3416    Widget_Data *wd = marker->wd;
3417    EINA_SAFETY_ON_NULL_RETURN(wd);
3418
3419    if ((marker->content) && (marker->clas->func.del))
3420       marker->clas->func.del(wd->obj, marker, marker->data, marker->content);
3421
3422    if (marker->bubble) _bubble_free(marker->bubble);
3423    if (marker->group) _marker_group_free(marker->group);
3424
3425    if (marker->group_clas)
3426       marker->group_clas->markers = eina_list_remove(marker->group_clas->markers, marker);
3427    wd->markers = eina_list_remove(wd->markers, marker);
3428
3429    evas_object_del(marker->obj);
3430    free(marker);
3431
3432    evas_object_smart_changed(wd->pan_smart);
3433 #else
3434    (void) marker;
3435 #endif
3436 }
3437
3438 EAPI void
3439 elm_map_marker_region_get(const Elm_Map_Marker *marker, double *lon, double *lat)
3440 {
3441 #ifdef HAVE_ELEMENTARY_ECORE_CON
3442    EINA_SAFETY_ON_NULL_RETURN(marker);
3443    if (lon) *lon = marker->longitude;
3444    if (lat) *lat = marker->latitude;
3445 #else
3446    (void) marker;
3447    (void) lon;
3448    (void) lat;
3449 #endif
3450 }
3451
3452 EAPI void
3453 elm_map_marker_bring_in(Elm_Map_Marker *marker)
3454 {
3455 #ifdef HAVE_ELEMENTARY_ECORE_CON
3456    EINA_SAFETY_ON_NULL_RETURN(marker);
3457    elm_map_geo_region_bring_in(marker->wd->obj, marker->longitude, marker->latitude);
3458 #else
3459    (void) marker;
3460 #endif
3461 }
3462
3463 EAPI void
3464 elm_map_marker_show(Elm_Map_Marker *marker)
3465 {
3466 #ifdef HAVE_ELEMENTARY_ECORE_CON
3467    EINA_SAFETY_ON_NULL_RETURN(marker);
3468    elm_map_geo_region_show(marker->wd->obj, marker->longitude, marker->latitude);
3469 #else
3470    (void) marker;
3471 #endif
3472 }
3473
3474 EAPI void
3475 elm_map_markers_list_show(Eina_List *markers)
3476 {
3477 #ifdef HAVE_ELEMENTARY_ECORE_CON
3478    EINA_SAFETY_ON_NULL_RETURN(markers);
3479    EINA_SAFETY_ON_TRUE_RETURN(!eina_list_count(markers));
3480
3481    Elm_Map_Marker *marker;
3482    marker = eina_list_data_get(markers);
3483
3484    Delayed_Data *data = ELM_NEW(Delayed_Data);
3485    data->func = _marker_list_show;
3486    data->wd = marker->wd;
3487    data->markers = eina_list_clone(markers);
3488    data->wd->delayed_jobs = eina_list_append(data->wd->delayed_jobs, data);
3489    evas_object_smart_changed(data->wd->pan_smart);
3490 #else
3491    (void) markers;
3492 #endif
3493 }
3494
3495 EAPI void
3496 elm_map_max_marker_per_group_set(Evas_Object *obj, int max)
3497 {
3498 #ifdef HAVE_ELEMENTARY_ECORE_CON
3499    ELM_CHECK_WIDTYPE(obj, widtype);
3500    Widget_Data *wd = elm_widget_data_get(obj);
3501    EINA_SAFETY_ON_NULL_RETURN(wd);
3502
3503    wd->markers_max_num = max;
3504 #else
3505    (void) obj;
3506    (void) max;
3507 #endif
3508 }
3509
3510 EAPI Evas_Object *
3511 elm_map_marker_object_get(const Elm_Map_Marker *marker)
3512 {
3513 #ifdef HAVE_ELEMENTARY_ECORE_CON
3514    EINA_SAFETY_ON_NULL_RETURN_VAL(marker, NULL);
3515    return marker->content;
3516 #else
3517    (void) marker;
3518    return NULL;
3519 #endif
3520 }
3521
3522 EAPI void
3523 elm_map_marker_update(Elm_Map_Marker *marker)
3524 {
3525 #ifdef HAVE_ELEMENTARY_ECORE_CON
3526    EINA_SAFETY_ON_NULL_RETURN(marker);
3527    Widget_Data *wd = marker->wd;
3528    EINA_SAFETY_ON_NULL_RETURN(wd);
3529
3530    _marker_update(marker);
3531 #else
3532    (void) marker;
3533 #endif
3534 }
3535
3536 EAPI void
3537 elm_map_bubbles_close(Evas_Object *obj)
3538 {
3539 #ifdef HAVE_ELEMENTARY_ECORE_CON
3540    ELM_CHECK_WIDTYPE(obj, widtype);
3541    Widget_Data *wd = elm_widget_data_get(obj);
3542    EINA_SAFETY_ON_NULL_RETURN(wd);
3543
3544    Eina_List *l;
3545    Elm_Map_Marker *marker;
3546    EINA_LIST_FOREACH(wd->markers, l, marker)
3547      {
3548         if (marker->bubble) _bubble_free(marker->bubble);
3549         marker->bubble = NULL;
3550
3551         if (marker->group)
3552           {
3553              if (marker->group->bubble) _bubble_free(marker->group->bubble);
3554              marker->group->bubble = NULL;
3555           }
3556      }
3557 #else
3558    (void) obj;
3559 #endif
3560 }
3561
3562 EAPI Elm_Map_Group_Class *
3563 elm_map_group_class_new(Evas_Object *obj)
3564 {
3565 #ifdef HAVE_ELEMENTARY_ECORE_CON
3566    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
3567    Widget_Data *wd = elm_widget_data_get(obj);
3568    EINA_SAFETY_ON_NULL_RETURN_VAL(wd, NULL);
3569
3570    Elm_Map_Group_Class *clas = ELM_NEW(Elm_Map_Group_Class);
3571    clas->wd = wd;
3572    clas->zoom_displayed = 0;
3573    clas->zoom_grouped = 255;
3574    eina_stringshare_replace(&clas->style, "radio");
3575
3576    wd->group_classes = eina_list_append(wd->group_classes, clas);
3577
3578    return clas;
3579 #else
3580    (void) obj;
3581    return NULL;
3582 #endif
3583 }
3584
3585 EAPI void
3586 elm_map_group_class_style_set(Elm_Map_Group_Class *clas, const char *style)
3587 {
3588 #ifdef HAVE_ELEMENTARY_ECORE_CON
3589    EINA_SAFETY_ON_NULL_RETURN(clas);
3590    eina_stringshare_replace(&clas->style, style);
3591 #else
3592    (void) clas;
3593    (void) style;
3594 #endif
3595 }
3596
3597 EAPI void
3598 elm_map_group_class_icon_cb_set(Elm_Map_Group_Class *clas, ElmMapGroupIconGetFunc icon_get)
3599 {
3600 #ifdef HAVE_ELEMENTARY_ECORE_CON
3601    EINA_SAFETY_ON_NULL_RETURN(clas);
3602    clas->func.icon_get = icon_get;
3603 #else
3604    (void) clas;
3605    (void) icon_get;
3606 #endif
3607 }
3608
3609 EAPI void
3610 elm_map_group_class_data_set(Elm_Map_Group_Class *clas, void *data)
3611 {
3612 #ifdef HAVE_ELEMENTARY_ECORE_CON
3613    EINA_SAFETY_ON_NULL_RETURN(clas);
3614    clas->data = data;
3615 #else
3616    (void) clas;
3617    (void) data;
3618 #endif
3619 }
3620
3621 EAPI void
3622 elm_map_group_class_zoom_displayed_set(Elm_Map_Group_Class *clas, int zoom)
3623 {
3624 #ifdef HAVE_ELEMENTARY_ECORE_CON
3625    EINA_SAFETY_ON_NULL_RETURN(clas);
3626    clas->zoom_displayed = zoom;
3627 #else
3628    (void) clas;
3629    (void) zoom;
3630 #endif
3631 }
3632
3633 EAPI void
3634 elm_map_group_class_zoom_grouped_set(Elm_Map_Group_Class *clas, int zoom)
3635 {
3636 #ifdef HAVE_ELEMENTARY_ECORE_CON
3637    EINA_SAFETY_ON_NULL_RETURN(clas);
3638    clas->zoom_grouped = zoom;
3639 #else
3640    (void) clas;
3641    (void) zoom;
3642 #endif
3643 }
3644
3645 EAPI void
3646 elm_map_group_class_hide_set(Evas_Object *obj, Elm_Map_Group_Class *clas, Eina_Bool hide)
3647 {
3648 #ifdef HAVE_ELEMENTARY_ECORE_CON
3649    ELM_CHECK_WIDTYPE(obj, widtype);
3650    Widget_Data *wd = elm_widget_data_get(obj);
3651    EINA_SAFETY_ON_NULL_RETURN(wd);
3652    EINA_SAFETY_ON_NULL_RETURN(clas);
3653
3654    clas->hide = hide;
3655    evas_object_smart_changed(wd->pan_smart);
3656 #else
3657    (void) obj;
3658    (void) clas;
3659    (void) hide;
3660 #endif
3661 }
3662
3663 EAPI Elm_Map_Marker_Class *
3664 elm_map_marker_class_new(Evas_Object *obj)
3665 {
3666 #ifdef HAVE_ELEMENTARY_ECORE_CON
3667    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
3668    Widget_Data *wd = elm_widget_data_get(obj);
3669    EINA_SAFETY_ON_NULL_RETURN_VAL(wd, NULL);
3670
3671    Elm_Map_Marker_Class *clas = ELM_NEW(Elm_Map_Marker_Class);
3672    eina_stringshare_replace(&clas->style, "radio");
3673
3674    wd->marker_classes = eina_list_append(wd->marker_classes, clas);
3675    return clas;
3676 #else
3677    (void) obj;
3678    return NULL;
3679 #endif
3680 }
3681
3682 EAPI void
3683 elm_map_marker_class_style_set(Elm_Map_Marker_Class *clas, const char *style)
3684 {
3685 #ifdef HAVE_ELEMENTARY_ECORE_CON
3686    EINA_SAFETY_ON_NULL_RETURN(clas);
3687    eina_stringshare_replace(&clas->style, style);
3688 #else
3689    (void) clas;
3690    (void) style;
3691 #endif
3692 }
3693
3694 EAPI void
3695 elm_map_marker_class_icon_cb_set(Elm_Map_Marker_Class *clas, ElmMapMarkerIconGetFunc icon_get)
3696 {
3697 #ifdef HAVE_ELEMENTARY_ECORE_CON
3698    EINA_SAFETY_ON_NULL_RETURN(clas);
3699    clas->func.icon_get = icon_get;
3700 #else
3701    (void) clas;
3702    (void) icon_get;
3703 #endif
3704 }
3705
3706 EAPI void
3707 elm_map_marker_class_get_cb_set(Elm_Map_Marker_Class *clas, ElmMapMarkerGetFunc get)
3708 {
3709 #ifdef HAVE_ELEMENTARY_ECORE_CON
3710    EINA_SAFETY_ON_NULL_RETURN(clas);
3711    clas->func.get = get;
3712 #else
3713    (void) clas;
3714    (void) get;
3715 #endif
3716 }
3717
3718 EAPI void
3719 elm_map_marker_class_del_cb_set(Elm_Map_Marker_Class *clas, ElmMapMarkerDelFunc del)
3720 {
3721 #ifdef HAVE_ELEMENTARY_ECORE_CON
3722    EINA_SAFETY_ON_NULL_RETURN(clas);
3723    clas->func.del = del;
3724 #else
3725    (void) clas;
3726    (void) del;
3727 #endif
3728 }
3729
3730 EAPI const char **
3731 elm_map_source_names_get(const Evas_Object *obj)
3732 {
3733 #ifdef HAVE_ELEMENTARY_ECORE_CON
3734    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
3735    Widget_Data *wd = elm_widget_data_get(obj);
3736    EINA_SAFETY_ON_NULL_RETURN_VAL(wd, NULL);
3737
3738    return wd->src_names;
3739 #else
3740    (void) obj;
3741    return NULL;
3742 #endif
3743 }
3744
3745 EAPI void
3746 elm_map_source_name_set(Evas_Object *obj, const char *source_name)
3747 {
3748 #ifdef HAVE_ELEMENTARY_ECORE_CON
3749    ELM_CHECK_WIDTYPE(obj, widtype);
3750    Widget_Data *wd = elm_widget_data_get(obj);
3751    EINA_SAFETY_ON_NULL_RETURN(wd);
3752
3753    Map_Sources_Tab *s;
3754    Eina_List *l;
3755    int zoom;
3756
3757    if (wd->src)
3758      {
3759         if (!strcmp(wd->src->name, source_name)) return;
3760         if (!wd->src->url_cb) return;
3761      }
3762
3763    _grid_all_clear(wd);
3764    EINA_LIST_FOREACH(wd->srcs, l, s)
3765      {
3766         if (!strcmp(s->name, source_name))
3767           {
3768              wd->src = s;
3769              break;
3770           }
3771      }
3772    zoom = wd->zoom;
3773    wd->zoom = -1;
3774
3775    if (wd->src)
3776      {
3777         if (wd->src->zoom_max < zoom)
3778           zoom = wd->src->zoom_max;
3779         if (wd->src->zoom_min > zoom)
3780           zoom = wd->src->zoom_min;
3781         if (wd->src->zoom_max < wd->zoom_max) wd->zoom_max = wd->src->zoom_max;
3782         if (wd->src->zoom_min > wd->zoom_min) wd->zoom_min = wd->src->zoom_min;
3783      }
3784    _grid_all_create(wd);
3785    zoom_do(wd, zoom);
3786 #else
3787    (void) obj;
3788    (void) source_name;
3789 #endif
3790 }
3791
3792 EAPI const char *
3793 elm_map_source_name_get(const Evas_Object *obj)
3794 {
3795 #ifdef HAVE_ELEMENTARY_ECORE_CON
3796    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
3797    Widget_Data *wd = elm_widget_data_get(obj);
3798
3799    if ((!wd) || (!wd->src)) return NULL;
3800    return wd->src->name;
3801 #else
3802    (void) obj;
3803    return NULL;
3804 #endif
3805 }
3806
3807 EAPI void
3808 elm_map_route_source_set(Evas_Object *obj, Elm_Map_Route_Sources source)
3809 {
3810 #ifdef HAVE_ELEMENTARY_ECORE_CON
3811    ELM_CHECK_WIDTYPE(obj, widtype);
3812    Widget_Data *wd = elm_widget_data_get(obj);
3813    EINA_SAFETY_ON_NULL_RETURN(wd);
3814
3815    wd->route_source = source;
3816 #else
3817    (void) obj;
3818    (void) source;
3819 #endif
3820 }
3821
3822 EAPI Elm_Map_Route_Sources
3823 elm_map_route_source_get(const Evas_Object *obj)
3824 {
3825 #ifdef HAVE_ELEMENTARY_ECORE_CON
3826    ELM_CHECK_WIDTYPE(obj, widtype) ELM_MAP_ROUTE_SOURCE_YOURS;
3827    Widget_Data *wd = elm_widget_data_get(obj);
3828    EINA_SAFETY_ON_NULL_RETURN_VAL(wd, ELM_MAP_ROUTE_SOURCE_YOURS);
3829
3830    return wd->route_source;
3831 #else
3832    (void) obj;
3833    return ELM_MAP_ROUTE_SOURCE_YOURS;
3834 #endif
3835 }
3836
3837 EAPI void
3838 elm_map_source_zoom_max_set(Evas_Object *obj, int zoom)
3839 {
3840 #ifdef HAVE_ELEMENTARY_ECORE_CON
3841    ELM_CHECK_WIDTYPE(obj, widtype);
3842    Widget_Data *wd = elm_widget_data_get(obj);
3843    EINA_SAFETY_ON_NULL_RETURN(wd);
3844    EINA_SAFETY_ON_NULL_RETURN(wd->src);
3845
3846    if ((zoom > wd->src->zoom_max) || (zoom < wd->src->zoom_min)) return;
3847    wd->zoom_max = zoom;
3848 #else
3849    (void) obj;
3850    (void) zoom;
3851 #endif
3852 }
3853
3854 EAPI int
3855 elm_map_source_zoom_max_get(const Evas_Object *obj)
3856 {
3857 #ifdef HAVE_ELEMENTARY_ECORE_CON
3858    ELM_CHECK_WIDTYPE(obj, widtype) 18;
3859    Widget_Data *wd = elm_widget_data_get(obj);
3860    EINA_SAFETY_ON_NULL_RETURN_VAL(wd, -1);
3861    EINA_SAFETY_ON_NULL_RETURN_VAL(wd->src, -1);
3862
3863    return wd->zoom_max;
3864 #else
3865    (void) obj;
3866    return 18;
3867 #endif
3868 }
3869
3870 EAPI void
3871 elm_map_source_zoom_min_set(Evas_Object *obj, int zoom)
3872 {
3873 #ifdef HAVE_ELEMENTARY_ECORE_CON
3874    ELM_CHECK_WIDTYPE(obj, widtype);
3875    Widget_Data *wd = elm_widget_data_get(obj);
3876    EINA_SAFETY_ON_NULL_RETURN(wd);
3877    EINA_SAFETY_ON_NULL_RETURN(wd->src);
3878
3879    if ((zoom > wd->src->zoom_max) || (zoom < wd->src->zoom_min)) return;
3880    wd->zoom_min = zoom;
3881 #else
3882    (void) obj;
3883    (void) zoom;
3884 #endif
3885 }
3886
3887 EAPI int
3888 elm_map_source_zoom_min_get(const Evas_Object *obj)
3889 {
3890 #ifdef HAVE_ELEMENTARY_ECORE_CON
3891    ELM_CHECK_WIDTYPE(obj, widtype) 0;
3892    Widget_Data *wd = elm_widget_data_get(obj);
3893    EINA_SAFETY_ON_NULL_RETURN_VAL(wd, -1);
3894    EINA_SAFETY_ON_NULL_RETURN_VAL(wd->src, -1);
3895
3896    return wd->zoom_min;
3897 #else
3898    (void) obj;
3899    return 0;
3900 #endif
3901 }
3902
3903 EAPI void
3904 elm_map_user_agent_set(Evas_Object *obj, const char *user_agent)
3905 {
3906 #ifdef HAVE_ELEMENTARY_ECORE_CON
3907    ELM_CHECK_WIDTYPE(obj, widtype);
3908    Widget_Data *wd = elm_widget_data_get(obj);
3909    EINA_SAFETY_ON_NULL_RETURN(wd);
3910    EINA_SAFETY_ON_NULL_RETURN(user_agent);
3911
3912    eina_stringshare_replace(&wd->user_agent, user_agent);
3913
3914    if (!wd->ua) wd->ua = eina_hash_string_small_new(NULL);
3915    eina_hash_set(wd->ua, "User-Agent", wd->user_agent);
3916 #else
3917    (void) obj;
3918    (void) user_agent;
3919 #endif
3920 }
3921
3922 EAPI const char *
3923 elm_map_user_agent_get(const Evas_Object *obj)
3924 {
3925 #ifdef HAVE_ELEMENTARY_ECORE_CON
3926    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
3927    Widget_Data *wd = elm_widget_data_get(obj);
3928    EINA_SAFETY_ON_NULL_RETURN_VAL(wd, NULL);
3929
3930    return wd->user_agent;
3931 #else
3932    (void) obj;
3933    return NULL;
3934 #endif
3935 }
3936
3937 EAPI Elm_Map_Route *
3938 elm_map_route_add(Evas_Object *obj, Elm_Map_Route_Type type, Elm_Map_Route_Method method, double flon, double flat, double tlon, double tlat)
3939 {
3940 #ifdef HAVE_ELEMENTARY_ECORE_CON
3941    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
3942    Widget_Data *wd = elm_widget_data_get(obj);
3943    char buf[PATH_MAX];
3944    char *source;
3945    char *type_name = NULL;
3946    int fd;
3947
3948    EINA_SAFETY_ON_NULL_RETURN_VAL(wd, NULL);
3949    EINA_SAFETY_ON_NULL_RETURN_VAL(wd->src, NULL);
3950
3951    Elm_Map_Route *route = ELM_NEW(Elm_Map_Route);
3952
3953    snprintf(buf, sizeof(buf), DEST_ROUTE_XML_FILE);
3954    fd = mkstemp(buf);
3955    if (fd < 0)
3956      {
3957         free(route);
3958         return NULL;
3959      }
3960
3961    route->con_url = ecore_con_url_new(NULL);
3962    route->ud.fname = strdup(buf);
3963    INF("xml file : %s", route->ud.fname);
3964
3965    route->ud.fd = fdopen(fd, "w+");
3966    if ((!route->con_url) || (!route->ud.fd))
3967      {
3968         ecore_con_url_free(route->con_url);
3969         free(route);
3970         return NULL;
3971      }
3972
3973    route->wd = wd;
3974    route->color.r = 255;
3975    route->color.g = 0;
3976    route->color.b = 0;
3977    route->color.a = 255;
3978    route->handlers = eina_list_append
3979      (route->handlers, (void *)ecore_event_handler_add
3980          (ECORE_CON_EVENT_URL_COMPLETE, _route_complete_cb, route));
3981
3982    route->inbound = EINA_FALSE;
3983    route->type = type;
3984    route->method = method;
3985    route->flon = flon;
3986    route->flat = flat;
3987    route->tlon = tlon;
3988    route->tlat = tlat;
3989
3990    switch (type)
3991      {
3992       case ELM_MAP_ROUTE_TYPE_MOTOCAR:
3993         type_name = strdup(ROUTE_TYPE_MOTORCAR);
3994         break;
3995       case ELM_MAP_ROUTE_TYPE_BICYCLE:
3996         type_name = strdup(ROUTE_TYPE_BICYCLE);
3997         break;
3998       case ELM_MAP_ROUTE_TYPE_FOOT:
3999         type_name = strdup(ROUTE_TYPE_FOOT);
4000         break;
4001       default:
4002         break;
4003      }
4004
4005    source = wd->src->route_url_cb(obj, type_name, method, flon, flat, tlon, tlat);
4006    INF("route url = %s", source);
4007
4008    wd->route = eina_list_append(wd->route, route);
4009
4010    ecore_con_url_url_set(route->con_url, source);
4011    ecore_con_url_fd_set(route->con_url, fileno(route->ud.fd));
4012    ecore_con_url_data_set(route->con_url, route);
4013    ecore_con_url_get(route->con_url);
4014    if (type_name) free(type_name);
4015    if (source) free(source);
4016
4017    edje_object_signal_emit(elm_smart_scroller_edje_object_get(wd->scr),
4018                            "elm,state,busy,start", "elm");
4019    evas_object_smart_callback_call(wd->obj, SIG_ROUTE_LOAD, NULL);
4020    return route;
4021 #else
4022    (void) obj;
4023    (void) type;
4024    (void) method;
4025    (void) flon;
4026    (void) flat;
4027    (void) tlon;
4028    (void) tlat;
4029    return NULL;
4030 #endif
4031 }
4032
4033 EAPI void
4034 elm_map_route_remove(Elm_Map_Route *route)
4035 {
4036 #ifdef HAVE_ELEMENTARY_ECORE_CON
4037    EINA_SAFETY_ON_NULL_RETURN(route);
4038
4039    Path_Waypoint *w;
4040    Path_Node *n;
4041    Evas_Object *p;
4042    Ecore_Event_Handler *h;
4043
4044    EINA_LIST_FREE(route->path, p)
4045      {
4046         evas_object_del(p);
4047      }
4048
4049    EINA_LIST_FREE(route->waypoint, w)
4050      {
4051         if (w->point) eina_stringshare_del(w->point);
4052         free(w);
4053      }
4054
4055    EINA_LIST_FREE(route->nodes, n)
4056      {
4057         if (n->pos.address) eina_stringshare_del(n->pos.address);
4058         free(n);
4059      }
4060
4061    EINA_LIST_FREE(route->handlers, h)
4062      {
4063         ecore_event_handler_del(h);
4064      }
4065
4066    if (route->ud.fname)
4067      {
4068         ecore_file_remove(route->ud.fname);
4069         free(route->ud.fname);
4070         route->ud.fname = NULL;
4071      }
4072 #else
4073    (void) route;
4074 #endif
4075 }
4076
4077 EAPI void
4078 elm_map_route_color_set(Elm_Map_Route *route, int r, int g , int b, int a)
4079 {
4080 #ifdef HAVE_ELEMENTARY_ECORE_CON
4081    EINA_SAFETY_ON_NULL_RETURN(route);
4082    route->color.r = r;
4083    route->color.g = g;
4084    route->color.b = b;
4085    route->color.a = a;
4086 #else
4087    (void) route;
4088    (void) r;
4089    (void) g;
4090    (void) b;
4091    (void) a;
4092 #endif
4093 }
4094
4095 EAPI void
4096 elm_map_route_color_get(const Elm_Map_Route *route, int *r, int *g , int *b, int *a)
4097 {
4098 #ifdef HAVE_ELEMENTARY_ECORE_CON
4099    EINA_SAFETY_ON_NULL_RETURN(route);
4100    if (r) *r = route->color.r;
4101    if (g) *g = route->color.g;
4102    if (b) *b = route->color.b;
4103    if (a) *a = route->color.a;
4104 #else
4105    (void) route;
4106    (void) r;
4107    (void) g;
4108    (void) b;
4109    (void) a;
4110 #endif
4111 }
4112
4113 EAPI double
4114 elm_map_route_distance_get(const Elm_Map_Route *route)
4115 {
4116 #ifdef HAVE_ELEMENTARY_ECORE_CON
4117    EINA_SAFETY_ON_NULL_RETURN_VAL(route, 0.0);
4118    return route->info.distance;
4119 #else
4120    (void) route;
4121    return 0.0;
4122 #endif
4123 }
4124
4125 EAPI const char*
4126 elm_map_route_node_get(const Elm_Map_Route *route)
4127 {
4128 #ifdef HAVE_ELEMENTARY_ECORE_CON
4129    EINA_SAFETY_ON_NULL_RETURN_VAL(route, NULL);
4130    return route->info.nodes;
4131 #else
4132    (void) route;
4133    return NULL;
4134 #endif
4135 }
4136
4137 EAPI const char*
4138 elm_map_route_waypoint_get(const Elm_Map_Route *route)
4139 {
4140 #ifdef HAVE_ELEMENTARY_ECORE_CON
4141    EINA_SAFETY_ON_NULL_RETURN_VAL(route, NULL);
4142    return route->info.waypoints;
4143 #else
4144    (void) route;
4145    return NULL;
4146 #endif
4147 }
4148
4149 EAPI const char *
4150 elm_map_name_address_get(const Elm_Map_Name *name)
4151 {
4152 #ifdef HAVE_ELEMENTARY_ECORE_CON
4153    EINA_SAFETY_ON_NULL_RETURN_VAL(name, NULL);
4154    return name->address;
4155 #else
4156    (void) name;
4157    return NULL;
4158 #endif
4159 }
4160
4161 EAPI void
4162 elm_map_name_region_get(const Elm_Map_Name *name, double *lon, double *lat)
4163 {
4164 #ifdef HAVE_ELEMENTARY_ECORE_CON
4165    EINA_SAFETY_ON_NULL_RETURN(name);
4166    if (lon) *lon = name->lon;
4167    if (lat) *lat = name->lat;
4168 #else
4169    (void) name;
4170    (void) lon;
4171    (void) lat;
4172 #endif
4173 }
4174
4175 EAPI void
4176 elm_map_name_remove(Elm_Map_Name *name)
4177 {
4178 #ifdef HAVE_ELEMENTARY_ECORE_CON
4179    EINA_SAFETY_ON_NULL_RETURN(name);
4180    if (name->address)
4181      {
4182         free(name->address);
4183         name->address = NULL;
4184      }
4185    if (name->handler)
4186      {
4187         ecore_event_handler_del(name->handler);
4188         name->handler = NULL;
4189      }
4190    if (name->ud.fname)
4191      {
4192         ecore_file_remove(name->ud.fname);
4193         free(name->ud.fname);
4194         name->ud.fname = NULL;
4195      }
4196 #else
4197    (void) name;
4198 #endif
4199 }
4200
4201 EAPI void
4202 elm_map_rotate_set(Evas_Object *obj, double degree, Evas_Coord cx, Evas_Coord cy)
4203 {
4204 #ifdef HAVE_ELEMENTARY_ECORE_CON
4205    ELM_CHECK_WIDTYPE(obj, widtype);
4206    Widget_Data *wd = elm_widget_data_get(obj);
4207    EINA_SAFETY_ON_NULL_RETURN(wd);
4208
4209    wd->rotate.d = degree;
4210    wd->rotate.cx = cx;
4211    wd->rotate.cy = cy;
4212
4213    evas_object_smart_changed(wd->pan_smart);
4214 #else
4215    (void) obj;
4216    (void) degree;
4217    (void) cx;
4218    (void) cy;
4219 #endif
4220 }
4221
4222 EAPI void
4223 elm_map_rotate_get(const Evas_Object *obj, double *degree, Evas_Coord *cx, Evas_Coord *cy)
4224 {
4225 #ifdef HAVE_ELEMENTARY_ECORE_CON
4226    ELM_CHECK_WIDTYPE(obj, widtype);
4227    Widget_Data *wd = elm_widget_data_get(obj);
4228    EINA_SAFETY_ON_NULL_RETURN(wd);
4229
4230    if (degree) *degree = wd->rotate.d;
4231    if (cx) *cx = wd->rotate.cx;
4232    if (cy) *cy = wd->rotate.cy;
4233 #else
4234    (void) obj;
4235    (void) degree;
4236    (void) cx;
4237    (void) cy;
4238 #endif
4239 }
4240
4241 EAPI void
4242 elm_map_wheel_disabled_set(Evas_Object *obj, Eina_Bool disabled)
4243 {
4244 #ifdef HAVE_ELEMENTARY_ECORE_CON
4245    ELM_CHECK_WIDTYPE(obj, widtype);
4246    Widget_Data *wd = elm_widget_data_get(obj);
4247    EINA_SAFETY_ON_NULL_RETURN(wd);
4248
4249    if ((!wd->wheel_disabled) && (disabled))
4250      evas_object_event_callback_del_full(obj, EVAS_CALLBACK_MOUSE_WHEEL, _mouse_wheel_cb, obj);
4251    else if ((wd->wheel_disabled) && (!disabled))
4252      evas_object_event_callback_add(obj, EVAS_CALLBACK_MOUSE_WHEEL, _mouse_wheel_cb, obj);
4253    wd->wheel_disabled = !!disabled;
4254 #else
4255    (void) obj;
4256    (void) disabled;
4257 #endif
4258 }
4259
4260 EAPI Eina_Bool
4261 elm_map_wheel_disabled_get(const Evas_Object *obj)
4262 {
4263 #ifdef HAVE_ELEMENTARY_ECORE_CON
4264    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
4265    Widget_Data *wd = elm_widget_data_get(obj);
4266    EINA_SAFETY_ON_NULL_RETURN_VAL(wd, EINA_FALSE);
4267
4268    return wd->wheel_disabled;
4269 #else
4270    (void) obj;
4271    return EINA_FALSE;
4272 #endif
4273 }
4274
4275 #ifdef ELM_EMAP
4276 EAPI Evas_Object *
4277 elm_map_track_add(Evas_Object *obj, EMap_Route *emap)
4278 {
4279 #ifdef HAVE_ELEMENTARY_ECORE_CON
4280    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
4281    Widget_Data *wd = elm_widget_data_get(obj);
4282    EINA_SAFETY_ON_NULL_RETURN_VAL(wd, EINA_FALSE);
4283
4284    Evas_Object *route = elm_route_add(obj);
4285    elm_route_emap_set(route, emap);
4286    wd->track = eina_list_append(wd->track, route);
4287
4288    return route;
4289 #else
4290    (void) obj;
4291    (void) emap;
4292    return NULL;
4293 #endif
4294 }
4295 #endif
4296
4297 EAPI void
4298 elm_map_track_remove(Evas_Object *obj, Evas_Object *route)
4299 {
4300 #ifdef HAVE_ELEMENTARY_ECORE_CON
4301    ELM_CHECK_WIDTYPE(obj, widtype) ;
4302    Widget_Data *wd = elm_widget_data_get(obj);
4303    EINA_SAFETY_ON_NULL_RETURN(wd);
4304
4305    wd->track = eina_list_remove(wd->track, route);
4306    evas_object_del(route);
4307 #else
4308    (void) obj;
4309    (void) route;
4310 #endif
4311 }