src/lib/elm_map.c

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