src/lib/elm_map.c

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