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