src/lib/elm_map.c

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