2011-07-10 14:45:47 -07:00
|
|
|
#ifdef HAVE_CONFIG_H
|
2011-07-10 18:22:19 -07:00
|
|
|
# include "elementary_config.h"
|
2011-07-10 14:45:47 -07:00
|
|
|
#endif
|
|
|
|
|
2011-05-15 09:14:17 -07:00
|
|
|
#include "Elementary.h"
|
2009-11-13 07:22:23 -08:00
|
|
|
#include "elm_priv.h"
|
2011-10-06 22:56:07 -07:00
|
|
|
#include "els_scroller.h"
|
2009-11-13 07:22:23 -08:00
|
|
|
|
2011-11-20 07:00:43 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_ECORE_CON
|
|
|
|
|
2009-11-13 07:22:23 -08:00
|
|
|
typedef struct _Widget_Data Widget_Data;
|
|
|
|
typedef struct _Pan Pan;
|
|
|
|
typedef struct _Grid Grid;
|
|
|
|
typedef struct _Grid_Item Grid_Item;
|
2009-11-15 07:53:37 -08:00
|
|
|
typedef struct _Marker_Group Marker_Group;
|
2011-01-05 19:43:51 -08:00
|
|
|
typedef struct _Event Event;
|
2011-05-19 22:55:15 -07:00
|
|
|
typedef struct _Path_Node Path_Node;
|
|
|
|
typedef struct _Path_Waypoint Path_Waypoint;
|
2011-04-07 23:14:10 -07:00
|
|
|
typedef struct _Url_Data Url_Data;
|
|
|
|
typedef struct _Route_Dump Route_Dump;
|
2011-04-17 23:42:47 -07:00
|
|
|
typedef struct _Name_Dump Name_Dump;
|
2011-05-19 22:55:15 -07:00
|
|
|
typedef struct _Track_Dump Track_Dump;
|
2009-11-15 07:53:37 -08:00
|
|
|
|
2011-12-13 00:39:01 -08:00
|
|
|
#define CACHE_ROOT_PATH "/tmp/elm_map"
|
|
|
|
#define CACHE_PATH CACHE_ROOT_PATH"/%d/%d/%d"
|
|
|
|
#define CACHE_FILE_PATH "%s/%d.png"
|
2011-04-17 23:42:47 -07:00
|
|
|
#define DEST_ROUTE_XML_FILE "/tmp/elm_map-route-XXXXXX"
|
|
|
|
#define DEST_NAME_XML_FILE "/tmp/elm_map-name-XXXXXX"
|
2011-04-07 23:14:10 -07:00
|
|
|
|
|
|
|
#define ROUTE_YOURS_URL "http://www.yournavigation.org/api/dev/route.php"
|
|
|
|
#define ROUTE_TYPE_MOTORCAR "motocar"
|
|
|
|
#define ROUTE_TYPE_BICYCLE "bicycle"
|
|
|
|
#define ROUTE_TYPE_FOOT "foot"
|
|
|
|
#define YOURS_DISTANCE "distance"
|
|
|
|
#define YOURS_DESCRIPTION "description"
|
|
|
|
#define YOURS_COORDINATES "coordinates"
|
|
|
|
|
2011-04-08 07:36:29 -07:00
|
|
|
// TODO: fix monav & ors url
|
2011-04-07 23:14:10 -07:00
|
|
|
#define ROUTE_MONAV_URL "http://"
|
|
|
|
#define ROUTE_ORS_URL "http:///"
|
2009-11-13 07:22:23 -08:00
|
|
|
|
2011-04-17 23:42:47 -07:00
|
|
|
#define NAME_NOMINATIM_URL "http://nominatim.openstreetmap.org"
|
|
|
|
#define NOMINATIM_RESULT "result"
|
|
|
|
#define NOMINATIM_PLACE "place"
|
|
|
|
#define NOMINATIM_ATTR_LON "lon"
|
|
|
|
#define NOMINATIM_ATTR_LAT "lat"
|
|
|
|
|
2011-09-21 00:04:34 -07:00
|
|
|
#define PINCH_ZOOM_MIN 0.25
|
|
|
|
#define PINCH_ZOOM_MAX 4.0
|
From: Kim Yunhan <spbear@gmail.com>
Subject: [E-devel] [elm_map] Fix up too many connections at the same
time.
Currently, elm_map requests all visible map image tile to map server
at the
same time.
If the scene is turned off while panning or zooming, it will be
aborted on
HTTP requests.
But it already sent to map server, and it already made useless HTTP
connections.
So if you pan scrolling quickly, elm_map try to download and abort too
many
HTTP
connections repeatedly.
If you have stable and high-throughput data connection, it doesn't
matter
on your side.
However map server will get high load, It is sufficient reason to block
you.
In another case, if you have poor data connection such as 3G
connection, it
has less
throughput and it causes delay of downloading. And finally, the device
is
as full as
HTTP connections even you already aborted. It makes low-performance
issue on
your device.
I wrote a patch for solving this situation.
The idea is simple.
1. I limited number of maximum HTTP request on elm_map side.
2. If maximum HTTP request is exceed, keep requests on Eina_List.
3. If each image downloading is completed, try to download recent
request.
(Because it has strong possibility for your screen)
4. At the same time, invisible request will be removed.
(It doesn't make HTTP connection yet)
I tested many times on my desktop and device.
It works for me. And elm_map's performance is improved
appreciably on 3G
connections.
SVN revision: 64685
2011-11-03 04:07:03 -07:00
|
|
|
#define MAX_CONCURRENT_DOWNLOAD 10
|
2011-04-21 01:55:02 -07:00
|
|
|
|
2011-05-19 22:55:15 -07:00
|
|
|
#define GPX_NAME "name>"
|
|
|
|
#define GPX_COORDINATES "trkpt "
|
|
|
|
#define GPX_LON "lon"
|
|
|
|
#define GPX_LAT "lat"
|
|
|
|
#define GPX_ELE "ele>"
|
|
|
|
#define GPX_TIME "time>"
|
|
|
|
|
2009-12-22 14:47:17 -08:00
|
|
|
// Map sources
|
|
|
|
// Currently the size of a tile must be 256*256
|
|
|
|
// and the size of the map must be pow(2.0, z)*tile_size
|
|
|
|
typedef struct _Map_Sources_Tab
|
|
|
|
{
|
|
|
|
const char *name;
|
|
|
|
int zoom_min;
|
|
|
|
int zoom_max;
|
2011-05-04 02:44:53 -07:00
|
|
|
ElmMapModuleUrlFunc url_cb;
|
2011-04-07 23:14:10 -07:00
|
|
|
Elm_Map_Route_Sources route_source;
|
2011-05-04 02:44:53 -07:00
|
|
|
ElmMapModuleRouteUrlFunc route_url_cb;
|
|
|
|
ElmMapModuleNameUrlFunc name_url_cb;
|
|
|
|
ElmMapModuleGeoIntoCoordFunc geo_into_coord;
|
|
|
|
ElmMapModuleCoordIntoGeoFunc coord_into_geo;
|
2009-12-22 14:47:17 -08:00
|
|
|
} Map_Sources_Tab;
|
|
|
|
|
|
|
|
//Zemm min is supposed to be 0
|
2011-01-10 21:48:28 -08:00
|
|
|
static char *_mapnik_url_cb(Evas_Object *obj __UNUSED__, int x, int y, int zoom);
|
|
|
|
static char *_osmarender_url_cb(Evas_Object *obj __UNUSED__, int x, int y, int zoom);
|
|
|
|
static char *_cyclemap_url_cb(Evas_Object *obj __UNUSED__, int x, int y, int zoom);
|
2011-12-05 01:00:04 -08:00
|
|
|
static char *_mapquest_url_cb(Evas_Object *obj __UNUSED__, int x, int y, int zoom);
|
|
|
|
static char *_mapquest_aerial_url_cb(Evas_Object *obj __UNUSED__, int x, int y, int zoom);
|
2011-01-10 21:48:28 -08:00
|
|
|
|
2011-04-07 23:14:10 -07:00
|
|
|
static char *_yours_url_cb(Evas_Object *obj __UNUSED__, char *type_name, int method, double flon, double flat, double tlon, double tlat);
|
2011-04-08 01:42:32 -07:00
|
|
|
/*
|
|
|
|
static char *_monav_url_cb(Evas_Object *obj __UNUSED__, char *type_name, int method, double flon, double flat, double tlon, double tlat)
|
2011-04-07 23:14:10 -07:00
|
|
|
static char *_ors_url_cb(Evas_Object *obj __UNUSED__, char *type_name, int method, double flon, double flat, double tlon, double tlat);
|
2011-04-08 01:42:32 -07:00
|
|
|
*/
|
2011-04-17 23:42:47 -07:00
|
|
|
static char *_nominatim_url_cb(Evas_Object *obj, int method, char *name, double lon, double lat);
|
2011-05-04 02:44:53 -07:00
|
|
|
|
|
|
|
static Map_Sources_Tab default_map_sources_tab[] =
|
|
|
|
{
|
|
|
|
{"Mapnik", 0, 18, _mapnik_url_cb, ELM_MAP_ROUTE_SOURCE_YOURS, _yours_url_cb, _nominatim_url_cb, NULL, NULL},
|
|
|
|
{"Osmarender", 0, 17, _osmarender_url_cb, ELM_MAP_ROUTE_SOURCE_YOURS, _yours_url_cb, _nominatim_url_cb, NULL, NULL},
|
2011-12-05 01:00:04 -08:00
|
|
|
{"CycleMap", 0, 16, _cyclemap_url_cb, ELM_MAP_ROUTE_SOURCE_YOURS, _yours_url_cb, _nominatim_url_cb, NULL, NULL},
|
|
|
|
{"MapQuest", 0, 18, _mapquest_url_cb, ELM_MAP_ROUTE_SOURCE_YOURS, _yours_url_cb, _nominatim_url_cb, NULL, NULL},
|
|
|
|
{"MapQuest Open Aerial", 0, 11, _mapquest_aerial_url_cb, ELM_MAP_ROUTE_SOURCE_YOURS, _yours_url_cb, _nominatim_url_cb, NULL, NULL},
|
2011-04-07 23:14:10 -07:00
|
|
|
};
|
|
|
|
|
|
|
|
struct _Url_Data
|
|
|
|
{
|
|
|
|
Ecore_Con_Url *con_url;
|
|
|
|
|
|
|
|
FILE *fd;
|
|
|
|
char *fname;
|
2009-12-22 14:47:17 -08:00
|
|
|
};
|
|
|
|
|
2009-12-20 08:34:45 -08:00
|
|
|
struct _Elm_Map_Marker_Class
|
|
|
|
{
|
|
|
|
const char *style;
|
|
|
|
int zoom_displayed;
|
|
|
|
|
2012-01-09 22:43:57 -08:00
|
|
|
struct _Elm_Map_Marker_Class_Func
|
|
|
|
{
|
2011-04-01 04:26:58 -07:00
|
|
|
ElmMapMarkerGetFunc get;
|
|
|
|
ElmMapMarkerDelFunc del; //if NULL the object will be destroyed with evas_object_del()
|
|
|
|
ElmMapMarkerIconGetFunc icon_get;
|
2012-01-09 22:43:57 -08:00
|
|
|
} func;
|
2009-12-20 08:34:45 -08:00
|
|
|
|
2012-01-09 22:43:57 -08:00
|
|
|
struct
|
|
|
|
{ //this part is private, do not modify these values
|
2011-04-01 04:26:58 -07:00
|
|
|
Eina_Bool set : 1;
|
|
|
|
Evas_Coord edje_w, edje_h;
|
2012-01-09 22:43:57 -08:00
|
|
|
} priv;
|
2009-12-20 08:34:45 -08:00
|
|
|
};
|
|
|
|
|
2009-11-15 07:53:37 -08:00
|
|
|
struct _Elm_Map_Marker
|
|
|
|
{
|
|
|
|
Widget_Data *wd;
|
2009-11-18 02:59:17 -08:00
|
|
|
Elm_Map_Marker_Class *clas;
|
2009-12-20 08:34:45 -08:00
|
|
|
Elm_Map_Group_Class *clas_group;
|
2009-11-15 07:53:37 -08:00
|
|
|
double longitude, latitude;
|
|
|
|
|
|
|
|
Evas_Coord map_size;
|
2011-05-21 06:13:53 -07:00
|
|
|
Evas_Coord *x, *y;
|
2009-11-15 07:53:37 -08:00
|
|
|
void *data;
|
2011-05-21 06:13:53 -07:00
|
|
|
Marker_Group **groups;
|
2009-11-15 07:53:37 -08:00
|
|
|
Evas_Object *content;
|
|
|
|
};
|
|
|
|
|
2009-12-20 08:34:45 -08:00
|
|
|
struct _Elm_Map_Group_Class
|
|
|
|
{
|
|
|
|
const char *style;
|
|
|
|
void *data;
|
2009-12-20 10:48:31 -08:00
|
|
|
int zoom_displayed; // display the group if the zoom is >= to zoom_display
|
|
|
|
int zoom_grouped; // group the markers only if the zoom is <= to zoom_groups
|
2009-12-20 12:40:55 -08:00
|
|
|
Eina_Bool hide : 1;
|
2009-12-20 08:34:45 -08:00
|
|
|
|
2012-01-09 22:43:57 -08:00
|
|
|
struct
|
|
|
|
{
|
2011-04-01 04:26:58 -07:00
|
|
|
ElmMapGroupIconGetFunc icon_get;
|
2012-01-09 22:43:57 -08:00
|
|
|
} func;
|
2011-04-01 04:26:58 -07:00
|
|
|
|
2012-01-09 22:43:57 -08:00
|
|
|
struct
|
|
|
|
{ //this part is private, do not modify these values
|
2011-04-01 04:26:58 -07:00
|
|
|
Eina_Bool set : 1;
|
|
|
|
Evas_Coord edje_w, edje_h;
|
|
|
|
Evas_Coord edje_max_w, edje_max_h;
|
|
|
|
|
|
|
|
Eina_List *objs_used;
|
|
|
|
Eina_List *objs_notused;
|
2012-01-09 22:43:57 -08:00
|
|
|
} priv;
|
2009-12-20 08:34:45 -08:00
|
|
|
};
|
|
|
|
|
2009-11-15 07:53:37 -08:00
|
|
|
struct _Marker_Group
|
|
|
|
{
|
|
|
|
Widget_Data *wd;
|
2009-12-18 06:28:36 -08:00
|
|
|
Eina_Matrixsparse_Cell *cell;
|
2009-12-20 08:34:45 -08:00
|
|
|
Elm_Map_Group_Class *clas;
|
2009-12-18 06:28:36 -08:00
|
|
|
|
2009-11-15 07:53:37 -08:00
|
|
|
Eina_List *markers;
|
2009-11-17 07:44:11 -08:00
|
|
|
long long sum_x, sum_y;
|
2009-11-15 07:53:37 -08:00
|
|
|
Evas_Coord x, y;
|
|
|
|
Evas_Coord w, h;
|
2009-12-20 08:34:45 -08:00
|
|
|
|
2009-11-15 08:24:02 -08:00
|
|
|
Evas_Object *obj, *bubble, *sc, *bx, *rect;
|
2009-11-15 07:53:37 -08:00
|
|
|
Eina_Bool open : 1;
|
2009-11-15 11:52:07 -08:00
|
|
|
Eina_Bool bringin : 1;
|
2009-12-18 12:16:37 -08:00
|
|
|
Eina_Bool update_nbelems : 1;
|
2009-12-20 08:34:45 -08:00
|
|
|
Eina_Bool update_resize : 1;
|
|
|
|
Eina_Bool update_raise : 1;
|
|
|
|
Eina_Bool delete_object : 1;
|
2009-11-15 07:53:37 -08:00
|
|
|
};
|
2009-11-13 07:22:23 -08:00
|
|
|
|
2011-04-07 23:14:10 -07:00
|
|
|
struct _Elm_Map_Route
|
|
|
|
{
|
|
|
|
Widget_Data *wd;
|
|
|
|
|
2011-05-19 22:55:15 -07:00
|
|
|
Path_Node *n;
|
|
|
|
Path_Waypoint *w;
|
2011-04-07 23:14:10 -07:00
|
|
|
Ecore_Con_Url *con_url;
|
|
|
|
|
|
|
|
int type;
|
|
|
|
int method;
|
|
|
|
int x, y;
|
|
|
|
double flon, flat, tlon, tlat;
|
|
|
|
|
|
|
|
Eina_List *nodes, *path;
|
|
|
|
Eina_List *waypoint;
|
|
|
|
|
2012-01-09 22:43:57 -08:00
|
|
|
struct
|
|
|
|
{
|
|
|
|
int node_count;
|
|
|
|
int waypoint_count;
|
|
|
|
const char *nodes;
|
|
|
|
const char *waypoints;
|
|
|
|
double distance; /* unit : km */
|
|
|
|
} info;
|
2011-04-07 23:14:10 -07:00
|
|
|
|
|
|
|
Eina_List *handlers;
|
|
|
|
Url_Data ud;
|
|
|
|
|
2012-01-09 22:43:57 -08:00
|
|
|
struct
|
|
|
|
{
|
|
|
|
int r;
|
|
|
|
int g;
|
|
|
|
int b;
|
|
|
|
int a;
|
|
|
|
} color;
|
2011-04-07 23:14:10 -07:00
|
|
|
|
|
|
|
Eina_Bool inbound : 1;
|
|
|
|
};
|
|
|
|
|
2011-05-19 22:55:15 -07:00
|
|
|
struct _Path_Node
|
2011-04-07 23:14:10 -07:00
|
|
|
{
|
|
|
|
Widget_Data *wd;
|
|
|
|
|
|
|
|
int idx;
|
2012-01-09 22:43:57 -08:00
|
|
|
struct
|
|
|
|
{
|
|
|
|
double lon, lat;
|
|
|
|
char *address;
|
|
|
|
} pos;
|
2011-04-07 23:14:10 -07:00
|
|
|
};
|
|
|
|
|
2011-05-19 22:55:15 -07:00
|
|
|
struct _Path_Waypoint
|
2011-04-07 23:14:10 -07:00
|
|
|
{
|
|
|
|
Widget_Data *wd;
|
|
|
|
|
|
|
|
const char *point;
|
|
|
|
};
|
|
|
|
|
2011-04-17 23:42:47 -07:00
|
|
|
struct _Elm_Map_Name
|
|
|
|
{
|
|
|
|
Widget_Data *wd;
|
|
|
|
|
|
|
|
Ecore_Con_Url *con_url;
|
|
|
|
int method;
|
|
|
|
char *address;
|
|
|
|
double lon, lat;
|
|
|
|
Url_Data ud;
|
|
|
|
Ecore_Event_Handler *handler;
|
|
|
|
};
|
|
|
|
|
2009-11-13 07:22:23 -08:00
|
|
|
struct _Grid_Item
|
|
|
|
{
|
|
|
|
Widget_Data *wd;
|
From: Kim Yunhan <spbear@gmail.com>
Subject: [E-devel] [elm_map] Fix up too many connections at the same
time.
Currently, elm_map requests all visible map image tile to map server
at the
same time.
If the scene is turned off while panning or zooming, it will be
aborted on
HTTP requests.
But it already sent to map server, and it already made useless HTTP
connections.
So if you pan scrolling quickly, elm_map try to download and abort too
many
HTTP
connections repeatedly.
If you have stable and high-throughput data connection, it doesn't
matter
on your side.
However map server will get high load, It is sufficient reason to block
you.
In another case, if you have poor data connection such as 3G
connection, it
has less
throughput and it causes delay of downloading. And finally, the device
is
as full as
HTTP connections even you already aborted. It makes low-performance
issue on
your device.
I wrote a patch for solving this situation.
The idea is simple.
1. I limited number of maximum HTTP request on elm_map side.
2. If maximum HTTP request is exceed, keep requests on Eina_List.
3. If each image downloading is completed, try to download recent
request.
(Because it has strong possibility for your screen)
4. At the same time, invisible request will be removed.
(It doesn't make HTTP connection yet)
I tested many times on my desktop and device.
It works for me. And elm_map's performance is improved
appreciably on 3G
connections.
SVN revision: 64685
2011-11-03 04:07:03 -07:00
|
|
|
Grid *g;
|
2011-12-12 19:48:18 -08:00
|
|
|
int zoom;
|
2009-11-15 07:53:37 -08:00
|
|
|
Evas_Object *img;
|
|
|
|
//Evas_Object *txt;
|
2009-11-14 05:58:22 -08:00
|
|
|
const char *file;
|
From: Kim Yunhan <spbear@gmail.com>
Subject: [E-devel] [elm_map] Fix up too many connections at the same
time.
Currently, elm_map requests all visible map image tile to map server
at the
same time.
If the scene is turned off while panning or zooming, it will be
aborted on
HTTP requests.
But it already sent to map server, and it already made useless HTTP
connections.
So if you pan scrolling quickly, elm_map try to download and abort too
many
HTTP
connections repeatedly.
If you have stable and high-throughput data connection, it doesn't
matter
on your side.
However map server will get high load, It is sufficient reason to block
you.
In another case, if you have poor data connection such as 3G
connection, it
has less
throughput and it causes delay of downloading. And finally, the device
is
as full as
HTTP connections even you already aborted. It makes low-performance
issue on
your device.
I wrote a patch for solving this situation.
The idea is simple.
1. I limited number of maximum HTTP request on elm_map side.
2. If maximum HTTP request is exceed, keep requests on Eina_List.
3. If each image downloading is completed, try to download recent
request.
(Because it has strong possibility for your screen)
4. At the same time, invisible request will be removed.
(It doesn't make HTTP connection yet)
I tested many times on my desktop and device.
It works for me. And elm_map's performance is improved
appreciably on 3G
connections.
SVN revision: 64685
2011-11-03 04:07:03 -07:00
|
|
|
const char *source;
|
2012-01-09 22:43:57 -08:00
|
|
|
struct
|
|
|
|
{
|
2011-04-01 04:26:58 -07:00
|
|
|
int x, y, w, h;
|
2012-01-09 22:43:57 -08:00
|
|
|
} src, out;
|
2011-12-04 23:30:31 -08:00
|
|
|
|
2011-12-13 00:31:55 -08:00
|
|
|
Eina_Bool file_have : 1;
|
2009-11-13 09:34:20 -08:00
|
|
|
Ecore_File_Download_Job *job;
|
2009-11-14 05:58:22 -08:00
|
|
|
int try_num;
|
2009-11-13 07:22:23 -08:00
|
|
|
};
|
|
|
|
|
|
|
|
struct _Grid
|
|
|
|
{
|
|
|
|
Widget_Data *wd;
|
|
|
|
int tsize; // size of tile (tsize x tsize pixels)
|
|
|
|
int zoom; // zoom level tiles want for optimal display (1, 2, 4, 8)
|
|
|
|
int iw, ih; // size of image in pixels
|
|
|
|
int w, h; // size of grid image in pixels (represented by grid)
|
|
|
|
int gw, gh; // size of grid in tiles
|
|
|
|
Eina_Matrixsparse *grid;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct _Widget_Data
|
|
|
|
{
|
|
|
|
Evas_Object *obj;
|
|
|
|
Evas_Object *scr;
|
2011-12-20 22:12:08 -08:00
|
|
|
Evas_Object *ges;
|
2009-11-13 07:22:23 -08:00
|
|
|
Evas_Object *pan_smart;
|
|
|
|
Evas_Object *rect;
|
2010-06-30 12:26:53 -07:00
|
|
|
Evas_Object *sep_maps_markers; //map objects are below this object and marker objects are on top
|
2009-11-13 07:22:23 -08:00
|
|
|
Pan *pan;
|
|
|
|
Evas_Coord pan_x, pan_y, minw, minh;
|
|
|
|
|
2010-03-09 08:27:46 -08:00
|
|
|
int id;
|
2009-11-13 07:22:23 -08:00
|
|
|
int zoom;
|
2011-04-25 01:11:46 -07:00
|
|
|
int zoom_method;
|
2009-11-13 07:22:23 -08:00
|
|
|
Elm_Map_Zoom_Mode mode;
|
|
|
|
|
|
|
|
Ecore_Job *calc_job;
|
|
|
|
Ecore_Timer *scr_timer;
|
|
|
|
Ecore_Timer *long_timer;
|
|
|
|
Ecore_Animator *zoom_animator;
|
2011-05-05 08:15:43 -07:00
|
|
|
double t;
|
2012-01-09 22:43:57 -08:00
|
|
|
struct
|
|
|
|
{
|
2011-04-01 04:26:58 -07:00
|
|
|
int w, h;
|
|
|
|
int ow, oh, nw, nh;
|
2012-01-09 22:43:57 -08:00
|
|
|
struct
|
|
|
|
{
|
2011-04-01 04:26:58 -07:00
|
|
|
double x, y;
|
2012-01-09 22:43:57 -08:00
|
|
|
} spos;
|
|
|
|
} size;
|
|
|
|
struct
|
|
|
|
{
|
2011-04-01 04:26:58 -07:00
|
|
|
Eina_Bool show : 1;
|
|
|
|
Evas_Coord x, y ,w ,h;
|
2012-01-09 22:43:57 -08:00
|
|
|
} show;
|
2009-11-13 07:22:23 -08:00
|
|
|
int tsize;
|
|
|
|
int nosmooth;
|
|
|
|
Eina_List *grids;
|
|
|
|
Eina_Bool resized : 1;
|
|
|
|
Eina_Bool on_hold : 1;
|
|
|
|
Eina_Bool paused : 1;
|
2009-12-18 13:28:06 -08:00
|
|
|
Eina_Bool paused_markers : 1;
|
2011-04-01 04:26:58 -07:00
|
|
|
|
2012-01-09 22:43:57 -08:00
|
|
|
struct
|
|
|
|
{
|
2011-04-01 04:26:58 -07:00
|
|
|
Eina_Bool enabled;
|
|
|
|
double lon, lat;
|
2012-01-09 22:43:57 -08:00
|
|
|
} center_on;
|
2009-11-15 13:36:44 -08:00
|
|
|
|
2009-11-16 13:32:33 -08:00
|
|
|
Ecore_Job *markers_place_job;
|
2011-05-21 06:13:53 -07:00
|
|
|
Eina_Matrixsparse **markers;
|
2009-12-18 09:45:47 -08:00
|
|
|
Eina_List *cells_displayed; // list of Eina_Matrixsparse_Cell
|
2009-11-18 13:07:01 -08:00
|
|
|
Evas_Coord markers_max_num;
|
2009-12-20 08:34:45 -08:00
|
|
|
int marker_max_w, marker_max_h;
|
2009-11-15 07:53:37 -08:00
|
|
|
int marker_zoom;
|
2009-11-21 14:38:07 -08:00
|
|
|
Eina_List *opened_bubbles; //opened bubbles, list of Map_Group *
|
2009-12-20 08:34:45 -08:00
|
|
|
|
|
|
|
Eina_List *groups_clas; // list of Elm_Map_Group_Class*
|
|
|
|
Eina_List *markers_clas; // list of Elm_Map_Markers_Class*
|
2009-12-22 14:47:17 -08:00
|
|
|
|
2011-04-07 23:14:10 -07:00
|
|
|
Elm_Map_Route_Sources route_source;
|
2011-01-05 19:43:51 -08:00
|
|
|
Eina_List *s_event_list;
|
2011-01-10 21:48:28 -08:00
|
|
|
int try_num;
|
|
|
|
int finish_num;
|
2011-02-27 01:00:22 -08:00
|
|
|
|
|
|
|
Eina_Hash *ua;
|
|
|
|
const char *user_agent;
|
2011-04-07 23:14:10 -07:00
|
|
|
Eina_List *route;
|
2011-05-19 22:55:15 -07:00
|
|
|
Eina_List *track;
|
2011-04-17 23:42:47 -07:00
|
|
|
Evas_Event_Mouse_Down ev;
|
|
|
|
Eina_List *names;
|
2011-04-21 01:55:02 -07:00
|
|
|
int multi_count;
|
|
|
|
|
2012-01-09 22:43:57 -08:00
|
|
|
struct
|
|
|
|
{
|
2011-04-21 01:55:02 -07:00
|
|
|
Evas_Coord cx, cy;
|
|
|
|
double level, diff;
|
2012-01-09 22:43:57 -08:00
|
|
|
} pinch;
|
2011-04-21 01:55:02 -07:00
|
|
|
|
2012-01-09 22:43:57 -08:00
|
|
|
struct
|
|
|
|
{
|
2011-04-21 01:55:02 -07:00
|
|
|
Evas_Coord cx, cy;
|
|
|
|
double a, d;
|
2012-01-09 22:43:57 -08:00
|
|
|
} rotate;
|
2011-04-21 01:55:02 -07:00
|
|
|
|
2011-12-20 22:12:08 -08:00
|
|
|
int wheel_diff;
|
2011-04-27 19:47:12 -07:00
|
|
|
Eina_Bool wheel_disabled : 1;
|
2011-12-20 22:12:08 -08:00
|
|
|
Eina_Bool scr_started : 1;
|
2009-11-13 07:22:23 -08:00
|
|
|
|
2011-05-04 02:44:53 -07:00
|
|
|
Eina_Array *modules;
|
|
|
|
Eina_List *map_sources_tab;
|
|
|
|
const char **source_names;
|
2011-05-06 23:32:34 -07:00
|
|
|
Evas_Map *map;
|
2011-05-07 06:37:31 -07:00
|
|
|
Ecore_Timer *zoom_timer;
|
2011-05-11 08:23:35 -07:00
|
|
|
Map_Sources_Tab *src;
|
2011-05-19 22:55:15 -07:00
|
|
|
const char *gpx_file;
|
2011-05-21 06:13:53 -07:00
|
|
|
int zoom_min, zoom_max;
|
From: Kim Yunhan <spbear@gmail.com>
Subject: [E-devel] [elm_map] Fix up too many connections at the same
time.
Currently, elm_map requests all visible map image tile to map server
at the
same time.
If the scene is turned off while panning or zooming, it will be
aborted on
HTTP requests.
But it already sent to map server, and it already made useless HTTP
connections.
So if you pan scrolling quickly, elm_map try to download and abort too
many
HTTP
connections repeatedly.
If you have stable and high-throughput data connection, it doesn't
matter
on your side.
However map server will get high load, It is sufficient reason to block
you.
In another case, if you have poor data connection such as 3G
connection, it
has less
throughput and it causes delay of downloading. And finally, the device
is
as full as
HTTP connections even you already aborted. It makes low-performance
issue on
your device.
I wrote a patch for solving this situation.
The idea is simple.
1. I limited number of maximum HTTP request on elm_map side.
2. If maximum HTTP request is exceed, keep requests on Eina_List.
3. If each image downloading is completed, try to download recent
request.
(Because it has strong possibility for your screen)
4. At the same time, invisible request will be removed.
(It doesn't make HTTP connection yet)
I tested many times on my desktop and device.
It works for me. And elm_map's performance is improved
appreciably on 3G
connections.
SVN revision: 64685
2011-11-03 04:07:03 -07:00
|
|
|
Eina_List *download_list;
|
|
|
|
int download_num;
|
2010-12-21 01:14:47 -08:00
|
|
|
};
|
2011-05-04 02:44:53 -07:00
|
|
|
|
2009-11-13 07:22:23 -08:00
|
|
|
struct _Pan
|
|
|
|
{
|
|
|
|
Evas_Object_Smart_Clipped_Data __clipped_data;
|
|
|
|
Widget_Data *wd;
|
|
|
|
};
|
|
|
|
|
2011-01-05 19:43:51 -08:00
|
|
|
struct _Event
|
|
|
|
{
|
|
|
|
int device;
|
2011-04-01 04:26:58 -07:00
|
|
|
|
2012-01-09 22:43:57 -08:00
|
|
|
struct
|
|
|
|
{
|
2011-04-21 01:55:02 -07:00
|
|
|
Evas_Coord x, y;
|
2012-01-09 22:43:57 -08:00
|
|
|
} start;
|
2011-04-21 01:55:02 -07:00
|
|
|
|
2012-01-09 22:43:57 -08:00
|
|
|
struct
|
|
|
|
{
|
2011-04-01 04:26:58 -07:00
|
|
|
Evas_Coord x, y;
|
2012-01-09 22:43:57 -08:00
|
|
|
} prev;
|
2011-04-01 04:26:58 -07:00
|
|
|
|
2011-01-05 19:43:51 -08:00
|
|
|
Evas_Coord x, y, w, h;
|
2011-04-01 04:26:58 -07:00
|
|
|
|
2011-01-05 19:43:51 -08:00
|
|
|
Evas_Object *object;
|
2011-04-01 04:26:58 -07:00
|
|
|
|
2011-04-21 01:55:02 -07:00
|
|
|
int pinch_start_dis;
|
2011-01-05 19:43:51 -08:00
|
|
|
int pinch_dis;
|
|
|
|
};
|
|
|
|
|
2011-04-07 23:14:10 -07:00
|
|
|
struct _Route_Dump
|
|
|
|
{
|
|
|
|
int id;
|
|
|
|
char *fname;
|
|
|
|
double distance;
|
|
|
|
char *description;
|
|
|
|
char *coordinates;
|
|
|
|
};
|
|
|
|
|
|
|
|
enum _Route_Xml_Attribute
|
|
|
|
{
|
|
|
|
ROUTE_XML_NONE,
|
|
|
|
ROUTE_XML_DISTANCE,
|
|
|
|
ROUTE_XML_DESCRIPTION,
|
|
|
|
ROUTE_XML_COORDINATES,
|
|
|
|
ROUTE_XML_LAST
|
|
|
|
} Route_Xml_Attibute;
|
|
|
|
|
2011-04-17 23:42:47 -07:00
|
|
|
struct _Name_Dump
|
|
|
|
{
|
|
|
|
int id;
|
|
|
|
char *address;
|
|
|
|
double lon;
|
|
|
|
double lat;
|
|
|
|
};
|
|
|
|
|
|
|
|
enum _Name_Xml_Attribute
|
|
|
|
{
|
|
|
|
NAME_XML_NONE,
|
|
|
|
NAME_XML_NAME,
|
|
|
|
NAME_XML_LON,
|
|
|
|
NAME_XML_LAT,
|
|
|
|
NAME_XML_LAST
|
|
|
|
} Name_Xml_Attibute;
|
|
|
|
|
2011-04-25 01:11:46 -07:00
|
|
|
enum _Zoom_Method
|
|
|
|
{
|
|
|
|
ZOOM_METHOD_NONE,
|
|
|
|
ZOOM_METHOD_IN,
|
|
|
|
ZOOM_METHOD_OUT,
|
|
|
|
ZOOM_METHOD_LAST
|
|
|
|
} Zoom_Mode;
|
|
|
|
|
2011-05-19 22:55:15 -07:00
|
|
|
enum _Track_Xml_Attribute
|
|
|
|
{
|
|
|
|
TRACK_XML_NONE,
|
|
|
|
TRACK_XML_COORDINATES,
|
|
|
|
TRACK_XML_LAST
|
|
|
|
} Track_Xml_Attibute;
|
|
|
|
|
2011-12-20 22:12:08 -08:00
|
|
|
static Evas_Smart_Class _pan_sc = EVAS_SMART_CLASS_INIT_NULL;
|
2010-03-08 22:15:39 -08:00
|
|
|
static const char *widtype = NULL;
|
2011-12-20 22:12:08 -08:00
|
|
|
static int idnum = 1;
|
2010-04-05 12:21:22 -07:00
|
|
|
|
|
|
|
static const char SIG_CHANGED[] = "changed";
|
|
|
|
static const char SIG_CLICKED[] = "clicked";
|
|
|
|
static const char SIG_CLICKED_DOUBLE[] = "clicked,double";
|
|
|
|
static const char SIG_LOADED_DETAIL[] = "loaded,detail";
|
|
|
|
static const char SIG_LOAD_DETAIL[] = "load,detail";
|
|
|
|
static const char SIG_LONGPRESSED[] = "longpressed";
|
|
|
|
static const char SIG_PRESS[] = "press";
|
|
|
|
static const char SIG_SCROLL[] = "scroll";
|
|
|
|
static const char SIG_SCROLL_DRAG_START[] = "scroll,drag,start";
|
|
|
|
static const char SIG_SCROLL_DRAG_STOP[] = "scroll,drag,stop";
|
|
|
|
static const char SIG_ZOOM_CHANGE[] = "zoom,change";
|
|
|
|
static const char SIG_ZOOM_START[] = "zoom,start";
|
|
|
|
static const char SIG_ZOOM_STOP[] = "zoom,stop";
|
2011-01-10 21:48:28 -08:00
|
|
|
static const char SIG_DOWNLOADED[] = "downloaded";
|
2011-04-07 23:14:10 -07:00
|
|
|
static const char SIG_ROUTE_LOAD[] = "route,load";
|
|
|
|
static const char SIG_ROUTE_LOADED[] = "route,loaded";
|
2011-04-17 23:42:47 -07:00
|
|
|
static const char SIG_NAME_LOAD[] = "name,load";
|
|
|
|
static const char SIG_NAME_LOADED[] = "name,loaded";
|
2010-04-05 12:21:22 -07:00
|
|
|
static const Evas_Smart_Cb_Description _signals[] = {
|
2011-04-01 04:26:58 -07:00
|
|
|
{SIG_CHANGED, ""},
|
|
|
|
{SIG_CLICKED, ""},
|
|
|
|
{SIG_CLICKED_DOUBLE, ""},
|
|
|
|
{SIG_LOADED_DETAIL, ""},
|
|
|
|
{SIG_LOAD_DETAIL, ""},
|
|
|
|
{SIG_LONGPRESSED, ""},
|
|
|
|
{SIG_PRESS, ""},
|
|
|
|
{SIG_SCROLL, ""},
|
|
|
|
{SIG_SCROLL_DRAG_START, ""},
|
|
|
|
{SIG_SCROLL_DRAG_STOP, ""},
|
|
|
|
{SIG_ZOOM_CHANGE, ""},
|
|
|
|
{SIG_ZOOM_START, ""},
|
|
|
|
{SIG_ZOOM_STOP, ""},
|
|
|
|
{SIG_DOWNLOADED, ""},
|
2011-04-07 23:14:10 -07:00
|
|
|
{SIG_ROUTE_LOAD, ""},
|
|
|
|
{SIG_ROUTE_LOADED, ""},
|
2011-04-17 23:42:47 -07:00
|
|
|
{SIG_NAME_LOAD, ""},
|
|
|
|
{SIG_NAME_LOADED, ""},
|
2011-04-01 04:26:58 -07:00
|
|
|
{NULL, NULL}
|
2010-04-05 12:21:22 -07:00
|
|
|
};
|
|
|
|
|
2009-11-17 07:44:11 -08:00
|
|
|
static void _pan_calculate(Evas_Object *obj);
|
|
|
|
|
2011-01-05 19:43:51 -08:00
|
|
|
static void _rect_resize_cb(void *data, Evas *e, Evas_Object *obj, void *event_info);
|
2009-11-13 07:22:23 -08:00
|
|
|
static void _del_hook(Evas_Object *obj);
|
|
|
|
static void _theme_hook(Evas_Object *obj);
|
2010-09-29 05:22:30 -07:00
|
|
|
static void _on_focus_hook(void *data, Evas_Object *obj);
|
2009-11-13 07:22:23 -08:00
|
|
|
static void _sizing_eval(Evas_Object *obj);
|
|
|
|
static void _calc_job(void *data);
|
2011-01-04 00:45:27 -08:00
|
|
|
static Eina_Bool _event_hook(Evas_Object *obj, Evas_Object *src,
|
|
|
|
Evas_Callback_Type type, void *event_info);
|
2009-11-13 07:22:23 -08:00
|
|
|
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);
|
|
|
|
static void grid_load(Evas_Object *obj, Grid *g);
|
|
|
|
|
From: Kim Yunhan <spbear@gmail.com>
Subject: [E-devel] [elm_map] Fix up too many connections at the same
time.
Currently, elm_map requests all visible map image tile to map server
at the
same time.
If the scene is turned off while panning or zooming, it will be
aborted on
HTTP requests.
But it already sent to map server, and it already made useless HTTP
connections.
So if you pan scrolling quickly, elm_map try to download and abort too
many
HTTP
connections repeatedly.
If you have stable and high-throughput data connection, it doesn't
matter
on your side.
However map server will get high load, It is sufficient reason to block
you.
In another case, if you have poor data connection such as 3G
connection, it
has less
throughput and it causes delay of downloading. And finally, the device
is
as full as
HTTP connections even you already aborted. It makes low-performance
issue on
your device.
I wrote a patch for solving this situation.
The idea is simple.
1. I limited number of maximum HTTP request on elm_map side.
2. If maximum HTTP request is exceed, keep requests on Eina_List.
3. If each image downloading is completed, try to download recent
request.
(Because it has strong possibility for your screen)
4. At the same time, invisible request will be removed.
(It doesn't make HTTP connection yet)
I tested many times on my desktop and device.
It works for me. And elm_map's performance is improved
appreciably on 3G
connections.
SVN revision: 64685
2011-11-03 04:07:03 -07:00
|
|
|
static void _process_download_list(Evas_Object *obj);
|
|
|
|
static void _add_download_list(Evas_Object *obj, Grid_Item *gi);
|
2009-11-15 07:53:37 -08:00
|
|
|
|
2009-11-21 14:38:07 -08:00
|
|
|
static void _group_object_create(Marker_Group *group);
|
|
|
|
static void _group_object_free(Marker_Group *group);
|
2009-11-15 07:53:37 -08:00
|
|
|
static void _group_open_cb(void *data, Evas_Object *obj, const char *emission, const char *soure);
|
2009-11-15 11:52:07 -08:00
|
|
|
static void _group_bringin_cb(void *data, Evas_Object *obj, const char *emission, const char *soure);
|
2009-11-15 07:53:37 -08:00
|
|
|
static void _group_bubble_create(Marker_Group *group);
|
|
|
|
static void _group_bubble_free(Marker_Group *group);
|
|
|
|
static void _group_bubble_place(Marker_Group *group);
|
|
|
|
|
2009-12-21 09:01:19 -08:00
|
|
|
static int _group_bubble_content_update(Marker_Group *group);
|
2009-11-15 07:53:37 -08:00
|
|
|
static void _group_bubble_content_free(Marker_Group *group);
|
|
|
|
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);
|
2011-10-30 17:15:10 -07:00
|
|
|
static void _bubble_sc_hints_changed_cb(void *data, Evas *e, Evas_Object *obj, void *event_info);
|
2009-11-15 07:53:37 -08:00
|
|
|
|
2011-01-05 19:43:51 -08:00
|
|
|
static void _mouse_down(void *data, Evas *evas, Evas_Object *obj, void *event_info);
|
|
|
|
static void _mouse_up(void *data, Evas *evas, Evas_Object *obj, void *event_info);
|
|
|
|
|
2011-04-07 23:14:10 -07:00
|
|
|
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);
|
2011-05-19 22:55:15 -07:00
|
|
|
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);
|
2011-04-07 23:14:10 -07:00
|
|
|
|
2011-05-04 02:44:53 -07:00
|
|
|
static Eina_Bool
|
|
|
|
module_list_cb(Eina_Module *m, void *data)
|
2010-12-21 01:14:47 -08:00
|
|
|
{
|
2011-05-04 02:44:53 -07:00
|
|
|
ELM_CHECK_WIDTYPE(data, widtype) EINA_FALSE;
|
|
|
|
Widget_Data *wd = elm_widget_data_get(data);
|
|
|
|
Map_Sources_Tab *s;
|
|
|
|
ElmMapModuleSourceFunc source;
|
|
|
|
ElmMapModuleZoomMinFunc zoom_min;
|
|
|
|
ElmMapModuleZoomMaxFunc zoom_max;
|
|
|
|
ElmMapModuleUrlFunc url;
|
|
|
|
ElmMapModuleRouteSourceFunc route_source;
|
|
|
|
ElmMapModuleRouteUrlFunc route_url;
|
|
|
|
ElmMapModuleNameUrlFunc name_url;
|
|
|
|
ElmMapModuleGeoIntoCoordFunc geo_into_coord;
|
|
|
|
ElmMapModuleCoordIntoGeoFunc coord_into_geo;
|
|
|
|
const char *file;
|
2010-12-21 01:14:47 -08:00
|
|
|
|
2011-05-04 02:44:53 -07:00
|
|
|
if (!wd) return EINA_FALSE;
|
|
|
|
|
|
|
|
file = eina_module_file_get(m);
|
|
|
|
if (!eina_module_load(m))
|
|
|
|
{
|
|
|
|
ERR("could not load module \"%s\": %s", file, eina_error_msg_get(eina_error_get()));
|
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
source = eina_module_symbol_get(m, "map_module_source_get");
|
|
|
|
zoom_min = eina_module_symbol_get(m, "map_module_zoom_min_get");
|
|
|
|
zoom_max = eina_module_symbol_get(m, "map_module_zoom_max_get");
|
|
|
|
url = eina_module_symbol_get(m, "map_module_url_get");
|
|
|
|
route_source = eina_module_symbol_get(m, "map_module_route_source_get");
|
|
|
|
route_url = eina_module_symbol_get(m, "map_module_route_url_get");
|
|
|
|
name_url = eina_module_symbol_get(m, "map_module_name_url_get");
|
|
|
|
geo_into_coord = eina_module_symbol_get(m, "map_module_geo_into_coord");
|
|
|
|
coord_into_geo = eina_module_symbol_get(m, "map_module_coord_into_geo");
|
|
|
|
if ((!source) || (!zoom_min) || (!zoom_max) || (!url) || (!route_source) || (!route_url) || (!name_url) || (!geo_into_coord) || (!coord_into_geo))
|
|
|
|
{
|
2011-12-13 00:31:55 -08:00
|
|
|
WRN("could not find map_module_source_get() in module \"%s\": %s", file, eina_error_msg_get(eina_error_get()));
|
2011-05-04 02:44:53 -07:00
|
|
|
eina_module_unload(m);
|
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
|
|
|
s = calloc(1, sizeof(Map_Sources_Tab));
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(s, EINA_FALSE);
|
|
|
|
s->name = source();
|
|
|
|
s->zoom_min = zoom_min();
|
|
|
|
s->zoom_max = zoom_max();
|
|
|
|
s->url_cb = url;
|
|
|
|
s->route_source = route_source();
|
|
|
|
s->route_url_cb = route_url;
|
|
|
|
s->name_url_cb = name_url;
|
|
|
|
s->geo_into_coord = geo_into_coord;
|
|
|
|
s->coord_into_geo = coord_into_geo;
|
|
|
|
wd->map_sources_tab = eina_list_append(wd->map_sources_tab, s);
|
|
|
|
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
module_init(void *data)
|
|
|
|
{
|
|
|
|
ELM_CHECK_WIDTYPE(data, widtype);
|
|
|
|
Widget_Data *wd = elm_widget_data_get(data);
|
|
|
|
|
|
|
|
if (!wd) return;
|
|
|
|
wd->modules = eina_module_list_get(wd->modules, MODULES_PATH, 1, &module_list_cb, data);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
source_init(void *data)
|
|
|
|
{
|
|
|
|
ELM_CHECK_WIDTYPE(data, widtype);
|
|
|
|
Widget_Data *wd = elm_widget_data_get(data);
|
|
|
|
Map_Sources_Tab *s;
|
|
|
|
Eina_List *l;
|
2011-12-05 01:00:04 -08:00
|
|
|
unsigned int idx;
|
2011-05-04 02:44:53 -07:00
|
|
|
|
|
|
|
if (!wd) return;
|
2011-12-05 01:00:04 -08:00
|
|
|
for (idx = 0; idx < sizeof(default_map_sources_tab)/sizeof(Map_Sources_Tab); idx++)
|
2011-05-04 02:44:53 -07:00
|
|
|
{
|
|
|
|
s = calloc(1, sizeof(Map_Sources_Tab));
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN(s);
|
|
|
|
s->name = default_map_sources_tab[idx].name;
|
|
|
|
s->zoom_min = default_map_sources_tab[idx].zoom_min;
|
|
|
|
s->zoom_max = default_map_sources_tab[idx].zoom_max;
|
|
|
|
s->url_cb = default_map_sources_tab[idx].url_cb;
|
|
|
|
s->route_source = default_map_sources_tab[idx].route_source;
|
|
|
|
s->route_url_cb = default_map_sources_tab[idx].route_url_cb;
|
|
|
|
s->name_url_cb = default_map_sources_tab[idx].name_url_cb;
|
|
|
|
s->geo_into_coord = default_map_sources_tab[idx].geo_into_coord;
|
|
|
|
s->coord_into_geo = default_map_sources_tab[idx].coord_into_geo;
|
|
|
|
wd->map_sources_tab = eina_list_append(wd->map_sources_tab, s);
|
2011-05-11 08:23:35 -07:00
|
|
|
if (!idx) wd->src = s;
|
2011-05-04 02:44:53 -07:00
|
|
|
}
|
|
|
|
module_init(data);
|
|
|
|
|
|
|
|
int n = eina_list_count(wd->map_sources_tab);
|
|
|
|
wd->source_names = malloc(sizeof(char *) * (n + 1));
|
|
|
|
if (!wd->source_names)
|
|
|
|
{
|
|
|
|
ERR("init source names failed.");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
idx = 0;
|
|
|
|
EINA_LIST_FOREACH(wd->map_sources_tab, l, s)
|
|
|
|
{
|
|
|
|
wd->source_names[idx] = strdup(s->name);
|
|
|
|
INF("source : %s", wd->source_names[idx]);
|
2011-11-30 19:54:52 -08:00
|
|
|
if (s->zoom_min < wd->zoom_min) wd->zoom_min = s->zoom_min;
|
|
|
|
if (s->zoom_max > wd->zoom_max) wd->zoom_max = s->zoom_max;
|
2011-05-04 02:44:53 -07:00
|
|
|
idx++;
|
|
|
|
}
|
|
|
|
wd->source_names[idx] = NULL;
|
2010-12-21 01:14:47 -08:00
|
|
|
}
|
|
|
|
|
2011-04-21 01:55:02 -07:00
|
|
|
static void
|
|
|
|
obj_rotate_zoom(void *data, Evas_Object *obj)
|
|
|
|
{
|
|
|
|
ELM_CHECK_WIDTYPE(data, widtype);
|
|
|
|
Widget_Data *wd = elm_widget_data_get(data);
|
2011-09-21 03:44:06 -07:00
|
|
|
int ow, oh, iw, ih;
|
2011-04-21 01:55:02 -07:00
|
|
|
if ((!wd->pinch.cx) && (!wd->pinch.cy))
|
|
|
|
{
|
|
|
|
wd->pinch.cx = wd->rotate.cx;
|
|
|
|
wd->pinch.cy = wd->rotate.cy;
|
|
|
|
}
|
|
|
|
|
2011-05-06 23:32:34 -07:00
|
|
|
evas_map_util_points_populate_from_object_full(wd->map, obj, 0);
|
2011-09-20 23:20:28 -07:00
|
|
|
evas_object_image_size_get(obj, &iw, &ih);
|
|
|
|
evas_object_geometry_get(obj, NULL, NULL, &ow, &oh);
|
2011-09-21 03:44:06 -07:00
|
|
|
if ((ow < iw) || (oh < ih))
|
2011-09-20 23:20:28 -07:00
|
|
|
{
|
|
|
|
ow *= (double)iw / ow;
|
|
|
|
oh *= (double)ih / oh;
|
|
|
|
evas_map_point_image_uv_set(wd->map, 1, ow, 0);
|
|
|
|
evas_map_point_image_uv_set(wd->map, 2, ow, oh);
|
|
|
|
evas_map_point_image_uv_set(wd->map, 3, 0, oh);
|
|
|
|
}
|
2011-05-06 23:32:34 -07:00
|
|
|
evas_map_util_zoom(wd->map, wd->pinch.level, wd->pinch.level, wd->pinch.cx, wd->pinch.cy);
|
|
|
|
evas_map_util_rotate(wd->map, wd->rotate.d, wd->rotate.cx, wd->rotate.cy);
|
2011-04-21 01:55:02 -07:00
|
|
|
evas_object_map_enable_set(obj, EINA_TRUE);
|
2011-05-06 23:32:34 -07:00
|
|
|
evas_object_map_set(obj, wd->map);
|
2011-04-21 01:55:02 -07:00
|
|
|
}
|
|
|
|
|
2011-05-19 22:55:15 -07:00
|
|
|
static void
|
2011-06-27 23:58:35 -07:00
|
|
|
#ifdef ELM_EMAP
|
2011-05-19 22:55:15 -07:00
|
|
|
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)
|
2011-06-27 23:58:35 -07:00
|
|
|
#else
|
|
|
|
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__)
|
|
|
|
#endif
|
2011-05-19 22:55:15 -07:00
|
|
|
{
|
2011-06-25 10:48:55 -07:00
|
|
|
#ifdef ELM_EMAP
|
2011-05-19 22:55:15 -07:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
2011-06-26 10:36:18 -07:00
|
|
|
Eina_List *l;
|
|
|
|
Evas_Object *route;
|
|
|
|
int xmin, xmax, ymin, ymax;
|
2011-05-19 22:55:15 -07:00
|
|
|
|
|
|
|
if (!wd) return;
|
|
|
|
Evas_Coord size = pow(2.0, wd->zoom)*wd->tsize;
|
|
|
|
|
2011-06-26 10:36:18 -07:00
|
|
|
EINA_LIST_FOREACH(wd->track, l, route)
|
2011-05-19 22:55:15 -07:00
|
|
|
{
|
2011-06-26 10:36:18 -07:00
|
|
|
elm_map_utils_convert_geo_into_coord(wd->obj, elm_route_lon_min_get(route), elm_route_lat_max_get(route), size, &xmin, &ymin);
|
|
|
|
elm_map_utils_convert_geo_into_coord(wd->obj, elm_route_lon_max_get(route), elm_route_lat_min_get(route), size, &xmax, &ymax);
|
2011-06-25 07:30:10 -07:00
|
|
|
|
2011-06-26 10:36:18 -07:00
|
|
|
if( !(xmin < px && xmax < px) && !(xmin > px+ow && xmax > px+ow))
|
|
|
|
{
|
|
|
|
if( !(ymin < py && ymax < py) && !(ymin > py+oh && ymax > py+oh))
|
|
|
|
{
|
|
|
|
//display the route
|
|
|
|
evas_object_move(route, xmin - px + ox, ymin - py + oy);
|
|
|
|
evas_object_resize(route, xmax - xmin, ymax - ymin);
|
|
|
|
|
|
|
|
evas_object_raise(route);
|
|
|
|
obj_rotate_zoom(obj, route);
|
|
|
|
evas_object_show(route);
|
|
|
|
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
//the route is not display
|
|
|
|
evas_object_hide(route);
|
2011-05-19 22:55:15 -07:00
|
|
|
}
|
2011-06-25 07:30:10 -07:00
|
|
|
#endif
|
2011-05-19 22:55:15 -07:00
|
|
|
}
|
2011-04-07 23:14:10 -07:00
|
|
|
static void
|
2011-04-08 01:42:32 -07:00
|
|
|
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)
|
2011-04-07 23:14:10 -07:00
|
|
|
{
|
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
|
|
|
Eina_List *lr, *lp, *ln;
|
2011-05-19 22:55:15 -07:00
|
|
|
Path_Node *n;
|
2011-04-07 23:14:10 -07:00
|
|
|
Evas_Object *p;
|
|
|
|
Elm_Map_Route *r;
|
|
|
|
int nodes;
|
|
|
|
int x, y, rx, ry;
|
2011-04-28 09:52:52 -07:00
|
|
|
double a;
|
2011-04-27 22:40:48 -07:00
|
|
|
|
|
|
|
if (!wd) return;
|
2011-04-07 23:14:10 -07:00
|
|
|
Evas_Coord size = pow(2.0, wd->zoom)*wd->tsize;
|
|
|
|
|
|
|
|
EINA_LIST_FOREACH(wd->route, lr, r)
|
|
|
|
{
|
|
|
|
EINA_LIST_FOREACH(r->path, lp, p)
|
|
|
|
{
|
2011-04-28 09:52:52 -07:00
|
|
|
evas_object_polygon_points_clear(p);
|
2011-04-07 23:14:10 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
evas_object_geometry_get(wd->rect, &rx, &ry, NULL, NULL);
|
|
|
|
nodes = eina_list_count(r->nodes);
|
|
|
|
|
|
|
|
EINA_LIST_FOREACH(r->nodes, ln, n)
|
|
|
|
{
|
|
|
|
if ((!wd->zoom) || ((n->idx) &&
|
|
|
|
((n->idx % (int)ceil((double)nodes/(double)size*100.0))))) continue;
|
|
|
|
if (r->inbound)
|
|
|
|
{
|
|
|
|
elm_map_utils_convert_geo_into_coord(wd->obj, n->pos.lon, n->pos.lat, size, &x, &y);
|
|
|
|
if ((x >= px - ow) && (x <= (px + ow*2)) &&
|
|
|
|
(y >= py - oh) && (y <= (py + oh*2)))
|
|
|
|
{
|
|
|
|
x = x - px + rx;
|
|
|
|
y = y - py + ry;
|
|
|
|
|
|
|
|
p = eina_list_nth(r->path, n->idx);
|
2011-04-28 09:52:52 -07:00
|
|
|
a = (double)(y - r->y) / (double)(x - r->x);
|
|
|
|
if ((abs(a) >= 1) || (r->x == x))
|
|
|
|
{
|
|
|
|
evas_object_polygon_point_add(p, r->x - 3, r->y);
|
|
|
|
evas_object_polygon_point_add(p, r->x + 3, r->y);
|
|
|
|
evas_object_polygon_point_add(p, x + 3, y);
|
|
|
|
evas_object_polygon_point_add(p, x - 3, y);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
evas_object_polygon_point_add(p, r->x, r->y - 3);
|
|
|
|
evas_object_polygon_point_add(p, r->x, r->y + 3);
|
|
|
|
evas_object_polygon_point_add(p, x, y + 3);
|
|
|
|
evas_object_polygon_point_add(p, x, y - 3);
|
|
|
|
}
|
|
|
|
|
2011-04-07 23:14:10 -07:00
|
|
|
evas_object_color_set(p, r->color.r, r->color.g, r->color.b, r->color.a);
|
|
|
|
evas_object_raise(p);
|
2011-04-21 01:55:02 -07:00
|
|
|
obj_rotate_zoom(obj, p);
|
2011-04-07 23:14:10 -07:00
|
|
|
evas_object_show(p);
|
|
|
|
r->x = x;
|
|
|
|
r->y = y;
|
|
|
|
}
|
|
|
|
else r->inbound = EINA_FALSE;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
elm_map_utils_convert_geo_into_coord(wd->obj, n->pos.lon, n->pos.lat, size, &x, &y);
|
|
|
|
if ((x >= px - ow) && (x <= (px + ow*2)) &&
|
|
|
|
(y >= py - oh) && (y <= (py + oh*2)))
|
|
|
|
{
|
|
|
|
r->x = x - px + rx;
|
|
|
|
r->y = y - py + ry;
|
|
|
|
r->inbound = EINA_TRUE;
|
|
|
|
}
|
|
|
|
else r->inbound = EINA_FALSE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
r->inbound = EINA_FALSE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-12-18 09:45:47 -08:00
|
|
|
static void
|
2009-11-13 07:22:23 -08:00
|
|
|
rect_place(Evas_Object *obj, Evas_Coord px, Evas_Coord py, Evas_Coord ox, Evas_Coord oy, Evas_Coord ow, Evas_Coord oh)
|
|
|
|
{
|
2011-04-27 22:40:48 -07:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
2009-11-13 07:22:23 -08:00
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
2009-11-17 07:44:11 -08:00
|
|
|
Evas_Coord ax, ay, gw, gh, hh, ww;
|
2011-04-27 22:40:48 -07:00
|
|
|
|
2010-03-09 08:27:46 -08:00
|
|
|
if (!wd) return;
|
2009-11-17 07:44:11 -08:00
|
|
|
evas_object_geometry_get(wd->rect, NULL, NULL, &ww, &hh);
|
|
|
|
|
2009-11-13 07:22:23 -08:00
|
|
|
ax = 0;
|
|
|
|
ay = 0;
|
|
|
|
gw = wd->size.w;
|
|
|
|
gh = wd->size.h;
|
2009-11-17 07:44:11 -08:00
|
|
|
|
2010-10-22 14:41:22 -07:00
|
|
|
if ((ww == gw) && (hh == gh)) return;
|
2009-11-17 07:44:11 -08:00
|
|
|
|
2009-11-13 07:22:23 -08:00
|
|
|
if (ow > gw) ax = (ow - gw) / 2;
|
|
|
|
if (oh > gh) ay = (oh - gh) / 2;
|
|
|
|
evas_object_move(wd->rect,
|
2010-03-09 08:27:46 -08:00
|
|
|
ox + 0 - px + ax,
|
|
|
|
oy + 0 - py + ay);
|
2009-11-13 07:22:23 -08:00
|
|
|
evas_object_resize(wd->rect, gw, gh);
|
2011-04-01 04:26:58 -07:00
|
|
|
|
2010-03-09 08:27:46 -08:00
|
|
|
if (wd->show.show)
|
2009-11-17 07:44:11 -08:00
|
|
|
{
|
2011-04-01 04:26:58 -07:00
|
|
|
wd->show.show = EINA_FALSE;
|
|
|
|
elm_smart_scroller_child_region_show(wd->scr, wd->show.x, wd->show.y, wd->show.w, wd->show.h);
|
2009-11-17 07:44:11 -08:00
|
|
|
}
|
2009-11-13 07:22:23 -08:00
|
|
|
}
|
|
|
|
|
2009-12-18 09:45:47 -08:00
|
|
|
static void
|
2009-11-15 07:53:37 -08:00
|
|
|
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)
|
2009-11-13 07:22:23 -08:00
|
|
|
{
|
2011-04-27 22:40:48 -07:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
2009-11-13 07:22:23 -08:00
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
|
|
|
Evas_Coord ax, ay, gw, gh, tx, ty;
|
2009-12-18 12:16:37 -08:00
|
|
|
Eina_List *l, *markers;
|
2009-12-18 09:45:47 -08:00
|
|
|
Eina_Matrixsparse_Cell *cell;
|
2009-11-15 07:53:37 -08:00
|
|
|
Marker_Group *group;
|
|
|
|
int xx, yy, ww, hh;
|
|
|
|
char buf[PATH_MAX];
|
2009-12-18 06:28:36 -08:00
|
|
|
int y, x;
|
|
|
|
int g_xx, g_yy, g_hh, g_ww;
|
2009-11-15 07:53:37 -08:00
|
|
|
|
2010-03-09 08:27:46 -08:00
|
|
|
if (!wd) return;
|
2009-11-15 07:53:37 -08:00
|
|
|
|
|
|
|
ax = 0;
|
|
|
|
ay = 0;
|
|
|
|
gw = wd->size.w;
|
|
|
|
gh = wd->size.h;
|
|
|
|
if (ow > gw) ax = (ow - gw) / 2;
|
|
|
|
if (oh > gh) ay = (oh - gh) / 2;
|
|
|
|
|
2010-03-09 08:27:46 -08:00
|
|
|
if (wd->zoom != wd->marker_zoom)
|
2009-11-15 07:53:37 -08:00
|
|
|
{
|
2011-04-01 04:26:58 -07:00
|
|
|
EINA_LIST_FREE(wd->cells_displayed, cell)
|
|
|
|
{
|
|
|
|
EINA_LIST_FOREACH(eina_matrixsparse_cell_data_get(cell), l, group)
|
|
|
|
{
|
|
|
|
if (group->obj) _group_object_free(group);
|
|
|
|
}
|
|
|
|
}
|
2009-11-15 07:53:37 -08:00
|
|
|
}
|
|
|
|
wd->marker_zoom = wd->zoom;
|
|
|
|
|
2010-10-22 14:41:22 -07:00
|
|
|
if ((wd->paused_markers)
|
|
|
|
&& ((wd->size.nw != wd->size.w) || (wd->size.nh != wd->size.h)) )
|
2010-03-09 08:27:46 -08:00
|
|
|
return;
|
2009-12-22 14:47:17 -08:00
|
|
|
|
2009-12-18 06:28:36 -08:00
|
|
|
g_xx = wd->pan_x / wd->tsize;
|
2010-03-09 08:27:46 -08:00
|
|
|
if (g_xx < 0) g_xx = 0;
|
2009-12-18 06:28:36 -08:00
|
|
|
g_yy = wd->pan_y / wd->tsize;
|
2010-03-09 08:27:46 -08:00
|
|
|
if (g_yy < 0) g_yy = 0;
|
2011-05-05 08:15:43 -07:00
|
|
|
g_ww = (ow / wd->tsize) + 1;
|
2010-03-09 08:27:46 -08:00
|
|
|
if (g_xx + g_ww >= g->gw) g_ww = g->gw - g_xx - 1;
|
2011-05-05 08:15:43 -07:00
|
|
|
g_hh = (oh / wd->tsize) + 1;
|
2010-03-09 08:27:46 -08:00
|
|
|
if (g_yy + g_hh >= g->gh) g_hh = g->gh - g_yy - 1;
|
2009-12-18 06:28:36 -08:00
|
|
|
|
2009-12-18 09:45:47 -08:00
|
|
|
//hide groups no more displayed
|
|
|
|
EINA_LIST_FREE(wd->cells_displayed, cell)
|
|
|
|
{
|
2011-04-01 04:26:58 -07:00
|
|
|
eina_matrixsparse_cell_position_get(cell, (unsigned long *)&y, (unsigned long *)&x);
|
|
|
|
if ((y < g_yy) || (y > g_yy + g_hh) || (x < g_xx) || (x > g_xx + g_ww))
|
|
|
|
{
|
|
|
|
EINA_LIST_FOREACH(eina_matrixsparse_cell_data_get(cell), l, group)
|
|
|
|
{
|
|
|
|
if (group->obj) _group_object_free(group);
|
|
|
|
}
|
|
|
|
}
|
2009-12-18 09:45:47 -08:00
|
|
|
}
|
|
|
|
|
2011-05-05 08:15:43 -07:00
|
|
|
if (!wd->marker_zoom)
|
|
|
|
{
|
|
|
|
g_ww = 0;
|
|
|
|
g_hh = 0;
|
|
|
|
}
|
|
|
|
|
2009-12-18 06:28:36 -08:00
|
|
|
for (y = g_yy; y <= g_yy + g_hh; y++)
|
|
|
|
{
|
2011-04-01 04:26:58 -07:00
|
|
|
for (x = g_xx; x <= g_xx + g_ww; x++)
|
|
|
|
{
|
|
|
|
if (!wd->markers[wd->zoom]) continue;
|
|
|
|
eina_matrixsparse_cell_idx_get(wd->markers[wd->zoom], y, x, &cell);
|
|
|
|
if (!cell) continue;
|
|
|
|
wd->cells_displayed = eina_list_append(wd->cells_displayed, cell);
|
|
|
|
markers = eina_matrixsparse_cell_data_get(cell);
|
|
|
|
EINA_LIST_FOREACH(markers, l, group)
|
|
|
|
{
|
|
|
|
if (!group->markers) continue;
|
|
|
|
if (group->clas->zoom_displayed > wd->zoom) continue;
|
|
|
|
|
|
|
|
xx = group->x;
|
|
|
|
yy = group->y;
|
|
|
|
ww = group->w;
|
|
|
|
hh = group->h;
|
|
|
|
|
|
|
|
if (eina_list_count(group->markers) == 1)
|
|
|
|
{
|
|
|
|
Elm_Map_Marker *m = eina_list_data_get(group->markers);
|
|
|
|
ww = m->clas->priv.edje_w;
|
|
|
|
hh = m->clas->priv.edje_h;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ww <= 0) ww = 1;
|
|
|
|
if (hh <= 0) hh = 1;
|
|
|
|
|
|
|
|
if ((gw != g->w) && (g->w > 0))
|
|
|
|
{
|
|
|
|
tx = xx;
|
|
|
|
xx = ((long long )gw * xx) / g->w;
|
|
|
|
ww = (((long long)gw * (tx + ww)) / g->w) - xx;
|
|
|
|
}
|
|
|
|
if ((gh != g->h) && (g->h > 0))
|
|
|
|
{
|
|
|
|
ty = yy;
|
|
|
|
yy = ((long long)gh * yy) / g->h;
|
|
|
|
hh = (((long long)gh * (ty + hh)) / g->h) - yy;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((!group->clas->hide)
|
2010-10-22 14:41:22 -07:00
|
|
|
&& (xx-px+ax+ox >= ox) && (xx-px+ax+ox<= ox+ow)
|
|
|
|
&& (yy-py+ay+oy >= oy) && (yy-py+ay+oy<= oy+oh))
|
2011-04-01 04:26:58 -07:00
|
|
|
{
|
|
|
|
if (!group->obj) _group_object_create(group);
|
|
|
|
|
|
|
|
if (group->update_nbelems)
|
|
|
|
{
|
|
|
|
group->update_nbelems = EINA_FALSE;
|
|
|
|
if (eina_list_count(group->markers) > 1)
|
|
|
|
{
|
|
|
|
snprintf(buf, sizeof(buf), "%d", eina_list_count(group->markers));
|
|
|
|
edje_object_part_text_set(elm_layout_edje_get(group->obj), "elm.text", buf);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
edje_object_part_text_set(elm_layout_edje_get(group->obj), "elm.text", "");
|
|
|
|
}
|
|
|
|
evas_object_move(group->obj,
|
2010-03-09 08:27:46 -08:00
|
|
|
xx - px + ax + ox - ww/2,
|
|
|
|
yy - py + ay + oy - hh/2);
|
2011-04-01 04:26:58 -07:00
|
|
|
if ((!wd->paused_markers) || (group->update_resize))
|
|
|
|
{
|
|
|
|
group->update_resize = EINA_FALSE;
|
|
|
|
evas_object_resize(group->obj, ww, hh);
|
2011-04-21 01:55:02 -07:00
|
|
|
obj_rotate_zoom(obj, group->obj);
|
2011-04-01 04:26:58 -07:00
|
|
|
}
|
|
|
|
if (group->update_raise)
|
|
|
|
{
|
|
|
|
group->update_raise = EINA_FALSE;
|
|
|
|
evas_object_raise(group->obj);
|
2011-04-21 01:55:02 -07:00
|
|
|
obj_rotate_zoom(obj, group->obj);
|
2011-04-01 04:26:58 -07:00
|
|
|
evas_object_show(group->obj);
|
|
|
|
}
|
|
|
|
if (group->bubble) _group_bubble_place(group);
|
|
|
|
}
|
|
|
|
else if (group->obj)
|
|
|
|
{
|
|
|
|
_group_object_free(group);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2009-11-15 07:53:37 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-12-18 09:45:47 -08:00
|
|
|
static void
|
2009-11-15 07:53:37 -08:00
|
|
|
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)
|
|
|
|
{
|
2011-04-27 22:40:48 -07:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
2009-11-15 07:53:37 -08:00
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
|
|
|
Evas_Coord ax, ay, gw, gh, tx, ty;
|
|
|
|
int xx, yy, ww, hh;
|
2009-11-13 07:22:23 -08:00
|
|
|
|
2010-03-09 08:27:46 -08:00
|
|
|
if (!wd) return;
|
2009-11-13 07:22:23 -08:00
|
|
|
ax = 0;
|
|
|
|
ay = 0;
|
|
|
|
gw = wd->size.w;
|
|
|
|
gh = wd->size.h;
|
|
|
|
if (ow > gw) ax = (ow - gw) / 2;
|
|
|
|
if (oh > gh) ay = (oh - gh) / 2;
|
|
|
|
|
|
|
|
Eina_Iterator *it = eina_matrixsparse_iterator_new(g->grid);
|
|
|
|
Eina_Matrixsparse_Cell *cell;
|
|
|
|
|
|
|
|
EINA_ITERATOR_FOREACH(it, cell)
|
|
|
|
{
|
2011-04-01 04:26:58 -07:00
|
|
|
Grid_Item *gi = eina_matrixsparse_cell_data_get(cell);
|
|
|
|
|
|
|
|
xx = gi->out.x;
|
|
|
|
yy = gi->out.y;
|
|
|
|
ww = gi->out.w;
|
|
|
|
hh = gi->out.h;
|
|
|
|
if ((gw != g->w) && (g->w > 0))
|
|
|
|
{
|
|
|
|
tx = xx;
|
|
|
|
xx = ((long long )gw * xx) / g->w;
|
|
|
|
ww = (((long long)gw * (tx + ww)) / g->w) - xx;
|
|
|
|
}
|
|
|
|
if ((gh != g->h) && (g->h > 0))
|
|
|
|
{
|
|
|
|
ty = yy;
|
|
|
|
yy = ((long long)gh * yy) / g->h;
|
|
|
|
hh = (((long long)gh * (ty + hh)) / g->h) - yy;
|
|
|
|
}
|
|
|
|
evas_object_move(gi->img,
|
2010-03-09 08:27:46 -08:00
|
|
|
xx - px + ax + ox,
|
|
|
|
yy - py + ay + oy);
|
2009-11-14 07:30:03 -08:00
|
|
|
|
2011-04-01 04:26:58 -07:00
|
|
|
evas_object_resize(gi->img, ww, hh);
|
|
|
|
|
2011-04-21 01:55:02 -07:00
|
|
|
obj_rotate_zoom(obj, gi->img);
|
2011-04-01 04:26:58 -07:00
|
|
|
/*evas_object_move(gi->txt,
|
elementary / entry, list, scroller, fileselector_button, config, photocam, map, pan, bg, store, priv, pager, conform, box, clock, flipselector
fixed indentation, removed white spaces.
SVN revision: 58267
2011-04-01 12:08:56 -07:00
|
|
|
xx - px + ax + ox,
|
|
|
|
yy - py + ay + oy);
|
2009-11-14 07:30:03 -08:00
|
|
|
|
2011-04-01 04:26:58 -07:00
|
|
|
evas_object_resize(gi->txt, ww, hh);
|
|
|
|
*/
|
2009-11-13 07:22:23 -08:00
|
|
|
}
|
2009-11-15 07:53:37 -08:00
|
|
|
eina_iterator_free(it);
|
2009-11-13 07:22:23 -08:00
|
|
|
}
|
|
|
|
|
2009-12-18 09:45:47 -08:00
|
|
|
static void
|
2009-11-14 07:30:03 -08:00
|
|
|
_tile_update(Grid_Item *gi)
|
|
|
|
{
|
|
|
|
evas_object_image_file_set(gi->img, gi->file, NULL);
|
2011-11-29 21:00:56 -08:00
|
|
|
Evas_Load_Error err = evas_object_image_load_error_get(gi->img);
|
|
|
|
if (err != EVAS_LOAD_ERROR_NONE)
|
2011-10-31 19:35:40 -07:00
|
|
|
{
|
2011-11-29 21:00:56 -08:00
|
|
|
ERR("Image loading error (%s): %s", gi->file, evas_load_error_str(err));
|
2011-10-31 19:35:40 -07:00
|
|
|
ecore_file_remove(gi->file);
|
2011-12-13 00:31:55 -08:00
|
|
|
gi->file_have = EINA_FALSE;
|
2011-10-31 19:35:40 -07:00
|
|
|
}
|
2011-11-29 21:00:56 -08:00
|
|
|
else
|
|
|
|
{
|
|
|
|
obj_rotate_zoom(gi->wd->obj, gi->img);
|
|
|
|
evas_object_show(gi->img);
|
2011-12-13 00:31:55 -08:00
|
|
|
gi->file_have = EINA_TRUE;
|
2011-11-29 21:00:56 -08:00
|
|
|
//evas_object_text_text_set(gi->txt, gi->file);
|
|
|
|
//evas_object_show(gi->txt);
|
|
|
|
}
|
2009-11-14 07:30:03 -08:00
|
|
|
}
|
|
|
|
|
2009-12-18 09:45:47 -08:00
|
|
|
static void
|
2010-03-09 09:51:30 -08:00
|
|
|
_tile_downloaded(void *data, const char *file __UNUSED__, int status)
|
2009-11-13 07:22:23 -08:00
|
|
|
{
|
|
|
|
Grid_Item *gi = data;
|
|
|
|
|
2009-11-13 09:34:20 -08:00
|
|
|
gi->job = NULL;
|
|
|
|
|
2011-12-04 23:30:31 -08:00
|
|
|
if (status == 200)
|
From: Kim Yunhan <spbear@gmail.com>
Subject: [E-devel] [elm_map] Fix up too many connections at the same
time.
Currently, elm_map requests all visible map image tile to map server
at the
same time.
If the scene is turned off while panning or zooming, it will be
aborted on
HTTP requests.
But it already sent to map server, and it already made useless HTTP
connections.
So if you pan scrolling quickly, elm_map try to download and abort too
many
HTTP
connections repeatedly.
If you have stable and high-throughput data connection, it doesn't
matter
on your side.
However map server will get high load, It is sufficient reason to block
you.
In another case, if you have poor data connection such as 3G
connection, it
has less
throughput and it causes delay of downloading. And finally, the device
is
as full as
HTTP connections even you already aborted. It makes low-performance
issue on
your device.
I wrote a patch for solving this situation.
The idea is simple.
1. I limited number of maximum HTTP request on elm_map side.
2. If maximum HTTP request is exceed, keep requests on Eina_List.
3. If each image downloading is completed, try to download recent
request.
(Because it has strong possibility for your screen)
4. At the same time, invisible request will be removed.
(It doesn't make HTTP connection yet)
I tested many times on my desktop and device.
It works for me. And elm_map's performance is improved
appreciably on 3G
connections.
SVN revision: 64685
2011-11-03 04:07:03 -07:00
|
|
|
{
|
2011-12-04 23:30:31 -08:00
|
|
|
DBG("Download success from %s to %s", gi->source, gi->file);
|
From: Kim Yunhan <spbear@gmail.com>
Subject: [E-devel] [elm_map] Fix up too many connections at the same
time.
Currently, elm_map requests all visible map image tile to map server
at the
same time.
If the scene is turned off while panning or zooming, it will be
aborted on
HTTP requests.
But it already sent to map server, and it already made useless HTTP
connections.
So if you pan scrolling quickly, elm_map try to download and abort too
many
HTTP
connections repeatedly.
If you have stable and high-throughput data connection, it doesn't
matter
on your side.
However map server will get high load, It is sufficient reason to block
you.
In another case, if you have poor data connection such as 3G
connection, it
has less
throughput and it causes delay of downloading. And finally, the device
is
as full as
HTTP connections even you already aborted. It makes low-performance
issue on
your device.
I wrote a patch for solving this situation.
The idea is simple.
1. I limited number of maximum HTTP request on elm_map side.
2. If maximum HTTP request is exceed, keep requests on Eina_List.
3. If each image downloading is completed, try to download recent
request.
(Because it has strong possibility for your screen)
4. At the same time, invisible request will be removed.
(It doesn't make HTTP connection yet)
I tested many times on my desktop and device.
It works for me. And elm_map's performance is improved
appreciably on 3G
connections.
SVN revision: 64685
2011-11-03 04:07:03 -07:00
|
|
|
_tile_update(gi);
|
2011-12-13 00:31:55 -08:00
|
|
|
gi->wd->finish_num++;
|
From: Kim Yunhan <spbear@gmail.com>
Subject: [E-devel] [elm_map] Fix up too many connections at the same
time.
Currently, elm_map requests all visible map image tile to map server
at the
same time.
If the scene is turned off while panning or zooming, it will be
aborted on
HTTP requests.
But it already sent to map server, and it already made useless HTTP
connections.
So if you pan scrolling quickly, elm_map try to download and abort too
many
HTTP
connections repeatedly.
If you have stable and high-throughput data connection, it doesn't
matter
on your side.
However map server will get high load, It is sufficient reason to block
you.
In another case, if you have poor data connection such as 3G
connection, it
has less
throughput and it causes delay of downloading. And finally, the device
is
as full as
HTTP connections even you already aborted. It makes low-performance
issue on
your device.
I wrote a patch for solving this situation.
The idea is simple.
1. I limited number of maximum HTTP request on elm_map side.
2. If maximum HTTP request is exceed, keep requests on Eina_List.
3. If each image downloading is completed, try to download recent
request.
(Because it has strong possibility for your screen)
4. At the same time, invisible request will be removed.
(It doesn't make HTTP connection yet)
I tested many times on my desktop and device.
It works for me. And elm_map's performance is improved
appreciably on 3G
connections.
SVN revision: 64685
2011-11-03 04:07:03 -07:00
|
|
|
}
|
2011-12-04 23:30:31 -08:00
|
|
|
else
|
2009-11-15 11:52:07 -08:00
|
|
|
{
|
2011-12-13 00:31:55 -08:00
|
|
|
WRN("Download failed from %s to %s (%d) ", gi->source, gi->file, status);
|
2011-04-01 04:26:58 -07:00
|
|
|
ecore_file_remove(gi->file);
|
2011-12-13 00:31:55 -08:00
|
|
|
gi->file_have = EINA_FALSE;
|
2009-11-15 11:52:07 -08:00
|
|
|
}
|
2011-01-10 21:48:28 -08:00
|
|
|
|
2011-12-04 23:30:31 -08:00
|
|
|
gi->wd->download_num--;
|
2011-01-10 21:48:28 -08:00
|
|
|
evas_object_smart_callback_call(gi->wd->obj, SIG_DOWNLOADED, NULL);
|
From: Kim Yunhan <spbear@gmail.com>
Subject: [E-devel] [elm_map] Fix up too many connections at the same
time.
Currently, elm_map requests all visible map image tile to map server
at the
same time.
If the scene is turned off while panning or zooming, it will be
aborted on
HTTP requests.
But it already sent to map server, and it already made useless HTTP
connections.
So if you pan scrolling quickly, elm_map try to download and abort too
many
HTTP
connections repeatedly.
If you have stable and high-throughput data connection, it doesn't
matter
on your side.
However map server will get high load, It is sufficient reason to block
you.
In another case, if you have poor data connection such as 3G
connection, it
has less
throughput and it causes delay of downloading. And finally, the device
is
as full as
HTTP connections even you already aborted. It makes low-performance
issue on
your device.
I wrote a patch for solving this situation.
The idea is simple.
1. I limited number of maximum HTTP request on elm_map side.
2. If maximum HTTP request is exceed, keep requests on Eina_List.
3. If each image downloading is completed, try to download recent
request.
(Because it has strong possibility for your screen)
4. At the same time, invisible request will be removed.
(It doesn't make HTTP connection yet)
I tested many times on my desktop and device.
It works for me. And elm_map's performance is improved
appreciably on 3G
connections.
SVN revision: 64685
2011-11-03 04:07:03 -07:00
|
|
|
if (!gi->wd->download_num)
|
|
|
|
{
|
|
|
|
edje_object_signal_emit(elm_smart_scroller_edje_object_get(gi->wd->scr), "elm,state,busy,stop", "elm");
|
|
|
|
evas_object_smart_callback_call(gi->wd->obj, SIG_LOADED_DETAIL, NULL);
|
|
|
|
}
|
|
|
|
_process_download_list(gi->wd->obj);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_process_download_list(Evas_Object *obj)
|
|
|
|
{
|
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
2011-11-11 08:29:15 -08:00
|
|
|
Eina_List *l, *ll;
|
From: Kim Yunhan <spbear@gmail.com>
Subject: [E-devel] [elm_map] Fix up too many connections at the same
time.
Currently, elm_map requests all visible map image tile to map server
at the
same time.
If the scene is turned off while panning or zooming, it will be
aborted on
HTTP requests.
But it already sent to map server, and it already made useless HTTP
connections.
So if you pan scrolling quickly, elm_map try to download and abort too
many
HTTP
connections repeatedly.
If you have stable and high-throughput data connection, it doesn't
matter
on your side.
However map server will get high load, It is sufficient reason to block
you.
In another case, if you have poor data connection such as 3G
connection, it
has less
throughput and it causes delay of downloading. And finally, the device
is
as full as
HTTP connections even you already aborted. It makes low-performance
issue on
your device.
I wrote a patch for solving this situation.
The idea is simple.
1. I limited number of maximum HTTP request on elm_map side.
2. If maximum HTTP request is exceed, keep requests on Eina_List.
3. If each image downloading is completed, try to download recent
request.
(Because it has strong possibility for your screen)
4. At the same time, invisible request will be removed.
(It doesn't make HTTP connection yet)
I tested many times on my desktop and device.
It works for me. And elm_map's performance is improved
appreciably on 3G
connections.
SVN revision: 64685
2011-11-03 04:07:03 -07:00
|
|
|
Evas_Coord ox, oy, ow, oh, cvx, cvy, cvw, cvh, tx, ty, gw, gh, xx, yy, ww, hh;
|
|
|
|
Grid_Item *gi;
|
|
|
|
|
|
|
|
evas_object_geometry_get(wd->pan_smart, &ox, &oy, &ow, &oh);
|
|
|
|
evas_output_viewport_get(evas_object_evas_get(wd->obj), &cvx, &cvy, &cvw, &cvh);
|
|
|
|
|
|
|
|
gw = wd->size.w;
|
|
|
|
gh = wd->size.h;
|
|
|
|
|
2011-12-13 01:07:00 -08:00
|
|
|
EINA_LIST_REVERSE_FOREACH_SAFE(wd->download_list, l, ll, gi)
|
From: Kim Yunhan <spbear@gmail.com>
Subject: [E-devel] [elm_map] Fix up too many connections at the same
time.
Currently, elm_map requests all visible map image tile to map server
at the
same time.
If the scene is turned off while panning or zooming, it will be
aborted on
HTTP requests.
But it already sent to map server, and it already made useless HTTP
connections.
So if you pan scrolling quickly, elm_map try to download and abort too
many
HTTP
connections repeatedly.
If you have stable and high-throughput data connection, it doesn't
matter
on your side.
However map server will get high load, It is sufficient reason to block
you.
In another case, if you have poor data connection such as 3G
connection, it
has less
throughput and it causes delay of downloading. And finally, the device
is
as full as
HTTP connections even you already aborted. It makes low-performance
issue on
your device.
I wrote a patch for solving this situation.
The idea is simple.
1. I limited number of maximum HTTP request on elm_map side.
2. If maximum HTTP request is exceed, keep requests on Eina_List.
3. If each image downloading is completed, try to download recent
request.
(Because it has strong possibility for your screen)
4. At the same time, invisible request will be removed.
(It doesn't make HTTP connection yet)
I tested many times on my desktop and device.
It works for me. And elm_map's performance is improved
appreciably on 3G
connections.
SVN revision: 64685
2011-11-03 04:07:03 -07:00
|
|
|
{
|
|
|
|
xx = gi->out.x;
|
|
|
|
yy = gi->out.y;
|
|
|
|
ww = gi->out.w;
|
|
|
|
hh = gi->out.h;
|
|
|
|
|
|
|
|
if ((gw != gi->g->w) && (gi->g->w > 0))
|
|
|
|
{
|
|
|
|
tx = xx;
|
|
|
|
xx = ((long long )gw * xx) / gi->g->w;
|
|
|
|
ww = (((long long)gw * (tx + ww)) / gi->g->w) - xx;
|
|
|
|
}
|
|
|
|
if ((gh != gi->g->h) && (gi->g->h > 0))
|
|
|
|
{
|
|
|
|
ty = yy;
|
|
|
|
yy = ((long long)gh * yy) / gi->g->h;
|
|
|
|
hh = (((long long)gh * (ty + hh)) / gi->g->h) - yy;
|
|
|
|
}
|
|
|
|
if (!ELM_RECTS_INTERSECT(xx - wd->pan_x + ox,
|
|
|
|
yy - wd->pan_y + oy,
|
|
|
|
ww, hh,
|
2011-12-13 01:07:00 -08:00
|
|
|
cvx, cvy, cvw, cvh) ||
|
|
|
|
(gi->zoom != wd->zoom))
|
From: Kim Yunhan <spbear@gmail.com>
Subject: [E-devel] [elm_map] Fix up too many connections at the same
time.
Currently, elm_map requests all visible map image tile to map server
at the
same time.
If the scene is turned off while panning or zooming, it will be
aborted on
HTTP requests.
But it already sent to map server, and it already made useless HTTP
connections.
So if you pan scrolling quickly, elm_map try to download and abort too
many
HTTP
connections repeatedly.
If you have stable and high-throughput data connection, it doesn't
matter
on your side.
However map server will get high load, It is sufficient reason to block
you.
In another case, if you have poor data connection such as 3G
connection, it
has less
throughput and it causes delay of downloading. And finally, the device
is
as full as
HTTP connections even you already aborted. It makes low-performance
issue on
your device.
I wrote a patch for solving this situation.
The idea is simple.
1. I limited number of maximum HTTP request on elm_map side.
2. If maximum HTTP request is exceed, keep requests on Eina_List.
3. If each image downloading is completed, try to download recent
request.
(Because it has strong possibility for your screen)
4. At the same time, invisible request will be removed.
(It doesn't make HTTP connection yet)
I tested many times on my desktop and device.
It works for me. And elm_map's performance is improved
appreciably on 3G
connections.
SVN revision: 64685
2011-11-03 04:07:03 -07:00
|
|
|
{
|
|
|
|
wd->download_list = eina_list_remove(wd->download_list, gi);
|
2011-12-13 01:07:00 -08:00
|
|
|
continue;
|
From: Kim Yunhan <spbear@gmail.com>
Subject: [E-devel] [elm_map] Fix up too many connections at the same
time.
Currently, elm_map requests all visible map image tile to map server
at the
same time.
If the scene is turned off while panning or zooming, it will be
aborted on
HTTP requests.
But it already sent to map server, and it already made useless HTTP
connections.
So if you pan scrolling quickly, elm_map try to download and abort too
many
HTTP
connections repeatedly.
If you have stable and high-throughput data connection, it doesn't
matter
on your side.
However map server will get high load, It is sufficient reason to block
you.
In another case, if you have poor data connection such as 3G
connection, it
has less
throughput and it causes delay of downloading. And finally, the device
is
as full as
HTTP connections even you already aborted. It makes low-performance
issue on
your device.
I wrote a patch for solving this situation.
The idea is simple.
1. I limited number of maximum HTTP request on elm_map side.
2. If maximum HTTP request is exceed, keep requests on Eina_List.
3. If each image downloading is completed, try to download recent
request.
(Because it has strong possibility for your screen)
4. At the same time, invisible request will be removed.
(It doesn't make HTTP connection yet)
I tested many times on my desktop and device.
It works for me. And elm_map's performance is improved
appreciably on 3G
connections.
SVN revision: 64685
2011-11-03 04:07:03 -07:00
|
|
|
}
|
|
|
|
|
2011-12-04 23:30:31 -08:00
|
|
|
if (gi->wd->download_num >= MAX_CONCURRENT_DOWNLOAD) break;
|
From: Kim Yunhan <spbear@gmail.com>
Subject: [E-devel] [elm_map] Fix up too many connections at the same
time.
Currently, elm_map requests all visible map image tile to map server
at the
same time.
If the scene is turned off while panning or zooming, it will be
aborted on
HTTP requests.
But it already sent to map server, and it already made useless HTTP
connections.
So if you pan scrolling quickly, elm_map try to download and abort too
many
HTTP
connections repeatedly.
If you have stable and high-throughput data connection, it doesn't
matter
on your side.
However map server will get high load, It is sufficient reason to block
you.
In another case, if you have poor data connection such as 3G
connection, it
has less
throughput and it causes delay of downloading. And finally, the device
is
as full as
HTTP connections even you already aborted. It makes low-performance
issue on
your device.
I wrote a patch for solving this situation.
The idea is simple.
1. I limited number of maximum HTTP request on elm_map side.
2. If maximum HTTP request is exceed, keep requests on Eina_List.
3. If each image downloading is completed, try to download recent
request.
(Because it has strong possibility for your screen)
4. At the same time, invisible request will be removed.
(It doesn't make HTTP connection yet)
I tested many times on my desktop and device.
It works for me. And elm_map's performance is improved
appreciably on 3G
connections.
SVN revision: 64685
2011-11-03 04:07:03 -07:00
|
|
|
|
2011-11-05 23:11:57 -07:00
|
|
|
Eina_Bool ret = ecore_file_download_full(gi->source, gi->file, _tile_downloaded, NULL, gi, &(gi->job), wd->ua);
|
2011-12-04 23:30:31 -08:00
|
|
|
if (!ret || !gi->job) ERR("Can't start to download from %s to %s", gi->source, gi->file);
|
From: Kim Yunhan <spbear@gmail.com>
Subject: [E-devel] [elm_map] Fix up too many connections at the same
time.
Currently, elm_map requests all visible map image tile to map server
at the
same time.
If the scene is turned off while panning or zooming, it will be
aborted on
HTTP requests.
But it already sent to map server, and it already made useless HTTP
connections.
So if you pan scrolling quickly, elm_map try to download and abort too
many
HTTP
connections repeatedly.
If you have stable and high-throughput data connection, it doesn't
matter
on your side.
However map server will get high load, It is sufficient reason to block
you.
In another case, if you have poor data connection such as 3G
connection, it
has less
throughput and it causes delay of downloading. And finally, the device
is
as full as
HTTP connections even you already aborted. It makes low-performance
issue on
your device.
I wrote a patch for solving this situation.
The idea is simple.
1. I limited number of maximum HTTP request on elm_map side.
2. If maximum HTTP request is exceed, keep requests on Eina_List.
3. If each image downloading is completed, try to download recent
request.
(Because it has strong possibility for your screen)
4. At the same time, invisible request will be removed.
(It doesn't make HTTP connection yet)
I tested many times on my desktop and device.
It works for me. And elm_map's performance is improved
appreciably on 3G
connections.
SVN revision: 64685
2011-11-03 04:07:03 -07:00
|
|
|
else
|
|
|
|
{
|
|
|
|
gi->wd->download_num++;
|
|
|
|
wd->try_num++;
|
|
|
|
wd->download_list = eina_list_remove(wd->download_list, gi);
|
|
|
|
if (wd->download_num == 1)
|
|
|
|
edje_object_signal_emit(elm_smart_scroller_edje_object_get(wd->scr), "elm,state,busy,start", "elm");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_add_download_list(Evas_Object *obj, Grid_Item *gi)
|
|
|
|
{
|
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
|
|
|
|
2011-12-12 19:48:18 -08:00
|
|
|
wd->download_list = eina_list_remove(wd->download_list, gi);
|
|
|
|
wd->download_list = eina_list_append(wd->download_list, gi);
|
From: Kim Yunhan <spbear@gmail.com>
Subject: [E-devel] [elm_map] Fix up too many connections at the same
time.
Currently, elm_map requests all visible map image tile to map server
at the
same time.
If the scene is turned off while panning or zooming, it will be
aborted on
HTTP requests.
But it already sent to map server, and it already made useless HTTP
connections.
So if you pan scrolling quickly, elm_map try to download and abort too
many
HTTP
connections repeatedly.
If you have stable and high-throughput data connection, it doesn't
matter
on your side.
However map server will get high load, It is sufficient reason to block
you.
In another case, if you have poor data connection such as 3G
connection, it
has less
throughput and it causes delay of downloading. And finally, the device
is
as full as
HTTP connections even you already aborted. It makes low-performance
issue on
your device.
I wrote a patch for solving this situation.
The idea is simple.
1. I limited number of maximum HTTP request on elm_map side.
2. If maximum HTTP request is exceed, keep requests on Eina_List.
3. If each image downloading is completed, try to download recent
request.
(Because it has strong possibility for your screen)
4. At the same time, invisible request will be removed.
(It doesn't make HTTP connection yet)
I tested many times on my desktop and device.
It works for me. And elm_map's performance is improved
appreciably on 3G
connections.
SVN revision: 64685
2011-11-03 04:07:03 -07:00
|
|
|
_process_download_list(obj);
|
2009-11-13 07:22:23 -08:00
|
|
|
}
|
|
|
|
|
2011-12-12 19:48:18 -08:00
|
|
|
static void
|
|
|
|
grid_create_all(Evas_Object *obj)
|
2009-11-13 07:22:23 -08:00
|
|
|
{
|
2011-12-12 19:48:18 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
2009-11-13 07:22:23 -08:00
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
|
|
|
Grid *g;
|
2011-12-12 19:48:18 -08:00
|
|
|
int zoom = 0;
|
2009-11-13 07:22:23 -08:00
|
|
|
|
2011-12-12 19:48:18 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN(wd);
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN(wd->src);
|
2009-11-13 07:22:23 -08:00
|
|
|
|
2011-12-12 19:48:18 -08:00
|
|
|
for (zoom = wd->src->zoom_min; zoom <= wd->src->zoom_max; zoom++)
|
|
|
|
{
|
|
|
|
g = calloc(1, sizeof(Grid));
|
2011-12-13 00:39:01 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN(g);
|
2011-12-12 19:48:18 -08:00
|
|
|
g->zoom = zoom;
|
|
|
|
g->tsize = wd->tsize;
|
|
|
|
g->wd = wd;
|
|
|
|
int size = pow(2.0, g->zoom);
|
|
|
|
g->gw = size;
|
|
|
|
g->gh = size;
|
|
|
|
g->w = g->tsize * g->gw;
|
|
|
|
g->h = g->tsize * g->gh;
|
|
|
|
|
|
|
|
g->grid = eina_matrixsparse_new(g->gh, g->gw, NULL, NULL);
|
|
|
|
wd->grids = eina_list_append(wd->grids, g);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
grid_clear_all(Evas_Object *obj)
|
|
|
|
{
|
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
|
|
|
Grid *g;
|
|
|
|
Grid_Item *gi;
|
|
|
|
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN(wd);
|
|
|
|
|
|
|
|
EINA_LIST_FREE(wd->grids, g)
|
|
|
|
{
|
|
|
|
Eina_Iterator *it = eina_matrixsparse_iterator_new(g->grid);
|
|
|
|
Eina_Matrixsparse_Cell *cell;
|
|
|
|
|
|
|
|
EINA_ITERATOR_FOREACH(it, cell)
|
|
|
|
{
|
|
|
|
gi = eina_matrixsparse_cell_data_get(cell);
|
|
|
|
evas_object_del(gi->img);
|
|
|
|
//evas_object_del(gi->txt);
|
2009-11-13 07:22:23 -08:00
|
|
|
|
2011-12-12 19:48:18 -08:00
|
|
|
if (gi->job)
|
|
|
|
{
|
|
|
|
DBG("DOWNLOAD abort %s", gi->file);
|
|
|
|
ecore_file_download_abort(gi->job);
|
|
|
|
ecore_file_remove(gi->file);
|
2011-12-13 00:31:55 -08:00
|
|
|
gi->file_have = EINA_FALSE;
|
2011-12-12 19:48:18 -08:00
|
|
|
gi->job = NULL;
|
|
|
|
wd->try_num--;
|
|
|
|
}
|
|
|
|
if (gi->file) eina_stringshare_del(gi->file);
|
|
|
|
if (gi->source) eina_stringshare_del(gi->source);
|
|
|
|
free(gi);
|
|
|
|
}
|
|
|
|
eina_matrixsparse_free(g->grid);
|
|
|
|
eina_iterator_free(it);
|
|
|
|
free(g);
|
|
|
|
}
|
|
|
|
|
|
|
|
EINA_LIST_FREE(wd->download_list, gi);
|
|
|
|
if (!ecore_file_recursive_rm("/tmp/elm_map/")) WRN("Deletion of /tmp/elm_map/ failed");
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
grid_unload(Evas_Object *obj, Grid *g)
|
|
|
|
{
|
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
2009-11-13 07:22:23 -08:00
|
|
|
|
2011-12-12 19:48:18 -08:00
|
|
|
Eina_Iterator *it;
|
|
|
|
Eina_Matrixsparse_Cell *cell;
|
|
|
|
Grid_Item *gi;
|
2009-11-13 07:22:23 -08:00
|
|
|
|
2011-12-12 19:48:18 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN(wd);
|
2009-11-13 07:22:23 -08:00
|
|
|
|
2011-12-12 19:48:18 -08:00
|
|
|
it = eina_matrixsparse_iterator_new(g->grid);
|
|
|
|
EINA_ITERATOR_FOREACH(it, cell)
|
|
|
|
{
|
|
|
|
gi = eina_matrixsparse_cell_data_get(cell);
|
2009-11-13 07:22:23 -08:00
|
|
|
|
2011-12-13 00:31:55 -08:00
|
|
|
if (gi->file_have)
|
2011-12-12 19:48:18 -08:00
|
|
|
{
|
|
|
|
evas_object_hide(gi->img);
|
|
|
|
//evas_object_hide(gi->txt);
|
|
|
|
evas_object_image_file_set(gi->img, NULL, NULL);
|
|
|
|
}
|
|
|
|
else if (gi->job)
|
|
|
|
{
|
|
|
|
DBG("DOWNLOAD abort %s", gi->file);
|
|
|
|
ecore_file_download_abort(gi->job);
|
|
|
|
ecore_file_remove(gi->file);
|
|
|
|
gi->job = NULL;
|
|
|
|
wd->try_num--;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
eina_iterator_free(it);
|
2009-11-13 07:22:23 -08:00
|
|
|
}
|
|
|
|
|
2011-12-12 19:48:18 -08:00
|
|
|
|
2009-12-18 09:45:47 -08:00
|
|
|
static void
|
2009-11-13 07:22:23 -08:00
|
|
|
grid_load(Evas_Object *obj, Grid *g)
|
|
|
|
{
|
2011-04-27 22:40:48 -07:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
2009-11-13 07:22:23 -08:00
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
|
|
|
int x, y;
|
|
|
|
int size;
|
2010-01-17 22:44:56 -08:00
|
|
|
Evas_Coord ox, oy, ow, oh, cvx, cvy, cvw, cvh, tx, ty, gw, gh, xx, yy, ww, hh;
|
2009-11-13 07:22:23 -08:00
|
|
|
Eina_Iterator *it;
|
|
|
|
Eina_Matrixsparse_Cell *cell;
|
|
|
|
Grid_Item *gi;
|
2011-05-04 02:44:53 -07:00
|
|
|
|
2011-12-12 19:48:18 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN(wd);
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN(wd->src);
|
|
|
|
|
2010-01-17 22:44:56 -08:00
|
|
|
evas_object_geometry_get(wd->pan_smart, &ox, &oy, &ow, &oh);
|
|
|
|
evas_output_viewport_get(evas_object_evas_get(wd->obj), &cvx, &cvy, &cvw, &cvh);
|
2011-04-01 04:26:58 -07:00
|
|
|
|
2009-11-13 07:22:23 -08:00
|
|
|
gw = wd->size.w;
|
|
|
|
gh = wd->size.h;
|
|
|
|
|
2010-01-17 22:44:56 -08:00
|
|
|
if ((gw <= 0) || (gh <= 0)) return;
|
2009-11-13 07:22:23 -08:00
|
|
|
|
|
|
|
size = g->tsize;
|
|
|
|
if ((gw != g->w) && (g->w > 0))
|
|
|
|
size = ((long long)gw * size) / g->w;
|
2010-01-17 22:44:56 -08:00
|
|
|
if (size < (g->tsize / 2)) return; // else we will load to much tiles
|
2009-11-13 07:22:23 -08:00
|
|
|
|
|
|
|
it = eina_matrixsparse_iterator_new(g->grid);
|
2011-04-01 04:26:58 -07:00
|
|
|
|
2009-11-13 07:22:23 -08:00
|
|
|
EINA_ITERATOR_FOREACH(it, cell)
|
|
|
|
{
|
2011-04-01 04:26:58 -07:00
|
|
|
gi = eina_matrixsparse_cell_data_get(cell);
|
|
|
|
|
|
|
|
xx = gi->out.x;
|
|
|
|
yy = gi->out.y;
|
|
|
|
ww = gi->out.w;
|
|
|
|
hh = gi->out.h;
|
|
|
|
|
|
|
|
if ((gw != g->w) && (g->w > 0))
|
|
|
|
{
|
|
|
|
tx = xx;
|
|
|
|
xx = ((long long )gw * xx) / g->w;
|
|
|
|
ww = (((long long)gw * (tx + ww)) / g->w) - xx;
|
|
|
|
}
|
|
|
|
if ((gh != g->h) && (g->h > 0))
|
|
|
|
{
|
|
|
|
ty = yy;
|
|
|
|
yy = ((long long)gh * yy) / g->h;
|
|
|
|
hh = (((long long)gh * (ty + hh)) / g->h) - yy;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!ELM_RECTS_INTERSECT(xx - wd->pan_x + ox,
|
2010-01-17 22:44:56 -08:00
|
|
|
yy - wd->pan_y + oy,
|
|
|
|
ww, hh,
|
|
|
|
cvx, cvy, cvw, cvh))
|
2011-04-01 04:26:58 -07:00
|
|
|
{
|
2011-12-13 00:31:55 -08:00
|
|
|
if (gi->file_have)
|
2011-04-01 04:26:58 -07:00
|
|
|
{
|
|
|
|
evas_object_hide(gi->img);
|
2011-12-13 00:31:55 -08:00
|
|
|
//evas_object_hide(gi->txt);
|
2011-04-01 04:26:58 -07:00
|
|
|
evas_object_image_file_set(gi->img, NULL, NULL);
|
|
|
|
}
|
2011-12-04 23:30:31 -08:00
|
|
|
else if (gi->job)
|
2011-04-01 04:26:58 -07:00
|
|
|
{
|
2011-12-13 00:31:55 -08:00
|
|
|
DBG("Download abort %s", gi->file);
|
2011-12-04 23:30:31 -08:00
|
|
|
ecore_file_download_abort(gi->job);
|
|
|
|
ecore_file_remove(gi->file);
|
|
|
|
gi->job = NULL;
|
|
|
|
wd->try_num--;
|
2011-04-01 04:26:58 -07:00
|
|
|
}
|
|
|
|
}
|
2009-11-13 07:22:23 -08:00
|
|
|
}
|
2009-11-15 07:53:37 -08:00
|
|
|
eina_iterator_free(it);
|
2009-11-13 07:22:23 -08:00
|
|
|
|
2011-05-09 07:30:29 -07:00
|
|
|
xx = wd->pan_x / size - 1;
|
2010-01-17 22:44:56 -08:00
|
|
|
if (xx < 0) xx = 0;
|
2009-11-13 07:22:23 -08:00
|
|
|
|
2011-05-09 07:30:29 -07:00
|
|
|
yy = wd->pan_y / size - 1;
|
2010-01-17 22:44:56 -08:00
|
|
|
if (yy < 0) yy = 0;
|
2009-11-13 07:22:23 -08:00
|
|
|
|
2011-05-09 07:30:29 -07:00
|
|
|
ww = ow / size + 2;
|
2010-01-17 22:44:56 -08:00
|
|
|
if (xx + ww >= g->gw) ww = g->gw - xx - 1;
|
2009-11-13 07:22:23 -08:00
|
|
|
|
2011-05-09 07:30:29 -07:00
|
|
|
hh = oh / size + 2;
|
2010-01-17 22:44:56 -08:00
|
|
|
if (yy + hh >= g->gh) hh = g->gh - yy - 1;
|
2009-11-13 07:22:23 -08:00
|
|
|
|
2009-11-17 07:44:11 -08:00
|
|
|
for (y = yy; y <= yy + hh; y++)
|
2009-11-13 07:22:23 -08:00
|
|
|
{
|
2011-04-01 04:26:58 -07:00
|
|
|
for (x = xx; x <= xx + ww; x++)
|
|
|
|
{
|
|
|
|
gi = eina_matrixsparse_data_idx_get(g->grid, y, x);
|
|
|
|
|
|
|
|
if (!gi)
|
|
|
|
{
|
2011-12-13 00:39:01 -08:00
|
|
|
char buf[PATH_MAX];
|
|
|
|
char buf2[PATH_MAX];
|
|
|
|
char *source;
|
|
|
|
|
2011-04-01 04:26:58 -07:00
|
|
|
gi = calloc(1, sizeof(Grid_Item));
|
2011-12-13 00:39:01 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN(gi);
|
|
|
|
|
|
|
|
gi->wd = wd;
|
|
|
|
gi->g = g;
|
|
|
|
gi->zoom = g->zoom;
|
|
|
|
gi->file_have = EINA_FALSE;
|
|
|
|
gi->job = NULL;
|
|
|
|
|
2011-04-01 04:26:58 -07:00
|
|
|
gi->src.x = x * g->tsize;
|
|
|
|
gi->src.y = y * g->tsize;
|
|
|
|
gi->src.w = g->tsize;
|
|
|
|
gi->src.h = g->tsize;
|
|
|
|
|
|
|
|
gi->out.x = gi->src.x;
|
|
|
|
gi->out.y = gi->src.y;
|
|
|
|
gi->out.w = gi->src.w;
|
|
|
|
gi->out.h = gi->src.h;
|
|
|
|
|
|
|
|
gi->img = evas_object_image_add(evas_object_evas_get(obj));
|
2011-12-13 00:39:01 -08:00
|
|
|
evas_object_image_scale_hint_set(gi->img, EVAS_IMAGE_SCALE_HINT_DYNAMIC);
|
2011-04-01 04:26:58 -07:00
|
|
|
evas_object_image_filled_set(gi->img, 1);
|
|
|
|
|
|
|
|
evas_object_smart_member_add(gi->img, wd->pan_smart);
|
|
|
|
elm_widget_sub_object_add(obj, gi->img);
|
|
|
|
evas_object_pass_events_set(gi->img, EINA_TRUE);
|
|
|
|
evas_object_stack_below(gi->img, wd->sep_maps_markers);
|
|
|
|
|
elementary / entry, list, scroller, fileselector_button, config, photocam, map, pan, bg, store, priv, pager, conform, box, clock, flipselector
fixed indentation, removed white spaces.
SVN revision: 58267
2011-04-01 12:08:56 -07:00
|
|
|
/* gi->txt = evas_object_text_add(evas_object_evas_get(obj));
|
|
|
|
evas_object_text_font_set(gi->txt, "Vera", 12);
|
|
|
|
evas_object_color_set(gi->txt, 100, 100, 100, 255);
|
|
|
|
evas_object_smart_member_add(gi->txt,
|
|
|
|
wd->pan_smart);
|
|
|
|
elm_widget_sub_object_add(obj, gi->txt);
|
|
|
|
evas_object_pass_events_set(gi->txt, EINA_TRUE);
|
|
|
|
*/
|
2011-12-13 00:39:01 -08:00
|
|
|
snprintf(buf, sizeof(buf), CACHE_PATH, wd->id, g->zoom, x);
|
|
|
|
snprintf(buf2, sizeof(buf2), CACHE_FILE_PATH, buf, y);
|
|
|
|
if (!ecore_file_exists(buf)) ecore_file_mkpath(buf);
|
2011-04-01 04:26:58 -07:00
|
|
|
|
|
|
|
eina_stringshare_replace(&gi->file, buf2);
|
2011-12-13 00:39:01 -08:00
|
|
|
source = wd->src->url_cb(obj, x, y, g->zoom);
|
|
|
|
if ((!source) || (strlen(source)==0))
|
2011-12-12 19:48:18 -08:00
|
|
|
{
|
2011-12-13 00:39:01 -08:00
|
|
|
eina_stringshare_replace(&gi->source, NULL);
|
|
|
|
WRN("Getting source url failed: %s", gi->file);
|
2011-12-13 00:31:55 -08:00
|
|
|
}
|
2011-12-13 00:39:01 -08:00
|
|
|
else eina_stringshare_replace(&gi->source, source);
|
2011-04-01 04:26:58 -07:00
|
|
|
if (source) free(source);
|
2011-12-13 00:39:01 -08:00
|
|
|
|
|
|
|
eina_matrixsparse_data_idx_set(g->grid, y, x, gi);
|
2011-04-01 04:26:58 -07:00
|
|
|
}
|
2011-12-13 00:39:01 -08:00
|
|
|
|
|
|
|
if (gi->file_have)
|
|
|
|
{
|
|
|
|
DBG("File exists: %s", gi->file);
|
|
|
|
_tile_update(gi);
|
|
|
|
}
|
|
|
|
else if (!gi->job)
|
|
|
|
{
|
|
|
|
DBG("Added to download list: %s", gi->file);
|
|
|
|
_add_download_list(obj, gi);
|
|
|
|
}
|
2011-04-01 04:26:58 -07:00
|
|
|
}
|
2009-11-13 07:22:23 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-12-18 09:45:47 -08:00
|
|
|
static void
|
2009-11-13 07:22:23 -08:00
|
|
|
_smooth_update(Evas_Object *obj)
|
|
|
|
{
|
2011-04-27 22:40:48 -07:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
2009-11-13 07:22:23 -08:00
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
|
|
|
Eina_List *l;
|
|
|
|
Grid *g;
|
|
|
|
|
2010-03-09 08:27:46 -08:00
|
|
|
if (!wd) return;
|
2009-11-13 07:22:23 -08:00
|
|
|
EINA_LIST_FOREACH(wd->grids, l, g)
|
|
|
|
{
|
2011-04-01 04:26:58 -07:00
|
|
|
Eina_Iterator *it = eina_matrixsparse_iterator_new(g->grid);
|
|
|
|
Eina_Matrixsparse_Cell *cell;
|
|
|
|
|
|
|
|
EINA_ITERATOR_FOREACH(it, cell)
|
|
|
|
{
|
|
|
|
Grid_Item *gi = eina_matrixsparse_cell_data_get(cell);
|
|
|
|
evas_object_image_smooth_scale_set(gi->img, (!wd->nosmooth));
|
|
|
|
}
|
|
|
|
eina_iterator_free(it);
|
2009-11-13 07:22:23 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-06-25 02:58:14 -07:00
|
|
|
static Eina_Bool
|
2009-11-13 07:22:23 -08:00
|
|
|
_scr_timeout(void *data)
|
|
|
|
{
|
2011-04-27 22:40:48 -07:00
|
|
|
ELM_CHECK_WIDTYPE(data, widtype) ECORE_CALLBACK_CANCEL;
|
2009-11-13 07:22:23 -08:00
|
|
|
Widget_Data *wd = elm_widget_data_get(data);
|
2011-04-27 22:40:48 -07:00
|
|
|
|
2010-06-25 02:58:14 -07:00
|
|
|
if (!wd) return ECORE_CALLBACK_CANCEL;
|
2009-11-13 07:22:23 -08:00
|
|
|
wd->nosmooth--;
|
2010-10-22 14:41:27 -07:00
|
|
|
if (!wd->nosmooth) _smooth_update(data);
|
2009-11-13 07:22:23 -08:00
|
|
|
wd->scr_timer = NULL;
|
2010-06-25 02:58:14 -07:00
|
|
|
return ECORE_CALLBACK_CANCEL;
|
2009-11-13 07:22:23 -08:00
|
|
|
}
|
|
|
|
|
2009-12-18 09:45:47 -08:00
|
|
|
static void
|
2010-03-09 09:51:30 -08:00
|
|
|
_scr(void *data, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
|
2009-11-13 07:22:23 -08:00
|
|
|
{
|
2011-04-27 22:40:48 -07:00
|
|
|
ELM_CHECK_WIDTYPE(data, widtype);
|
2009-11-13 07:22:23 -08:00
|
|
|
Widget_Data *wd = elm_widget_data_get(data);
|
2011-04-27 22:40:48 -07:00
|
|
|
|
2010-03-09 08:27:46 -08:00
|
|
|
if (!wd) return;
|
2009-11-13 07:22:23 -08:00
|
|
|
if (!wd->scr_timer)
|
|
|
|
{
|
2011-04-01 04:26:58 -07:00
|
|
|
wd->nosmooth++;
|
|
|
|
if (wd->nosmooth == 1) _smooth_update(data);
|
2009-11-13 07:22:23 -08:00
|
|
|
}
|
|
|
|
if (wd->scr_timer) ecore_timer_del(wd->scr_timer);
|
|
|
|
wd->scr_timer = ecore_timer_add(0.5, _scr_timeout, data);
|
|
|
|
}
|
|
|
|
|
2011-04-25 01:11:46 -07:00
|
|
|
static void
|
|
|
|
zoom_do(Evas_Object *obj)
|
2009-11-13 07:22:23 -08:00
|
|
|
{
|
2011-04-27 22:40:48 -07:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
2009-11-13 07:22:23 -08:00
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
|
|
|
Evas_Coord xx, yy, ow, oh;
|
|
|
|
|
2011-04-25 01:11:46 -07:00
|
|
|
if (!wd) return;
|
|
|
|
wd->size.w = wd->size.nw;
|
|
|
|
wd->size.h = wd->size.nh;
|
2009-11-13 07:22:23 -08:00
|
|
|
|
|
|
|
elm_smart_scroller_child_viewport_size_get(wd->scr, &ow, &oh);
|
2011-04-28 00:51:46 -07:00
|
|
|
|
|
|
|
if (wd->center_on.enabled)
|
|
|
|
{
|
2011-04-28 09:52:52 -07:00
|
|
|
elm_map_utils_convert_geo_into_coord(obj, wd->center_on.lon, wd->center_on.lat, wd->size.w, &xx, &yy);
|
|
|
|
xx -= ow / 2;
|
|
|
|
yy -= oh / 2;
|
2011-04-28 00:51:46 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2011-04-28 09:52:52 -07:00
|
|
|
xx = (wd->size.spos.x * wd->size.w) - (ow / 2);
|
|
|
|
yy = (wd->size.spos.y * wd->size.h) - (oh / 2);
|
2011-04-28 00:51:46 -07:00
|
|
|
}
|
|
|
|
|
2009-11-15 13:36:44 -08:00
|
|
|
|
2009-11-13 07:22:23 -08:00
|
|
|
if (xx < 0) xx = 0;
|
|
|
|
else if (xx > (wd->size.w - ow)) xx = wd->size.w - ow;
|
|
|
|
if (yy < 0) yy = 0;
|
|
|
|
else if (yy > (wd->size.h - oh)) yy = wd->size.h - oh;
|
|
|
|
|
2009-11-17 07:44:11 -08:00
|
|
|
wd->show.show = EINA_TRUE;
|
|
|
|
wd->show.x = xx;
|
|
|
|
wd->show.y = yy;
|
|
|
|
wd->show.w = ow;
|
|
|
|
wd->show.h = oh;
|
|
|
|
|
2009-11-13 07:22:23 -08:00
|
|
|
if (wd->calc_job) ecore_job_del(wd->calc_job);
|
|
|
|
wd->calc_job = ecore_job_add(_calc_job, wd);
|
|
|
|
}
|
|
|
|
|
2011-05-07 06:37:31 -07:00
|
|
|
static Eina_Bool
|
|
|
|
_zoom_timeout(void *data)
|
|
|
|
{
|
|
|
|
ELM_CHECK_WIDTYPE(data, widtype) ECORE_CALLBACK_CANCEL;
|
|
|
|
Widget_Data *wd = elm_widget_data_get(data);
|
|
|
|
|
|
|
|
if (!wd) return ECORE_CALLBACK_CANCEL;
|
|
|
|
wd->zoom_timer = NULL;
|
|
|
|
wd->pinch.level = 1.0;
|
|
|
|
zoom_do(data);
|
|
|
|
evas_object_smart_callback_call(data, SIG_ZOOM_STOP, NULL);
|
|
|
|
return ECORE_CALLBACK_CANCEL;
|
|
|
|
}
|
|
|
|
|
2010-06-25 02:58:14 -07:00
|
|
|
static Eina_Bool
|
2009-11-13 07:22:23 -08:00
|
|
|
_zoom_anim(void *data)
|
|
|
|
{
|
2011-04-27 22:40:48 -07:00
|
|
|
ELM_CHECK_WIDTYPE(data, widtype) ECORE_CALLBACK_CANCEL;
|
2009-11-13 07:22:23 -08:00
|
|
|
Evas_Object *obj = data;
|
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
|
|
|
|
2010-06-25 02:58:14 -07:00
|
|
|
if (!wd) return ECORE_CALLBACK_CANCEL;
|
2011-05-05 08:15:43 -07:00
|
|
|
if (wd->zoom_method == ZOOM_METHOD_IN) wd->t += 0.1 ;
|
2011-05-06 23:32:34 -07:00
|
|
|
else if (wd->zoom_method == ZOOM_METHOD_OUT) wd->t -= 0.05;
|
2009-11-13 07:22:23 -08:00
|
|
|
else
|
2011-05-05 08:15:43 -07:00
|
|
|
{
|
2011-05-06 23:32:34 -07:00
|
|
|
wd->zoom_animator = NULL;
|
2011-05-05 08:15:43 -07:00
|
|
|
zoom_do(obj);
|
2011-05-07 06:37:31 -07:00
|
|
|
evas_object_smart_callback_call(data, SIG_ZOOM_STOP, NULL);
|
2011-05-05 08:15:43 -07:00
|
|
|
return ECORE_CALLBACK_CANCEL;
|
|
|
|
}
|
2011-04-25 01:11:46 -07:00
|
|
|
|
2011-05-07 06:37:31 -07:00
|
|
|
if (wd->t >= 2.0)
|
2009-11-13 07:22:23 -08:00
|
|
|
{
|
2011-04-28 00:51:46 -07:00
|
|
|
wd->zoom_animator = NULL;
|
2011-05-07 06:55:30 -07:00
|
|
|
wd->pinch.level = 2.0;
|
2011-05-07 06:37:31 -07:00
|
|
|
if (wd->zoom_timer) ecore_timer_del(wd->zoom_timer);
|
|
|
|
wd->zoom_timer = ecore_timer_add(0.35, _zoom_timeout, obj);
|
|
|
|
return ECORE_CALLBACK_CANCEL;
|
|
|
|
}
|
|
|
|
else if (wd->t <= 0.5)
|
|
|
|
{
|
|
|
|
wd->zoom_animator = NULL;
|
|
|
|
wd->pinch.level = 0.5;
|
|
|
|
if (wd->zoom_timer) ecore_timer_del(wd->zoom_timer);
|
|
|
|
wd->zoom_timer = ecore_timer_add(1.35, _zoom_timeout, obj);
|
2011-04-25 01:11:46 -07:00
|
|
|
return ECORE_CALLBACK_CANCEL;
|
|
|
|
}
|
2011-05-05 08:15:43 -07:00
|
|
|
else if (wd->t != 1.0)
|
2011-04-25 01:11:46 -07:00
|
|
|
{
|
|
|
|
Evas_Coord x, y, w, h;
|
|
|
|
float half_w, half_h;
|
|
|
|
evas_object_geometry_get(data, &x, &y, &w, &h);
|
|
|
|
half_w = (float)w * 0.5;
|
|
|
|
half_h = (float)h * 0.5;
|
|
|
|
wd->pinch.cx = x + half_w;
|
|
|
|
wd->pinch.cy = y + half_h;
|
2011-05-05 08:15:43 -07:00
|
|
|
wd->pinch.level = wd->t;
|
2011-04-25 01:11:46 -07:00
|
|
|
if (wd->calc_job) ecore_job_del(wd->calc_job);
|
|
|
|
wd->calc_job = ecore_job_add(_calc_job, wd);
|
2009-11-13 07:22:23 -08:00
|
|
|
}
|
2011-04-28 00:51:46 -07:00
|
|
|
return ECORE_CALLBACK_RENEW;
|
2009-11-13 07:22:23 -08:00
|
|
|
}
|
|
|
|
|
2010-06-25 02:58:14 -07:00
|
|
|
static Eina_Bool
|
2009-11-13 07:22:23 -08:00
|
|
|
_long_press(void *data)
|
|
|
|
{
|
2011-04-27 22:40:48 -07:00
|
|
|
ELM_CHECK_WIDTYPE(data, widtype) ECORE_CALLBACK_CANCEL;
|
2009-11-13 07:22:23 -08:00
|
|
|
Widget_Data *wd = elm_widget_data_get(data);
|
2011-04-27 22:40:48 -07:00
|
|
|
|
2010-06-25 02:58:14 -07:00
|
|
|
if (!wd) return ECORE_CALLBACK_CANCEL;
|
2009-11-13 07:22:23 -08:00
|
|
|
wd->long_timer = NULL;
|
2011-04-17 23:42:47 -07:00
|
|
|
evas_object_smart_callback_call(data, SIG_LONGPRESSED, &wd->ev);
|
2010-06-25 02:58:14 -07:00
|
|
|
return ECORE_CALLBACK_CANCEL;
|
2009-11-13 07:22:23 -08:00
|
|
|
}
|
|
|
|
|
2009-12-18 09:45:47 -08:00
|
|
|
static void
|
2011-12-20 22:12:08 -08:00
|
|
|
_mouse_down(void *data, Evas *evas __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info)
|
2009-11-13 07:22:23 -08:00
|
|
|
{
|
2011-04-21 01:55:02 -07:00
|
|
|
ELM_CHECK_WIDTYPE(data, widtype);
|
2009-11-13 07:22:23 -08:00
|
|
|
Widget_Data *wd = elm_widget_data_get(data);
|
|
|
|
Evas_Event_Mouse_Down *ev = event_info;
|
2011-01-05 19:43:51 -08:00
|
|
|
|
2009-11-13 07:22:23 -08:00
|
|
|
if (ev->button != 1) return;
|
|
|
|
if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD) wd->on_hold = EINA_TRUE;
|
|
|
|
else wd->on_hold = EINA_FALSE;
|
|
|
|
if (ev->flags & EVAS_BUTTON_DOUBLE_CLICK)
|
2011-04-01 04:26:58 -07:00
|
|
|
evas_object_smart_callback_call(data, SIG_CLICKED_DOUBLE, ev);
|
2009-11-13 07:22:23 -08:00
|
|
|
else
|
2011-04-01 04:26:58 -07:00
|
|
|
evas_object_smart_callback_call(data, SIG_PRESS, ev);
|
2009-11-13 07:22:23 -08:00
|
|
|
if (wd->long_timer) ecore_timer_del(wd->long_timer);
|
2011-12-25 19:50:33 -08:00
|
|
|
wd->ev = *ev;
|
2010-12-06 21:04:45 -08:00
|
|
|
wd->long_timer = ecore_timer_add(_elm_config->longpress_timeout, _long_press, data);
|
2009-11-13 07:22:23 -08:00
|
|
|
}
|
|
|
|
|
2011-01-05 19:43:51 -08:00
|
|
|
static void
|
2011-01-11 01:47:56 -08:00
|
|
|
_mouse_up(void *data, Evas *evas __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info)
|
2009-11-13 07:22:23 -08:00
|
|
|
{
|
2011-04-21 01:55:02 -07:00
|
|
|
ELM_CHECK_WIDTYPE(data, widtype);
|
2009-11-13 07:22:23 -08:00
|
|
|
Widget_Data *wd = elm_widget_data_get(data);
|
2011-12-20 22:12:08 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN(wd);
|
2011-04-27 22:40:48 -07:00
|
|
|
|
2009-11-13 07:22:23 -08:00
|
|
|
Evas_Event_Mouse_Up *ev = event_info;
|
2011-12-20 22:12:08 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN(ev);
|
2011-01-05 19:43:51 -08:00
|
|
|
|
2009-11-13 07:22:23 -08:00
|
|
|
if (ev->button != 1) return;
|
|
|
|
if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD) wd->on_hold = EINA_TRUE;
|
|
|
|
else wd->on_hold = EINA_FALSE;
|
|
|
|
if (wd->long_timer)
|
|
|
|
{
|
2011-04-01 04:26:58 -07:00
|
|
|
ecore_timer_del(wd->long_timer);
|
|
|
|
wd->long_timer = NULL;
|
2009-11-13 07:22:23 -08:00
|
|
|
}
|
2011-01-05 19:43:51 -08:00
|
|
|
if (!wd->on_hold) evas_object_smart_callback_call(data, SIG_CLICKED, ev);
|
2009-11-13 07:22:23 -08:00
|
|
|
wd->on_hold = EINA_FALSE;
|
|
|
|
}
|
|
|
|
|
2011-01-05 19:43:51 -08:00
|
|
|
static void
|
2011-12-20 22:12:08 -08:00
|
|
|
_mouse_wheel_cb(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info)
|
2011-01-05 19:43:51 -08:00
|
|
|
{
|
2011-04-21 01:55:02 -07:00
|
|
|
ELM_CHECK_WIDTYPE(data, widtype);
|
2011-01-05 19:43:51 -08:00
|
|
|
Widget_Data *wd = elm_widget_data_get(data);
|
2011-12-20 22:12:08 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN(wd);
|
2011-01-05 19:43:51 -08:00
|
|
|
|
2011-12-20 22:12:08 -08:00
|
|
|
if (!wd->paused)
|
2011-04-21 01:55:02 -07:00
|
|
|
{
|
2011-12-21 23:54:59 -08:00
|
|
|
int zoom_diff = 0;
|
2011-12-20 22:12:08 -08:00
|
|
|
Evas_Event_Mouse_Wheel *ev = (Evas_Event_Mouse_Wheel*) event_info;
|
|
|
|
Evas_Coord x, y, w, h;
|
2011-01-05 19:43:51 -08:00
|
|
|
|
2011-12-20 22:12:08 -08:00
|
|
|
evas_object_geometry_get(data, &x, &y, &w, &h);
|
2011-01-05 19:43:51 -08:00
|
|
|
|
2011-12-20 22:12:08 -08:00
|
|
|
if (wd->calc_job) ecore_job_del(wd->calc_job);
|
|
|
|
wd->calc_job = ecore_job_add(_calc_job, wd);
|
2011-01-05 19:43:51 -08:00
|
|
|
|
2011-12-20 22:12:08 -08:00
|
|
|
wd->wheel_diff -= ev->z;
|
2011-12-21 23:54:59 -08:00
|
|
|
wd->pinch.level = wd->pinch.diff * pow(2.0, (double)wd->wheel_diff/10);
|
2011-12-20 22:12:08 -08:00
|
|
|
wd->pinch.cx = x + ((double)w * 0.5);
|
|
|
|
wd->pinch.cy = y + ((double)h * 0.5);
|
2011-01-05 19:43:51 -08:00
|
|
|
|
2011-12-29 18:57:17 -08:00
|
|
|
if (wd->pinch.level > 1.99 || wd->pinch.level < 1.01)
|
2011-12-20 22:12:08 -08:00
|
|
|
{
|
2011-12-21 23:54:59 -08:00
|
|
|
wd->wheel_diff = 0;
|
2011-12-29 18:57:17 -08:00
|
|
|
if (wd->pinch.level > 1.99)
|
2011-12-21 23:54:59 -08:00
|
|
|
{
|
|
|
|
zoom_diff = 1;
|
2011-12-29 18:57:17 -08:00
|
|
|
wd->pinch.diff = wd->pinch.level / 2.0;
|
|
|
|
wd->pinch.level = wd->pinch.level / 2.0;
|
2011-12-21 23:54:59 -08:00
|
|
|
}
|
2011-12-29 18:57:17 -08:00
|
|
|
else if (wd->pinch.level < 1.01)
|
2011-12-21 23:54:59 -08:00
|
|
|
{
|
|
|
|
zoom_diff = -1;
|
2011-12-29 18:57:17 -08:00
|
|
|
wd->pinch.diff = wd->pinch.level * 2.0;
|
|
|
|
wd->pinch.level = wd->pinch.level * 2.0;
|
2011-12-21 23:54:59 -08:00
|
|
|
}
|
2011-04-21 01:55:02 -07:00
|
|
|
|
2011-12-20 22:12:08 -08:00
|
|
|
Elm_Map_Zoom_Mode temp;
|
|
|
|
temp = wd->mode;
|
|
|
|
wd->mode = ELM_MAP_ZOOM_MODE_MANUAL;
|
|
|
|
wd->paused = EINA_TRUE;
|
2011-12-21 23:54:59 -08:00
|
|
|
elm_map_zoom_set(data, wd->zoom + zoom_diff);
|
2011-12-20 22:12:08 -08:00
|
|
|
wd->paused = EINA_FALSE;
|
|
|
|
wd->mode = temp;
|
|
|
|
}
|
2011-04-21 01:55:02 -07:00
|
|
|
else
|
2011-01-05 19:43:51 -08:00
|
|
|
{
|
2011-04-21 01:55:02 -07:00
|
|
|
if (wd->calc_job) ecore_job_del(wd->calc_job);
|
|
|
|
wd->calc_job = ecore_job_add(_calc_job, wd);
|
2011-01-05 19:43:51 -08:00
|
|
|
}
|
|
|
|
}
|
2011-04-27 19:47:12 -07:00
|
|
|
}
|
|
|
|
|
2011-04-01 04:26:58 -07:00
|
|
|
static void
|
2011-01-05 19:43:51 -08:00
|
|
|
_rect_resize_cb(void *data, Evas *evas __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
|
|
|
|
{
|
2011-04-27 22:40:48 -07:00
|
|
|
ELM_CHECK_WIDTYPE(data, widtype);
|
2011-01-05 19:43:51 -08:00
|
|
|
Widget_Data *wd = elm_widget_data_get(data);
|
|
|
|
int x, y, w, h;
|
|
|
|
|
|
|
|
evas_object_geometry_get(wd->rect, &x, &y, &w, &h);
|
|
|
|
evas_object_geometry_get(wd->pan_smart, &x, &y, &w, &h);
|
|
|
|
evas_object_resize(wd->rect, w, h);
|
|
|
|
evas_object_move(wd->rect, x, y);
|
|
|
|
}
|
|
|
|
|
2009-12-18 09:45:47 -08:00
|
|
|
static void
|
2009-11-13 07:22:23 -08:00
|
|
|
_del_hook(Evas_Object *obj)
|
|
|
|
{
|
2011-04-27 22:40:48 -07:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
2009-12-20 08:34:45 -08:00
|
|
|
Elm_Map_Group_Class *group_clas;
|
|
|
|
Elm_Map_Marker_Class *marker_clas;
|
2011-01-05 19:43:51 -08:00
|
|
|
Eina_List *l;
|
2011-04-07 23:14:10 -07:00
|
|
|
Evas_Object *p;
|
2011-05-19 22:55:15 -07:00
|
|
|
Path_Node *n;
|
|
|
|
Path_Waypoint *w;
|
2011-04-07 23:14:10 -07:00
|
|
|
Ecore_Event_Handler *h;
|
|
|
|
Elm_Map_Route *r;
|
2011-04-17 23:42:47 -07:00
|
|
|
Elm_Map_Name *na;
|
2011-06-26 10:36:18 -07:00
|
|
|
Evas_Object *route;
|
2009-11-15 07:53:37 -08:00
|
|
|
|
2010-03-09 08:27:46 -08:00
|
|
|
if (!wd) return;
|
2009-12-20 08:34:45 -08:00
|
|
|
EINA_LIST_FREE(wd->groups_clas, group_clas)
|
|
|
|
{
|
2011-04-01 04:26:58 -07:00
|
|
|
if (group_clas->style)
|
|
|
|
eina_stringshare_del(group_clas->style);
|
|
|
|
free(group_clas);
|
2009-12-20 08:34:45 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
EINA_LIST_FREE(wd->markers_clas, marker_clas)
|
|
|
|
{
|
2011-04-01 04:26:58 -07:00
|
|
|
if (marker_clas->style)
|
|
|
|
eina_stringshare_del(marker_clas->style);
|
|
|
|
free(marker_clas);
|
2009-12-20 08:34:45 -08:00
|
|
|
}
|
|
|
|
|
2011-04-07 23:14:10 -07:00
|
|
|
EINA_LIST_FOREACH(wd->route, l, r)
|
|
|
|
{
|
|
|
|
EINA_LIST_FREE(r->path, p)
|
|
|
|
{
|
|
|
|
evas_object_del(p);
|
|
|
|
}
|
|
|
|
|
|
|
|
EINA_LIST_FREE(r->waypoint, w)
|
|
|
|
{
|
|
|
|
if (w->point) eina_stringshare_del(w->point);
|
|
|
|
free(w);
|
|
|
|
}
|
|
|
|
|
|
|
|
EINA_LIST_FREE(r->nodes, n)
|
|
|
|
{
|
|
|
|
if (n->pos.address) eina_stringshare_del(n->pos.address);
|
|
|
|
free(n);
|
|
|
|
}
|
|
|
|
|
|
|
|
EINA_LIST_FREE(r->handlers, h)
|
|
|
|
{
|
|
|
|
ecore_event_handler_del(h);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (r->con_url) ecore_con_url_free(r->con_url);
|
|
|
|
if (r->info.nodes) eina_stringshare_del(r->info.nodes);
|
|
|
|
if (r->info.waypoints) eina_stringshare_del(r->info.waypoints);
|
|
|
|
}
|
2011-04-17 23:42:47 -07:00
|
|
|
|
|
|
|
EINA_LIST_FREE(wd->names, na)
|
|
|
|
{
|
|
|
|
if (na->address) free(na->address);
|
|
|
|
if (na->handler) ecore_event_handler_del(na->handler);
|
|
|
|
if (na->ud.fname)
|
|
|
|
{
|
|
|
|
ecore_file_remove(na->ud.fname);
|
|
|
|
free(na->ud.fname);
|
|
|
|
na->ud.fname = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-06-26 10:36:18 -07:00
|
|
|
EINA_LIST_FREE(wd->track, route)
|
2011-05-19 22:55:15 -07:00
|
|
|
{
|
2011-06-26 10:36:18 -07:00
|
|
|
evas_object_del(route);
|
2011-05-19 22:55:15 -07:00
|
|
|
}
|
|
|
|
|
2011-05-06 23:32:34 -07:00
|
|
|
if (wd->map) evas_map_free(wd->map);
|
2011-05-04 02:44:53 -07:00
|
|
|
if (wd->source_names) free(wd->source_names);
|
2009-11-13 07:22:23 -08:00
|
|
|
if (wd->calc_job) ecore_job_del(wd->calc_job);
|
|
|
|
if (wd->scr_timer) ecore_timer_del(wd->scr_timer);
|
|
|
|
if (wd->zoom_animator) ecore_animator_del(wd->zoom_animator);
|
|
|
|
if (wd->long_timer) ecore_timer_del(wd->long_timer);
|
2011-02-27 01:00:22 -08:00
|
|
|
if (wd->user_agent) eina_stringshare_del(wd->user_agent);
|
|
|
|
if (wd->ua) eina_hash_free(wd->ua);
|
2011-05-21 06:13:53 -07:00
|
|
|
if (wd->markers) free(wd->markers);
|
2009-11-15 07:53:37 -08:00
|
|
|
|
2009-11-13 07:22:23 -08:00
|
|
|
free(wd);
|
|
|
|
}
|
|
|
|
|
2009-12-18 09:45:47 -08:00
|
|
|
static void
|
2009-11-13 14:22:05 -08:00
|
|
|
_del_pre_hook(Evas_Object *obj)
|
|
|
|
{
|
2011-04-27 22:40:48 -07:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
2009-11-15 07:53:37 -08:00
|
|
|
Marker_Group *group;
|
|
|
|
Elm_Map_Marker *marker;
|
|
|
|
int i;
|
|
|
|
Eina_Bool free_marker = EINA_TRUE;
|
2009-12-18 06:28:36 -08:00
|
|
|
Eina_List *l;
|
2009-11-15 08:24:02 -08:00
|
|
|
|
2010-03-09 08:27:46 -08:00
|
|
|
if (!wd) return;
|
2011-12-12 19:48:18 -08:00
|
|
|
grid_clear_all(obj);
|
2011-05-21 06:13:53 -07:00
|
|
|
for (i = 0; i <= wd->zoom_max; i++)
|
2009-11-15 07:53:37 -08:00
|
|
|
{
|
2011-04-01 04:26:58 -07:00
|
|
|
if (!wd->markers[i]) continue;
|
|
|
|
Eina_Iterator *it = eina_matrixsparse_iterator_new(wd->markers[i]);
|
|
|
|
Eina_Matrixsparse_Cell *cell;
|
|
|
|
|
|
|
|
EINA_ITERATOR_FOREACH(it, cell)
|
|
|
|
{
|
|
|
|
l = eina_matrixsparse_cell_data_get(cell);
|
|
|
|
EINA_LIST_FREE(l, group)
|
|
|
|
{
|
|
|
|
EINA_LIST_FREE(group->markers, marker)
|
|
|
|
{
|
|
|
|
evas_object_event_callback_del_full(group->sc, EVAS_CALLBACK_CHANGED_SIZE_HINTS,
|
2011-10-30 17:15:10 -07:00
|
|
|
_bubble_sc_hints_changed_cb, group);
|
2011-04-01 04:26:58 -07:00
|
|
|
if (free_marker) free(marker);
|
|
|
|
}
|
|
|
|
free(group);
|
|
|
|
}
|
|
|
|
free_marker = EINA_FALSE;
|
|
|
|
}
|
|
|
|
eina_iterator_free(it);
|
|
|
|
eina_matrixsparse_free(wd->markers[i]);
|
2009-11-15 07:53:37 -08:00
|
|
|
}
|
|
|
|
|
2010-06-30 12:26:53 -07:00
|
|
|
evas_object_del(wd->sep_maps_markers);
|
2009-11-13 14:22:05 -08:00
|
|
|
evas_object_del(wd->pan_smart);
|
|
|
|
wd->pan_smart = NULL;
|
|
|
|
}
|
|
|
|
|
2010-09-29 05:22:30 -07:00
|
|
|
static void
|
|
|
|
_on_focus_hook(void *data __UNUSED__, Evas_Object *obj)
|
|
|
|
{
|
2011-04-27 22:40:48 -07:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
2010-09-29 05:22:30 -07:00
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
2011-04-27 22:40:48 -07:00
|
|
|
|
2010-09-29 05:22:30 -07:00
|
|
|
if (!wd) return;
|
|
|
|
if (elm_widget_focus_get(obj))
|
|
|
|
{
|
2011-06-14 22:30:23 -07:00
|
|
|
edje_object_signal_emit(elm_smart_scroller_edje_object_get(wd->scr), "elm,action,focus", "elm");
|
2011-04-01 04:26:58 -07:00
|
|
|
evas_object_focus_set(wd->obj, EINA_TRUE);
|
2010-09-29 05:22:30 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2011-06-14 22:30:23 -07:00
|
|
|
edje_object_signal_emit(elm_smart_scroller_edje_object_get(wd->scr), "elm,action,unfocus", "elm");
|
2011-04-01 04:26:58 -07:00
|
|
|
evas_object_focus_set(wd->obj, EINA_FALSE);
|
2010-09-29 05:22:30 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-12-18 09:45:47 -08:00
|
|
|
static void
|
2009-11-13 07:22:23 -08:00
|
|
|
_theme_hook(Evas_Object *obj)
|
|
|
|
{
|
2011-04-27 22:40:48 -07:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
2009-11-13 07:22:23 -08:00
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
2011-04-27 22:40:48 -07:00
|
|
|
|
2010-03-09 08:27:46 -08:00
|
|
|
if (!wd) return;
|
2010-05-11 18:03:46 -07:00
|
|
|
elm_smart_scroller_object_theme_set(obj, wd->scr, "map", "base", elm_widget_style_get(obj));
|
2011-04-01 04:26:58 -07:00
|
|
|
// edje_object_scale_set(wd->scr, elm_widget_scale_get(obj) * _elm_config->scale);
|
2009-11-13 07:22:23 -08:00
|
|
|
_sizing_eval(obj);
|
|
|
|
}
|
|
|
|
|
2009-12-18 09:45:47 -08:00
|
|
|
static void
|
2009-11-13 07:22:23 -08:00
|
|
|
_sizing_eval(Evas_Object *obj)
|
|
|
|
{
|
2011-04-27 22:40:48 -07:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
2009-11-13 07:22:23 -08:00
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
|
|
|
Evas_Coord minw = -1, minh = -1, maxw = -1, maxh = -1;
|
2011-04-27 22:40:48 -07:00
|
|
|
|
2010-03-09 08:27:46 -08:00
|
|
|
if (!wd) return;
|
2009-11-13 07:22:23 -08:00
|
|
|
evas_object_size_hint_max_get(wd->scr, &maxw, &maxh);
|
|
|
|
evas_object_size_hint_min_set(obj, minw, minh);
|
|
|
|
evas_object_size_hint_max_set(obj, maxw, maxh);
|
|
|
|
}
|
|
|
|
|
2009-12-18 09:45:47 -08:00
|
|
|
static void
|
2009-11-13 07:22:23 -08:00
|
|
|
_calc_job(void *data)
|
|
|
|
{
|
|
|
|
Widget_Data *wd = data;
|
|
|
|
Evas_Coord minw, minh;
|
|
|
|
|
2011-05-04 02:44:53 -07:00
|
|
|
if (!wd) return;
|
2009-11-13 07:22:23 -08:00
|
|
|
minw = wd->size.w;
|
|
|
|
minh = wd->size.h;
|
|
|
|
if (wd->resized)
|
|
|
|
{
|
2011-05-06 23:32:34 -07:00
|
|
|
wd->resized = EINA_FALSE;
|
2011-04-01 04:26:58 -07:00
|
|
|
if (wd->mode != ELM_MAP_ZOOM_MODE_MANUAL)
|
|
|
|
{
|
|
|
|
double tz = wd->zoom;
|
|
|
|
wd->zoom = 0.0;
|
|
|
|
elm_map_zoom_set(wd->obj, tz);
|
|
|
|
}
|
2009-11-13 07:22:23 -08:00
|
|
|
}
|
|
|
|
if ((minw != wd->minw) || (minh != wd->minh))
|
|
|
|
{
|
2011-04-01 04:26:58 -07:00
|
|
|
wd->minw = minw;
|
|
|
|
wd->minh = minh;
|
|
|
|
evas_object_smart_callback_call(wd->pan_smart, SIG_CHANGED, NULL);
|
|
|
|
_sizing_eval(wd->obj);
|
2009-11-13 07:22:23 -08:00
|
|
|
}
|
|
|
|
wd->calc_job = NULL;
|
|
|
|
evas_object_smart_changed(wd->pan_smart);
|
|
|
|
}
|
|
|
|
|
2009-12-18 09:45:47 -08:00
|
|
|
static void
|
2009-11-13 07:22:23 -08:00
|
|
|
_pan_set(Evas_Object *obj, Evas_Coord x, Evas_Coord y)
|
|
|
|
{
|
|
|
|
Pan *sd = evas_object_smart_data_get(obj);
|
2010-03-09 08:27:46 -08:00
|
|
|
if (!sd) return;
|
2009-11-13 07:22:23 -08:00
|
|
|
if ((x == sd->wd->pan_x) && (y == sd->wd->pan_y)) return;
|
|
|
|
sd->wd->pan_x = x;
|
|
|
|
sd->wd->pan_y = y;
|
|
|
|
evas_object_smart_changed(obj);
|
|
|
|
}
|
|
|
|
|
2009-12-18 09:45:47 -08:00
|
|
|
static void
|
2009-11-13 07:22:23 -08:00
|
|
|
_pan_get(Evas_Object *obj, Evas_Coord *x, Evas_Coord *y)
|
|
|
|
{
|
|
|
|
Pan *sd = evas_object_smart_data_get(obj);
|
2010-03-09 08:27:46 -08:00
|
|
|
if (!sd) return;
|
2009-11-13 07:22:23 -08:00
|
|
|
if (x) *x = sd->wd->pan_x;
|
|
|
|
if (y) *y = sd->wd->pan_y;
|
|
|
|
}
|
|
|
|
|
2009-12-18 09:45:47 -08:00
|
|
|
static void
|
2009-11-13 07:22:23 -08:00
|
|
|
_pan_max_get(Evas_Object *obj, Evas_Coord *x, Evas_Coord *y)
|
|
|
|
{
|
|
|
|
Pan *sd = evas_object_smart_data_get(obj);
|
|
|
|
Evas_Coord ow, oh;
|
2010-03-09 08:27:46 -08:00
|
|
|
if (!sd) return;
|
2009-11-13 07:22:23 -08:00
|
|
|
evas_object_geometry_get(obj, NULL, NULL, &ow, &oh);
|
|
|
|
ow = sd->wd->minw - ow;
|
|
|
|
if (ow < 0) ow = 0;
|
|
|
|
oh = sd->wd->minh - oh;
|
|
|
|
if (oh < 0) oh = 0;
|
|
|
|
if (x) *x = ow;
|
|
|
|
if (y) *y = oh;
|
|
|
|
}
|
|
|
|
|
2010-11-23 12:20:41 -08:00
|
|
|
static void
|
2010-11-26 05:35:30 -08:00
|
|
|
_pan_min_get(Evas_Object *obj __UNUSED__, Evas_Coord *x, Evas_Coord *y)
|
2010-11-23 12:20:41 -08:00
|
|
|
{
|
|
|
|
if (x) *x = 0;
|
2010-11-23 12:26:08 -08:00
|
|
|
if (y) *y = 0;
|
2010-11-23 12:20:41 -08:00
|
|
|
}
|
|
|
|
|
2009-12-18 09:45:47 -08:00
|
|
|
static void
|
2009-11-13 07:22:23 -08:00
|
|
|
_pan_child_size_get(Evas_Object *obj, Evas_Coord *w, Evas_Coord *h)
|
|
|
|
{
|
|
|
|
Pan *sd = evas_object_smart_data_get(obj);
|
2010-03-09 08:27:46 -08:00
|
|
|
if (!sd) return;
|
2009-11-13 07:22:23 -08:00
|
|
|
if (w) *w = sd->wd->minw;
|
|
|
|
if (h) *h = sd->wd->minh;
|
|
|
|
}
|
|
|
|
|
2009-12-18 09:45:47 -08:00
|
|
|
static void
|
2009-11-13 07:22:23 -08:00
|
|
|
_pan_add(Evas_Object *obj)
|
|
|
|
{
|
|
|
|
Pan *sd;
|
|
|
|
Evas_Object_Smart_Clipped_Data *cd;
|
|
|
|
_pan_sc.add(obj);
|
|
|
|
cd = evas_object_smart_data_get(obj);
|
2010-03-09 08:27:46 -08:00
|
|
|
if (!cd) return;
|
2009-11-13 07:22:23 -08:00
|
|
|
sd = calloc(1, sizeof(Pan));
|
|
|
|
if (!sd) return;
|
|
|
|
sd->__clipped_data = *cd;
|
|
|
|
free(cd);
|
|
|
|
evas_object_smart_data_set(obj, sd);
|
|
|
|
}
|
|
|
|
|
2009-12-18 09:45:47 -08:00
|
|
|
static void
|
2009-11-13 07:22:23 -08:00
|
|
|
_pan_del(Evas_Object *obj)
|
|
|
|
{
|
|
|
|
Pan *sd = evas_object_smart_data_get(obj);
|
|
|
|
if (!sd) return;
|
|
|
|
_pan_sc.del(obj);
|
|
|
|
}
|
|
|
|
|
2009-12-18 09:45:47 -08:00
|
|
|
static void
|
2009-11-13 07:22:23 -08:00
|
|
|
_pan_resize(Evas_Object *obj, Evas_Coord w, Evas_Coord h)
|
|
|
|
{
|
|
|
|
Pan *sd = evas_object_smart_data_get(obj);
|
|
|
|
Evas_Coord ow, oh;
|
2010-03-09 08:27:46 -08:00
|
|
|
if (!sd) return;
|
2009-11-13 07:22:23 -08:00
|
|
|
evas_object_geometry_get(obj, NULL, NULL, &ow, &oh);
|
|
|
|
if ((ow == w) && (oh == h)) return;
|
2011-05-06 23:32:34 -07:00
|
|
|
sd->wd->resized = EINA_TRUE;
|
2009-11-13 07:22:23 -08:00
|
|
|
if (sd->wd->calc_job) ecore_job_del(sd->wd->calc_job);
|
|
|
|
sd->wd->calc_job = ecore_job_add(_calc_job, sd->wd);
|
|
|
|
}
|
|
|
|
|
2009-12-18 09:45:47 -08:00
|
|
|
static void
|
2009-11-13 07:22:23 -08:00
|
|
|
_pan_calculate(Evas_Object *obj)
|
|
|
|
{
|
|
|
|
Pan *sd = evas_object_smart_data_get(obj);
|
|
|
|
Evas_Coord ox, oy, ow, oh;
|
|
|
|
Eina_List *l;
|
|
|
|
Grid *g;
|
2011-12-12 19:48:18 -08:00
|
|
|
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN(sd);
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN(sd->wd);
|
|
|
|
|
2009-11-13 07:22:23 -08:00
|
|
|
evas_object_geometry_get(obj, &ox, &oy, &ow, &oh);
|
|
|
|
rect_place(sd->wd->obj, sd->wd->pan_x, sd->wd->pan_y, ox, oy, ow, oh);
|
|
|
|
EINA_LIST_FOREACH(sd->wd->grids, l, g)
|
|
|
|
{
|
2011-12-13 00:31:55 -08:00
|
|
|
if (sd->wd->zoom == g->zoom) grid_load(sd->wd->obj, g);
|
|
|
|
else if (sd->wd->zoom-1 != g->zoom && sd->wd->zoom+1 != g->zoom) grid_unload(sd->wd->obj, g); // remain only adjacent grids
|
2011-04-01 04:26:58 -07:00
|
|
|
grid_place(sd->wd->obj, g, sd->wd->pan_x, sd->wd->pan_y, ox, oy, ow, oh);
|
2011-12-12 19:48:18 -08:00
|
|
|
if (sd->wd->zoom == g->zoom) marker_place(sd->wd->obj, g, sd->wd->pan_x, sd->wd->pan_y, ox, oy, ow, oh);
|
2011-04-07 23:14:10 -07:00
|
|
|
if (!sd->wd->zoom_animator) route_place(sd->wd->obj, g, sd->wd->pan_x, sd->wd->pan_y, ox, oy, ow, oh);
|
2011-05-19 22:55:15 -07:00
|
|
|
if (!sd->wd->zoom_animator) track_place(sd->wd->obj, g, sd->wd->pan_x, sd->wd->pan_y, ox, oy, ow, oh);
|
2009-11-13 07:22:23 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-01-24 19:53:36 -08:00
|
|
|
static void
|
2010-03-09 09:51:30 -08:00
|
|
|
_pan_move(Evas_Object *obj, Evas_Coord x __UNUSED__, Evas_Coord y __UNUSED__)
|
2010-01-24 19:53:36 -08:00
|
|
|
{
|
|
|
|
Pan *sd = evas_object_smart_data_get(obj);
|
2010-03-09 08:27:46 -08:00
|
|
|
if (!sd) return;
|
2010-01-24 19:53:36 -08:00
|
|
|
if (sd->wd->calc_job) ecore_job_del(sd->wd->calc_job);
|
|
|
|
sd->wd->calc_job = ecore_job_add(_calc_job, sd->wd);
|
|
|
|
}
|
|
|
|
|
2009-12-18 09:45:47 -08:00
|
|
|
static void
|
2010-03-09 09:51:30 -08:00
|
|
|
_hold_on(void *data __UNUSED__, Evas_Object *obj, void *event_info __UNUSED__)
|
2009-11-13 07:22:23 -08:00
|
|
|
{
|
2011-04-27 22:40:48 -07:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
2009-11-13 07:22:23 -08:00
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
2011-04-27 22:40:48 -07:00
|
|
|
|
2009-11-13 07:22:23 -08:00
|
|
|
if (!wd) return;
|
|
|
|
elm_smart_scroller_hold_set(wd->scr, 1);
|
|
|
|
}
|
|
|
|
|
2009-12-18 09:45:47 -08:00
|
|
|
static void
|
2010-03-09 09:51:30 -08:00
|
|
|
_hold_off(void *data __UNUSED__, Evas_Object *obj, void *event_info __UNUSED__)
|
2009-11-13 07:22:23 -08:00
|
|
|
{
|
2011-04-27 22:40:48 -07:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
2009-11-13 07:22:23 -08:00
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
2011-04-27 22:40:48 -07:00
|
|
|
|
2009-11-13 07:22:23 -08:00
|
|
|
if (!wd) return;
|
|
|
|
elm_smart_scroller_hold_set(wd->scr, 0);
|
|
|
|
}
|
|
|
|
|
2009-12-18 09:45:47 -08:00
|
|
|
static void
|
2010-03-09 09:51:30 -08:00
|
|
|
_freeze_on(void *data __UNUSED__, Evas_Object *obj, void *event_info __UNUSED__)
|
2009-11-13 07:22:23 -08:00
|
|
|
{
|
2011-04-27 22:40:48 -07:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
2009-11-13 07:22:23 -08:00
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
2011-04-27 22:40:48 -07:00
|
|
|
|
2009-11-13 07:22:23 -08:00
|
|
|
if (!wd) return;
|
|
|
|
elm_smart_scroller_freeze_set(wd->scr, 1);
|
|
|
|
}
|
|
|
|
|
2009-12-18 09:45:47 -08:00
|
|
|
static void
|
2010-03-09 09:51:30 -08:00
|
|
|
_freeze_off(void *data __UNUSED__, Evas_Object *obj, void *event_info __UNUSED__)
|
2009-11-13 07:22:23 -08:00
|
|
|
{
|
2011-04-27 22:40:48 -07:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
2009-11-13 07:22:23 -08:00
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
2011-04-27 22:40:48 -07:00
|
|
|
|
2009-11-13 07:22:23 -08:00
|
|
|
if (!wd) return;
|
|
|
|
elm_smart_scroller_freeze_set(wd->scr, 0);
|
|
|
|
}
|
|
|
|
|
2009-12-18 09:45:47 -08:00
|
|
|
static void
|
2010-03-09 09:51:30 -08:00
|
|
|
_scr_anim_start(void *data, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
|
2009-11-13 07:22:23 -08:00
|
|
|
{
|
|
|
|
evas_object_smart_callback_call(data, "scroll,anim,start", NULL);
|
|
|
|
}
|
|
|
|
|
2009-12-18 09:45:47 -08:00
|
|
|
static void
|
2010-03-09 09:51:30 -08:00
|
|
|
_scr_anim_stop(void *data, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
|
2009-11-13 07:22:23 -08:00
|
|
|
{
|
|
|
|
evas_object_smart_callback_call(data, "scroll,anim,stop", NULL);
|
|
|
|
}
|
|
|
|
|
2009-12-18 09:45:47 -08:00
|
|
|
static void
|
2010-03-09 09:51:30 -08:00
|
|
|
_scr_drag_start(void *data, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
|
2009-11-13 07:22:23 -08:00
|
|
|
{
|
2009-11-15 13:36:44 -08:00
|
|
|
Widget_Data *wd = elm_widget_data_get(data);
|
2011-12-20 22:12:08 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN(wd);
|
2009-11-15 13:36:44 -08:00
|
|
|
wd->center_on.enabled = EINA_FALSE;
|
2011-12-20 22:12:08 -08:00
|
|
|
|
|
|
|
// FIXME: els_scoller sometimes give start event again & again... it confuses app. (els_scr bug?)
|
|
|
|
if (!wd->scr_started)
|
|
|
|
{
|
|
|
|
wd->scr_started = EINA_TRUE;
|
|
|
|
evas_object_smart_callback_call(data, SIG_SCROLL_DRAG_START, NULL);
|
|
|
|
}
|
2009-11-13 07:22:23 -08:00
|
|
|
}
|
|
|
|
|
2009-12-18 09:45:47 -08:00
|
|
|
static void
|
2010-03-09 09:51:30 -08:00
|
|
|
_scr_drag_stop(void *data, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
|
2009-11-13 07:22:23 -08:00
|
|
|
{
|
2011-12-20 22:12:08 -08:00
|
|
|
Widget_Data *wd = elm_widget_data_get(data);
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN(wd);
|
|
|
|
wd->center_on.enabled = EINA_FALSE;
|
|
|
|
|
|
|
|
// FIXME: els_scoller sometimes give start event again & again... it confuses app. (els_scr bug?)
|
|
|
|
if (wd->scr_started)
|
|
|
|
{
|
|
|
|
wd->scr_started = EINA_FALSE;
|
|
|
|
evas_object_smart_callback_call(data, SIG_SCROLL_DRAG_STOP, NULL);
|
|
|
|
}
|
2009-11-13 07:22:23 -08:00
|
|
|
}
|
|
|
|
|
2009-12-18 09:45:47 -08:00
|
|
|
static void
|
2010-03-09 09:51:30 -08:00
|
|
|
_scr_scroll(void *data, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
|
2009-11-13 07:22:23 -08:00
|
|
|
{
|
2010-04-05 12:21:22 -07:00
|
|
|
evas_object_smart_callback_call(data, SIG_SCROLL, NULL);
|
2009-11-13 07:22:23 -08:00
|
|
|
}
|
|
|
|
|
2009-11-21 14:38:07 -08:00
|
|
|
|
2009-12-18 09:45:47 -08:00
|
|
|
static void
|
2009-11-21 14:38:07 -08:00
|
|
|
_group_object_create(Marker_Group *group)
|
|
|
|
{
|
2009-12-20 08:34:45 -08:00
|
|
|
const char *style = "radio";
|
|
|
|
Evas_Object *icon = NULL;
|
|
|
|
|
2010-03-09 08:27:46 -08:00
|
|
|
if (group->obj) return;
|
2010-10-22 14:41:22 -07:00
|
|
|
if ((!group->clas->priv.objs_notused) || (eina_list_count(group->markers) == 1))
|
2009-12-18 09:00:01 -08:00
|
|
|
{
|
2011-04-01 04:26:58 -07:00
|
|
|
//set icon and style
|
|
|
|
if (eina_list_count(group->markers) == 1)
|
|
|
|
{
|
|
|
|
Elm_Map_Marker *m = eina_list_data_get(group->markers);
|
|
|
|
if (m->clas->style)
|
|
|
|
style = m->clas->style;
|
|
|
|
|
|
|
|
if (m->clas->func.icon_get)
|
|
|
|
icon = m->clas->func.icon_get(group->wd->obj, m, m->data);
|
|
|
|
|
|
|
|
group->delete_object = EINA_TRUE;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (group->clas->style)
|
|
|
|
style = group->clas->style;
|
|
|
|
|
|
|
|
if (group->clas->func.icon_get)
|
|
|
|
icon = group->clas->func.icon_get(group->wd->obj, group->clas->data);
|
|
|
|
|
|
|
|
group->delete_object = EINA_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
group->obj = elm_layout_add(group->wd->obj);
|
|
|
|
elm_layout_theme_set(group->obj, "map/marker", style, elm_widget_style_get(group->wd->obj));
|
|
|
|
|
2011-11-17 13:02:31 -08:00
|
|
|
if (icon) elm_object_part_content_set(group->obj, "elm.icon", icon);
|
2011-04-01 04:26:58 -07:00
|
|
|
|
|
|
|
evas_object_smart_member_add(group->obj, group->wd->pan_smart);
|
|
|
|
elm_widget_sub_object_add(group->wd->obj, group->obj);
|
|
|
|
evas_object_stack_above(group->obj, group->wd->sep_maps_markers);
|
|
|
|
|
|
|
|
if (!group->delete_object)
|
|
|
|
group->clas->priv.objs_used = eina_list_append(group->clas->priv.objs_used, group->obj);
|
2009-12-18 09:00:01 -08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2011-04-01 04:26:58 -07:00
|
|
|
group->delete_object = EINA_FALSE;
|
|
|
|
|
|
|
|
group->obj = eina_list_data_get(group->clas->priv.objs_notused);
|
|
|
|
group->clas->priv.objs_used = eina_list_append(group->clas->priv.objs_used, group->obj);
|
|
|
|
group->clas->priv.objs_notused = eina_list_remove(group->clas->priv.objs_notused, group->obj);
|
|
|
|
evas_object_show(group->obj);
|
2009-12-18 09:00:01 -08:00
|
|
|
}
|
2009-11-21 14:38:07 -08:00
|
|
|
|
2009-12-20 08:34:45 -08:00
|
|
|
edje_object_signal_callback_add(elm_layout_edje_get(group->obj), "open", "elm", _group_open_cb, group);
|
|
|
|
edje_object_signal_callback_add(elm_layout_edje_get(group->obj), "bringin", "elm", _group_bringin_cb, group);
|
2009-12-18 09:00:01 -08:00
|
|
|
|
2009-12-18 12:16:37 -08:00
|
|
|
group->update_nbelems = EINA_TRUE;
|
2009-12-20 08:34:45 -08:00
|
|
|
group->update_resize = EINA_TRUE;
|
|
|
|
group->update_raise = EINA_TRUE;
|
2009-12-18 12:16:37 -08:00
|
|
|
|
2010-03-09 08:27:46 -08:00
|
|
|
if (group->open) _group_bubble_create(group);
|
2009-11-21 14:38:07 -08:00
|
|
|
}
|
|
|
|
|
2009-12-18 09:45:47 -08:00
|
|
|
static void
|
2009-11-21 14:38:07 -08:00
|
|
|
_group_object_free(Marker_Group *group)
|
|
|
|
{
|
2010-03-09 08:27:46 -08:00
|
|
|
if (!group->obj) return;
|
|
|
|
if (!group->delete_object)
|
2009-12-20 08:34:45 -08:00
|
|
|
{
|
2011-04-01 04:26:58 -07:00
|
|
|
group->clas->priv.objs_notused = eina_list_append(group->clas->priv.objs_notused, group->obj);
|
|
|
|
group->clas->priv.objs_used = eina_list_remove(group->clas->priv.objs_used, group->obj);
|
|
|
|
evas_object_hide(group->obj);
|
2009-12-18 09:00:01 -08:00
|
|
|
|
2011-04-01 04:26:58 -07:00
|
|
|
edje_object_signal_callback_del(elm_layout_edje_get(group->obj), "open", "elm", _group_open_cb);
|
|
|
|
edje_object_signal_callback_del(elm_layout_edje_get(group->obj), "bringin", "elm", _group_bringin_cb);
|
2009-12-20 08:34:45 -08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
evas_object_del(group->obj);
|
2009-12-18 09:00:01 -08:00
|
|
|
|
2009-11-21 14:38:07 -08:00
|
|
|
group->obj = NULL;
|
|
|
|
_group_bubble_free(group);
|
|
|
|
}
|
|
|
|
|
2009-12-18 09:45:47 -08:00
|
|
|
static void
|
2010-03-09 09:51:30 -08:00
|
|
|
_group_bubble_mouse_up_cb(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
|
2009-11-15 08:24:02 -08:00
|
|
|
{
|
|
|
|
Marker_Group *group = data;
|
2009-11-15 13:36:44 -08:00
|
|
|
|
2010-03-09 08:27:46 -08:00
|
|
|
if (!evas_object_above_get(group->rect)) return;
|
2009-11-15 08:24:02 -08:00
|
|
|
evas_object_raise(group->bubble);
|
|
|
|
evas_object_raise(group->sc);
|
|
|
|
evas_object_raise(group->rect);
|
|
|
|
}
|
|
|
|
|
2009-12-18 09:45:47 -08:00
|
|
|
static void
|
2009-11-15 07:53:37 -08:00
|
|
|
_group_bubble_create(Marker_Group *group)
|
|
|
|
{
|
2010-03-09 08:27:46 -08:00
|
|
|
if (group->bubble) return;
|
2009-11-15 07:53:37 -08:00
|
|
|
|
2009-11-22 02:15:12 -08:00
|
|
|
group->wd->opened_bubbles = eina_list_append(group->wd->opened_bubbles, group);
|
2009-11-15 07:53:37 -08:00
|
|
|
group->bubble = edje_object_add(evas_object_evas_get(group->obj));
|
2010-05-11 18:03:46 -07:00
|
|
|
_elm_theme_object_set(group->wd->obj, group->bubble, "map", "marker_bubble",
|
|
|
|
elm_widget_style_get(group->wd->obj));
|
2009-11-15 07:53:37 -08:00
|
|
|
evas_object_smart_member_add(group->bubble,
|
2010-03-09 08:27:46 -08:00
|
|
|
group->wd->obj);
|
2009-11-15 07:53:37 -08:00
|
|
|
elm_widget_sub_object_add(group->wd->obj, group->bubble);
|
2011-04-01 04:26:58 -07:00
|
|
|
|
2009-11-18 13:07:01 -08:00
|
|
|
_group_bubble_content_free(group);
|
2010-03-09 08:27:46 -08:00
|
|
|
if (!_group_bubble_content_update(group))
|
2009-12-21 09:01:19 -08:00
|
|
|
{
|
2011-04-01 04:26:58 -07:00
|
|
|
//no content, we can delete the bubble
|
|
|
|
_group_bubble_free(group);
|
|
|
|
return;
|
2009-12-21 09:01:19 -08:00
|
|
|
}
|
2011-04-01 04:26:58 -07:00
|
|
|
|
2009-11-15 08:24:02 -08:00
|
|
|
group->rect = evas_object_rectangle_add(evas_object_evas_get(group->obj));
|
|
|
|
evas_object_color_set(group->rect, 0, 0, 0, 0);
|
|
|
|
evas_object_repeat_events_set(group->rect, EINA_TRUE);
|
2010-05-11 18:03:46 -07:00
|
|
|
evas_object_smart_member_add(group->rect, group->wd->obj);
|
2009-11-15 08:24:02 -08:00
|
|
|
elm_widget_sub_object_add(group->wd->obj, group->rect);
|
2011-04-01 04:26:58 -07:00
|
|
|
|
2009-11-15 11:52:07 -08:00
|
|
|
evas_object_event_callback_add(group->rect, EVAS_CALLBACK_MOUSE_UP, _group_bubble_mouse_up_cb, group);
|
2011-04-01 04:26:58 -07:00
|
|
|
|
2009-11-15 08:24:02 -08:00
|
|
|
_group_bubble_place(group);
|
2009-11-15 07:53:37 -08:00
|
|
|
}
|
|
|
|
|
2011-10-30 17:15:10 -07:00
|
|
|
static void _bubble_sc_hints_changed_cb(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
|
2009-11-16 13:32:33 -08:00
|
|
|
{
|
|
|
|
_group_bubble_place(data);
|
|
|
|
}
|
|
|
|
|
2009-12-21 09:01:19 -08:00
|
|
|
static int
|
2009-11-15 07:53:37 -08:00
|
|
|
_group_bubble_content_update(Marker_Group *group)
|
|
|
|
{
|
|
|
|
Eina_List *l;
|
|
|
|
Elm_Map_Marker *marker;
|
2009-11-18 13:07:01 -08:00
|
|
|
int i = 0;
|
2009-11-15 07:53:37 -08:00
|
|
|
|
2010-03-09 08:27:46 -08:00
|
|
|
if (!group->bubble) return 1;
|
2009-11-15 07:53:37 -08:00
|
|
|
|
2010-03-09 08:27:46 -08:00
|
|
|
if (!group->sc)
|
2009-11-15 07:53:37 -08:00
|
|
|
{
|
2011-04-01 04:26:58 -07:00
|
|
|
group->sc = elm_scroller_add(group->bubble);
|
|
|
|
elm_widget_style_set(group->sc, "map_bubble");
|
|
|
|
elm_scroller_content_min_limit(group->sc, EINA_FALSE, EINA_TRUE);
|
|
|
|
elm_scroller_policy_set(group->sc, ELM_SCROLLER_POLICY_AUTO, ELM_SCROLLER_POLICY_OFF);
|
|
|
|
elm_scroller_bounce_set(group->sc, _elm_config->thumbscroll_bounce_enable, EINA_FALSE);
|
|
|
|
edje_object_part_swallow(group->bubble, "elm.swallow.content", group->sc);
|
|
|
|
evas_object_show(group->sc);
|
|
|
|
evas_object_smart_member_add(group->sc,
|
2010-03-09 08:27:46 -08:00
|
|
|
group->wd->obj);
|
2011-04-01 04:26:58 -07:00
|
|
|
elm_widget_sub_object_add(group->wd->obj, group->sc);
|
|
|
|
|
|
|
|
group->bx = elm_box_add(group->bubble);
|
|
|
|
evas_object_size_hint_align_set(group->bx, EVAS_HINT_FILL, EVAS_HINT_FILL);
|
|
|
|
evas_object_size_hint_weight_set(group->bx, 0.5, 0.5);
|
|
|
|
elm_box_horizontal_set(group->bx, EINA_TRUE);
|
|
|
|
evas_object_show(group->bx);
|
|
|
|
|
2011-10-30 19:56:03 -07:00
|
|
|
elm_object_content_set(group->sc, group->bx);
|
2011-04-01 04:26:58 -07:00
|
|
|
|
2011-10-30 17:13:32 -07:00
|
|
|
evas_object_event_callback_add(group->sc, EVAS_CALLBACK_CHANGED_SIZE_HINTS,
|
2011-10-30 17:15:10 -07:00
|
|
|
_bubble_sc_hints_changed_cb, group);
|
2009-11-15 07:53:37 -08:00
|
|
|
}
|
2011-04-01 04:26:58 -07:00
|
|
|
|
2009-11-15 07:53:37 -08:00
|
|
|
EINA_LIST_FOREACH(group->markers, l, marker)
|
|
|
|
{
|
2011-04-01 04:26:58 -07:00
|
|
|
if (i >= group->wd->markers_max_num) break;
|
|
|
|
if ((!marker->content) && (marker->clas->func.get))
|
|
|
|
marker->content = marker->clas->func.get(group->wd->obj, marker, marker->data);
|
|
|
|
else if (marker->content)
|
|
|
|
elm_box_unpack(group->bx, marker->content);
|
|
|
|
if (marker->content)
|
|
|
|
{
|
|
|
|
elm_box_pack_end(group->bx, marker->content);
|
|
|
|
i++;
|
|
|
|
}
|
2009-11-15 07:53:37 -08:00
|
|
|
}
|
2009-12-21 09:01:19 -08:00
|
|
|
return i;
|
2009-11-15 07:53:37 -08:00
|
|
|
}
|
|
|
|
|
2009-12-18 09:45:47 -08:00
|
|
|
static void
|
2009-11-15 07:53:37 -08:00
|
|
|
_group_bubble_content_free(Marker_Group *group)
|
|
|
|
{
|
|
|
|
Eina_List *l;
|
|
|
|
Elm_Map_Marker *marker;
|
|
|
|
|
2010-03-09 08:27:46 -08:00
|
|
|
if (!group->sc) return;
|
2009-11-15 07:53:37 -08:00
|
|
|
EINA_LIST_FOREACH(group->markers, l, marker)
|
|
|
|
{
|
2011-04-01 04:26:58 -07:00
|
|
|
if ((marker->content) && (marker->clas->func.del))
|
|
|
|
marker->clas->func.del(group->wd->obj, marker, marker->data, marker->content);
|
|
|
|
else if (marker->content)
|
|
|
|
evas_object_del(marker->content);
|
|
|
|
marker->content = NULL;
|
2009-11-15 07:53:37 -08:00
|
|
|
}
|
|
|
|
evas_object_del(group->sc);
|
|
|
|
group->sc = NULL;
|
|
|
|
}
|
|
|
|
|
2009-12-18 09:45:47 -08:00
|
|
|
static void
|
2009-11-15 07:53:37 -08:00
|
|
|
_group_bubble_free(Marker_Group *group)
|
|
|
|
{
|
2010-03-09 08:27:46 -08:00
|
|
|
if (!group->bubble) return;
|
2009-11-22 02:15:12 -08:00
|
|
|
group->wd->opened_bubbles = eina_list_remove(group->wd->opened_bubbles, group);
|
2009-11-18 13:07:01 -08:00
|
|
|
evas_object_event_callback_del_full(group->sc, EVAS_CALLBACK_CHANGED_SIZE_HINTS,
|
2011-10-30 17:15:10 -07:00
|
|
|
_bubble_sc_hints_changed_cb, group);
|
2009-11-15 07:53:37 -08:00
|
|
|
evas_object_del(group->bubble);
|
2009-11-15 08:24:02 -08:00
|
|
|
evas_object_del(group->rect);
|
2009-11-15 07:53:37 -08:00
|
|
|
group->bubble = NULL;
|
|
|
|
_group_bubble_content_free(group);
|
|
|
|
}
|
|
|
|
|
2009-12-18 09:45:47 -08:00
|
|
|
static void
|
2009-11-15 07:53:37 -08:00
|
|
|
_group_bubble_place(Marker_Group *group)
|
|
|
|
{
|
2009-11-25 12:51:28 -08:00
|
|
|
Evas_Coord x, y, w;
|
2009-11-15 07:53:37 -08:00
|
|
|
Evas_Coord xx, yy, ww, hh;
|
|
|
|
const char *s;
|
|
|
|
|
2010-10-22 14:41:22 -07:00
|
|
|
if ((!group->bubble) || (!group->obj)) return;
|
2009-11-16 13:32:33 -08:00
|
|
|
|
|
|
|
evas_object_geometry_get(group->obj, &x, &y, &w, NULL);
|
|
|
|
edje_object_size_min_calc(group->bubble, NULL, &hh);
|
2009-11-15 07:53:37 -08:00
|
|
|
|
|
|
|
s = edje_object_data_get(group->bubble, "size_w");
|
2011-02-13 05:16:59 -08:00
|
|
|
if (s) ww = atoi(s);
|
|
|
|
else ww = 0;
|
2010-03-09 08:27:46 -08:00
|
|
|
xx = x + w / 2 - ww / 2;
|
2009-11-15 07:53:37 -08:00
|
|
|
yy = y-hh;
|
|
|
|
|
|
|
|
evas_object_move(group->bubble, xx, yy);
|
|
|
|
evas_object_resize(group->bubble, ww, hh);
|
2012-01-13 15:45:53 -08:00
|
|
|
obj_rotate_zoom(group->wd->obj, group->bubble);
|
2009-11-15 07:53:37 -08:00
|
|
|
evas_object_show(group->bubble);
|
2009-11-15 08:24:02 -08:00
|
|
|
|
|
|
|
evas_object_move(group->rect, xx, yy);
|
|
|
|
evas_object_resize(group->rect, ww, hh);
|
2012-01-13 15:45:53 -08:00
|
|
|
obj_rotate_zoom(group->wd->obj, group->rect);
|
2009-11-15 08:24:02 -08:00
|
|
|
evas_object_show(group->rect);
|
2009-11-15 07:53:37 -08:00
|
|
|
}
|
|
|
|
|
2009-12-18 09:45:47 -08:00
|
|
|
static void
|
2010-03-09 09:51:30 -08:00
|
|
|
_group_bringin_cb(void *data, Evas_Object *obj __UNUSED__, const char *emission __UNUSED__, const char *soure __UNUSED__)
|
2009-11-15 13:36:44 -08:00
|
|
|
{
|
2009-11-15 11:52:07 -08:00
|
|
|
Marker_Group *group = data;
|
2009-11-17 07:44:11 -08:00
|
|
|
Elm_Map_Marker *marker = eina_list_data_get(group->markers);
|
2010-03-09 08:27:46 -08:00
|
|
|
if (!marker) return;
|
2009-11-15 11:52:07 -08:00
|
|
|
group->bringin = EINA_TRUE;
|
2009-11-17 07:44:11 -08:00
|
|
|
elm_map_geo_region_bring_in(group->wd->obj, marker->longitude, marker->latitude);
|
2009-11-15 11:52:07 -08:00
|
|
|
}
|
2009-11-15 07:53:37 -08:00
|
|
|
|
2009-12-18 09:45:47 -08:00
|
|
|
static void
|
2010-03-09 09:51:30 -08:00
|
|
|
_group_open_cb(void *data, Evas_Object *obj __UNUSED__, const char *emission __UNUSED__, const char *soure __UNUSED__)
|
2009-11-15 07:53:37 -08:00
|
|
|
{
|
|
|
|
Marker_Group *group = data;
|
|
|
|
|
2010-03-09 08:27:46 -08:00
|
|
|
if (group->bringin)
|
2009-11-15 11:52:07 -08:00
|
|
|
{
|
2011-04-01 04:26:58 -07:00
|
|
|
group->bringin = EINA_FALSE;
|
|
|
|
return;
|
2009-11-15 11:52:07 -08:00
|
|
|
}
|
|
|
|
|
2010-03-09 08:27:46 -08:00
|
|
|
if (group->bubble)
|
2009-11-15 07:53:37 -08:00
|
|
|
{
|
2011-04-01 04:26:58 -07:00
|
|
|
group->open = EINA_FALSE;
|
|
|
|
_group_bubble_free(group);
|
|
|
|
return;
|
2009-11-15 07:53:37 -08:00
|
|
|
}
|
|
|
|
group->open = EINA_TRUE;
|
|
|
|
_group_bubble_create(group);
|
|
|
|
}
|
|
|
|
|
2011-01-04 00:45:27 -08:00
|
|
|
static Eina_Bool
|
|
|
|
_event_hook(Evas_Object *obj, Evas_Object *src __UNUSED__, Evas_Callback_Type type, void *event_info)
|
|
|
|
{
|
2011-04-27 22:40:48 -07:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
|
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
2011-05-05 08:15:43 -07:00
|
|
|
int zoom;
|
2011-01-04 00:45:27 -08:00
|
|
|
Evas_Coord x = 0;
|
|
|
|
Evas_Coord y = 0;
|
|
|
|
Evas_Coord step_x = 0;
|
|
|
|
Evas_Coord step_y = 0;
|
|
|
|
Evas_Coord v_w = 0;
|
|
|
|
Evas_Coord v_h = 0;
|
|
|
|
Evas_Coord page_x = 0;
|
|
|
|
Evas_Coord page_y = 0;
|
|
|
|
|
2011-04-27 22:40:48 -07:00
|
|
|
if (!wd) return EINA_FALSE;
|
2011-01-04 00:45:27 -08:00
|
|
|
if (type != EVAS_CALLBACK_KEY_DOWN) return EINA_FALSE;
|
|
|
|
Evas_Event_Key_Down *ev = event_info;
|
|
|
|
if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD) return EINA_FALSE;
|
|
|
|
|
|
|
|
elm_smart_scroller_child_pos_get(wd->scr, &x, &y);
|
|
|
|
elm_smart_scroller_step_size_get(wd->scr, &step_x, &step_y);
|
|
|
|
elm_smart_scroller_page_size_get(wd->scr, &page_x, &page_y);
|
|
|
|
elm_smart_scroller_child_viewport_size_get(wd->scr, &v_w, &v_h);
|
|
|
|
|
|
|
|
if ((!strcmp(ev->keyname, "Left")) || (!strcmp(ev->keyname, "KP_Left")))
|
|
|
|
{
|
|
|
|
x -= step_x;
|
|
|
|
}
|
|
|
|
else if ((!strcmp(ev->keyname, "Right")) || (!strcmp(ev->keyname, "KP_Right")))
|
|
|
|
{
|
|
|
|
x += step_x;
|
|
|
|
}
|
|
|
|
else if ((!strcmp(ev->keyname, "Up")) || (!strcmp(ev->keyname, "KP_Up")))
|
|
|
|
{
|
|
|
|
y -= step_y;
|
|
|
|
}
|
|
|
|
else if ((!strcmp(ev->keyname, "Down")) || (!strcmp(ev->keyname, "KP_Down")))
|
|
|
|
{
|
|
|
|
y += step_y;
|
|
|
|
}
|
|
|
|
else if ((!strcmp(ev->keyname, "Prior")) || (!strcmp(ev->keyname, "KP_Prior")))
|
|
|
|
{
|
|
|
|
if (page_y < 0)
|
2011-04-01 04:26:58 -07:00
|
|
|
y -= -(page_y * v_h) / 100;
|
2011-01-04 00:45:27 -08:00
|
|
|
else
|
2011-04-01 04:26:58 -07:00
|
|
|
y -= page_y;
|
2011-01-04 00:45:27 -08:00
|
|
|
}
|
|
|
|
else if ((!strcmp(ev->keyname, "Next")) || (!strcmp(ev->keyname, "KP_Next")))
|
|
|
|
{
|
|
|
|
if (page_y < 0)
|
2011-04-01 04:26:58 -07:00
|
|
|
y += -(page_y * v_h) / 100;
|
2011-01-04 00:45:27 -08:00
|
|
|
else
|
2011-04-01 04:26:58 -07:00
|
|
|
y += page_y;
|
2011-01-04 00:45:27 -08:00
|
|
|
}
|
|
|
|
else if (!strcmp(ev->keyname, "KP_Add"))
|
|
|
|
{
|
2011-05-05 08:15:43 -07:00
|
|
|
zoom = elm_map_zoom_get(obj) + 1;
|
2011-01-04 00:45:27 -08:00
|
|
|
elm_map_zoom_mode_set(obj, ELM_MAP_ZOOM_MODE_MANUAL);
|
|
|
|
elm_map_zoom_set(obj, zoom);
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
else if (!strcmp(ev->keyname, "KP_Subtract"))
|
|
|
|
{
|
2011-05-05 08:15:43 -07:00
|
|
|
zoom = elm_map_zoom_get(obj) - 1;
|
2011-01-04 00:45:27 -08:00
|
|
|
elm_map_zoom_mode_set(obj, ELM_MAP_ZOOM_MODE_MANUAL);
|
|
|
|
elm_map_zoom_set(obj, zoom);
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
else return EINA_FALSE;
|
|
|
|
|
|
|
|
ev->event_flags |= EVAS_EVENT_FLAG_ON_HOLD;
|
|
|
|
elm_smart_scroller_child_pos_set(wd->scr, x, y);
|
|
|
|
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
|
2011-04-07 23:14:10 -07:00
|
|
|
static Eina_Bool
|
2011-04-17 23:42:47 -07:00
|
|
|
cb_dump_name_attrs(void *data, const char *key, const char *value)
|
2011-04-07 23:14:10 -07:00
|
|
|
{
|
2011-04-17 23:42:47 -07:00
|
|
|
Name_Dump *dump = (Name_Dump*)data;
|
|
|
|
if (!dump) return EINA_FALSE;
|
|
|
|
|
|
|
|
if (!strncmp(key, NOMINATIM_ATTR_LON, sizeof(NOMINATIM_ATTR_LON))) dump->lon = atof(value);
|
|
|
|
else if (!strncmp(key, NOMINATIM_ATTR_LAT, sizeof(NOMINATIM_ATTR_LAT))) dump->lat = atof(value);
|
|
|
|
|
2011-04-07 23:14:10 -07:00
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static Eina_Bool
|
2011-04-17 23:42:47 -07:00
|
|
|
cb_route_dump(void *data, Eina_Simple_XML_Type type, const char *value, unsigned offset __UNUSED__, unsigned length)
|
2011-04-07 23:14:10 -07:00
|
|
|
{
|
|
|
|
Route_Dump *dump = data;
|
2011-04-17 23:42:47 -07:00
|
|
|
if (!dump) return EINA_FALSE;
|
2011-04-07 23:14:10 -07:00
|
|
|
|
|
|
|
switch (type)
|
|
|
|
{
|
|
|
|
case EINA_SIMPLE_XML_OPEN:
|
|
|
|
case EINA_SIMPLE_XML_OPEN_EMPTY:
|
|
|
|
{
|
|
|
|
const char *attrs;
|
|
|
|
|
|
|
|
attrs = eina_simple_xml_tag_attributes_find(value, length);
|
|
|
|
if (!attrs)
|
|
|
|
{
|
|
|
|
if (!strncmp(value, YOURS_DISTANCE, length)) dump->id = ROUTE_XML_DISTANCE;
|
|
|
|
else if (!strncmp(value, YOURS_DESCRIPTION, length)) dump->id = ROUTE_XML_DESCRIPTION;
|
|
|
|
else if (!strncmp(value, YOURS_COORDINATES, length)) dump->id = ROUTE_XML_COORDINATES;
|
|
|
|
else dump->id = ROUTE_XML_NONE;
|
|
|
|
}
|
2011-04-17 23:42:47 -07:00
|
|
|
}
|
2011-04-07 23:14:10 -07:00
|
|
|
break;
|
|
|
|
case EINA_SIMPLE_XML_DATA:
|
|
|
|
{
|
|
|
|
char *buf = malloc(length);
|
2011-04-08 01:42:32 -07:00
|
|
|
if (!buf) return EINA_FALSE;
|
2011-04-07 23:14:10 -07:00
|
|
|
snprintf(buf, length, "%s", value);
|
|
|
|
if (dump->id == ROUTE_XML_DISTANCE) dump->distance = atof(buf);
|
|
|
|
else if (!(dump->description) && (dump->id == ROUTE_XML_DESCRIPTION)) dump->description = strdup(buf);
|
|
|
|
else if (dump->id == ROUTE_XML_COORDINATES) dump->coordinates = strdup(buf);
|
|
|
|
free(buf);
|
|
|
|
}
|
|
|
|
break;
|
2011-04-08 01:42:32 -07:00
|
|
|
default:
|
|
|
|
break;
|
2011-04-07 23:14:10 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
|
2011-04-17 23:42:47 -07:00
|
|
|
static Eina_Bool
|
|
|
|
cb_name_dump(void *data, Eina_Simple_XML_Type type, const char *value, unsigned offset __UNUSED__, unsigned length)
|
|
|
|
{
|
|
|
|
Name_Dump *dump = data;
|
|
|
|
if (!dump) return EINA_FALSE;
|
|
|
|
|
|
|
|
switch (type)
|
|
|
|
{
|
|
|
|
case EINA_SIMPLE_XML_OPEN:
|
|
|
|
case EINA_SIMPLE_XML_OPEN_EMPTY:
|
|
|
|
{
|
|
|
|
const char *attrs;
|
|
|
|
attrs = eina_simple_xml_tag_attributes_find(value, length);
|
|
|
|
if (attrs)
|
|
|
|
{
|
2011-05-06 23:32:34 -07:00
|
|
|
if (!strncmp(value, NOMINATIM_RESULT, sizeof(NOMINATIM_RESULT) - 1)) dump->id = NAME_XML_NAME;
|
2011-04-17 23:42:47 -07:00
|
|
|
else dump->id = NAME_XML_NONE;
|
|
|
|
|
|
|
|
eina_simple_xml_attributes_parse
|
|
|
|
(attrs, length - (attrs - value), cb_dump_name_attrs, dump);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case EINA_SIMPLE_XML_DATA:
|
|
|
|
{
|
|
|
|
char *buf = malloc(length + 1);
|
|
|
|
if (!buf) return EINA_FALSE;
|
|
|
|
snprintf(buf, length + 1, "%s", value);
|
|
|
|
if (dump->id == NAME_XML_NAME) dump->address = strdup(buf);
|
|
|
|
free(buf);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
|
2011-04-07 23:14:10 -07:00
|
|
|
static void
|
|
|
|
_parse_kml(void *data)
|
|
|
|
{
|
|
|
|
Elm_Map_Route *r = (Elm_Map_Route*)data;
|
2011-08-05 16:11:28 -07:00
|
|
|
if (!r || !r->ud.fname) return;
|
2011-04-07 23:14:10 -07:00
|
|
|
|
|
|
|
FILE *f;
|
|
|
|
char **str;
|
|
|
|
unsigned int ele, idx;
|
|
|
|
double lon, lat;
|
|
|
|
Evas_Object *path;
|
|
|
|
|
|
|
|
Route_Dump dump = {0, r->ud.fname, 0.0, NULL, NULL};
|
|
|
|
|
|
|
|
f = fopen(r->ud.fname, "rb");
|
|
|
|
if (f)
|
|
|
|
{
|
|
|
|
long sz;
|
|
|
|
|
|
|
|
fseek(f, 0, SEEK_END);
|
|
|
|
sz = ftell(f);
|
|
|
|
if (sz > 0)
|
|
|
|
{
|
|
|
|
char *buf;
|
|
|
|
|
|
|
|
fseek(f, 0, SEEK_SET);
|
|
|
|
buf = malloc(sz);
|
|
|
|
if (buf)
|
|
|
|
{
|
|
|
|
if (fread(buf, 1, sz, f))
|
|
|
|
{
|
2011-04-17 23:42:47 -07:00
|
|
|
eina_simple_xml_parse(buf, sz, EINA_TRUE, cb_route_dump, &dump);
|
2011-04-07 23:14:10 -07:00
|
|
|
free(buf);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
fclose(f);
|
|
|
|
|
|
|
|
if (dump.distance) r->info.distance = dump.distance;
|
|
|
|
if (dump.description)
|
|
|
|
{
|
|
|
|
eina_stringshare_replace(&r->info.waypoints, dump.description);
|
|
|
|
str = eina_str_split_full(dump.description, "\n", 0, &ele);
|
|
|
|
r->info.waypoint_count = ele;
|
|
|
|
for (idx = 0 ; idx < ele ; idx++)
|
|
|
|
{
|
2011-05-19 22:55:15 -07:00
|
|
|
Path_Waypoint *wp = ELM_NEW(Path_Waypoint);
|
2011-04-07 23:14:10 -07:00
|
|
|
if (wp)
|
|
|
|
{
|
|
|
|
wp->wd = r->wd;
|
|
|
|
wp->point = eina_stringshare_add(str[idx]);
|
|
|
|
DBG("%s", str[idx]);
|
|
|
|
r->waypoint = eina_list_append(r->waypoint, wp);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (str && str[0])
|
|
|
|
{
|
|
|
|
free(str[0]);
|
|
|
|
free(str);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else WRN("description is not found !");
|
|
|
|
|
|
|
|
if (dump.coordinates)
|
|
|
|
{
|
|
|
|
eina_stringshare_replace(&r->info.nodes, dump.coordinates);
|
|
|
|
str = eina_str_split_full(dump.coordinates, "\n", 0, &ele);
|
|
|
|
r->info.node_count = ele;
|
|
|
|
for (idx = 0 ; idx < ele ; idx++)
|
|
|
|
{
|
|
|
|
sscanf(str[idx], "%lf,%lf", &lon, &lat);
|
2011-05-19 22:55:15 -07:00
|
|
|
Path_Node *n = ELM_NEW(Path_Node);
|
2011-04-07 23:14:10 -07:00
|
|
|
if (n)
|
|
|
|
{
|
|
|
|
n->wd = r->wd;
|
|
|
|
n->pos.lon = lon;
|
|
|
|
n->pos.lat = lat;
|
|
|
|
n->idx = idx;
|
|
|
|
DBG("%lf:%lf", lon, lat);
|
|
|
|
n->pos.address = NULL;
|
|
|
|
r->nodes = eina_list_append(r->nodes, n);
|
|
|
|
|
2011-04-28 09:52:52 -07:00
|
|
|
path = evas_object_polygon_add(evas_object_evas_get(r->wd->obj));
|
2011-04-07 23:14:10 -07:00
|
|
|
evas_object_smart_member_add(path, r->wd->pan_smart);
|
|
|
|
r->path = eina_list_append(r->path, path);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (str && str[0])
|
|
|
|
{
|
|
|
|
free(str[0]);
|
|
|
|
free(str);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-04-17 23:42:47 -07:00
|
|
|
static void
|
|
|
|
_parse_name(void *data)
|
|
|
|
{
|
|
|
|
Elm_Map_Name *n = (Elm_Map_Name*)data;
|
2011-08-05 16:11:28 -07:00
|
|
|
if (!n || !n->ud.fname) return;
|
2011-04-17 23:42:47 -07:00
|
|
|
|
|
|
|
FILE *f;
|
|
|
|
|
|
|
|
Name_Dump dump = {0, NULL, 0.0, 0.0};
|
|
|
|
|
|
|
|
f = fopen(n->ud.fname, "rb");
|
|
|
|
if (f)
|
|
|
|
{
|
|
|
|
long sz;
|
|
|
|
|
|
|
|
fseek(f, 0, SEEK_END);
|
|
|
|
sz = ftell(f);
|
|
|
|
if (sz > 0)
|
|
|
|
{
|
|
|
|
char *buf;
|
|
|
|
|
|
|
|
fseek(f, 0, SEEK_SET);
|
|
|
|
buf = malloc(sz);
|
|
|
|
if (buf)
|
|
|
|
{
|
|
|
|
if (fread(buf, 1, sz, f))
|
|
|
|
{
|
|
|
|
eina_simple_xml_parse(buf, sz, EINA_TRUE, cb_name_dump, &dump);
|
|
|
|
free(buf);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
fclose(f);
|
|
|
|
|
|
|
|
if (dump.address)
|
|
|
|
{
|
|
|
|
INF("[%lf : %lf] ADDRESS : %s", n->lon, n->lat, dump.address);
|
|
|
|
n->address = strdup(dump.address);
|
|
|
|
}
|
|
|
|
n->lon = dump.lon;
|
|
|
|
n->lat = dump.lat;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-12-13 01:07:00 -08:00
|
|
|
Grid *_get_current_grid(Widget_Data *wd)
|
|
|
|
{
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(wd, NULL);
|
|
|
|
Eina_List *l;
|
|
|
|
Grid *g = NULL, *ret = NULL;
|
|
|
|
EINA_LIST_FOREACH(wd->grids, l, g)
|
|
|
|
{
|
|
|
|
if (wd->zoom == g->zoom)
|
|
|
|
{
|
|
|
|
ret = g;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2011-04-07 23:14:10 -07:00
|
|
|
static Eina_Bool
|
2011-04-17 23:42:47 -07:00
|
|
|
_route_complete_cb(void *data, int ev_type __UNUSED__, void *event)
|
2011-04-07 23:14:10 -07:00
|
|
|
{
|
|
|
|
Ecore_Con_Event_Url_Complete *ev = event;
|
|
|
|
Elm_Map_Route *r = (Elm_Map_Route*)data;
|
|
|
|
Widget_Data *wd = r->wd;
|
|
|
|
|
|
|
|
if ((!r) || (!ev)) return EINA_TRUE;
|
|
|
|
Elm_Map_Route *rr = ecore_con_url_data_get(r->con_url);
|
|
|
|
ecore_con_url_data_set(r->con_url, NULL);
|
|
|
|
if (r!=rr) return EINA_TRUE;
|
|
|
|
|
|
|
|
if (r->ud.fd) fclose(r->ud.fd);
|
|
|
|
_parse_kml(r);
|
|
|
|
|
|
|
|
if (wd->grids)
|
|
|
|
{
|
2011-12-12 19:48:18 -08:00
|
|
|
Grid *g;
|
2011-04-07 23:14:10 -07:00
|
|
|
Evas_Coord ox, oy, ow, oh;
|
|
|
|
evas_object_geometry_get(wd->obj, &ox, &oy, &ow, &oh);
|
2011-12-13 01:07:00 -08:00
|
|
|
g = _get_current_grid(wd);
|
2011-12-12 19:48:18 -08:00
|
|
|
route_place(wd->obj, g, wd->pan_x, wd->pan_y, ox, oy, ow, oh);
|
2011-04-07 23:14:10 -07:00
|
|
|
}
|
|
|
|
edje_object_signal_emit(elm_smart_scroller_edje_object_get(wd->scr),
|
|
|
|
"elm,state,busy,stop", "elm");
|
|
|
|
evas_object_smart_callback_call(wd->obj, SIG_ROUTE_LOADED, NULL);
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
|
2011-04-17 23:42:47 -07:00
|
|
|
static Eina_Bool
|
|
|
|
_name_complete_cb(void *data, int ev_type __UNUSED__, void *event)
|
|
|
|
{
|
|
|
|
Ecore_Con_Event_Url_Complete *ev = event;
|
|
|
|
Elm_Map_Name *n = (Elm_Map_Name*)data;
|
|
|
|
Widget_Data *wd = n->wd;
|
|
|
|
|
|
|
|
if ((!n) || (!ev)) return EINA_TRUE;
|
|
|
|
Elm_Map_Name *nn = ecore_con_url_data_get(n->con_url);
|
|
|
|
ecore_con_url_data_set(n->con_url, NULL);
|
|
|
|
if (n!=nn) return EINA_TRUE;
|
|
|
|
|
|
|
|
if (n->ud.fd) fclose(n->ud.fd);
|
|
|
|
_parse_name(n);
|
|
|
|
|
|
|
|
edje_object_signal_emit(elm_smart_scroller_edje_object_get(wd->scr),
|
|
|
|
"elm,state,busy,stop", "elm");
|
|
|
|
evas_object_smart_callback_call(wd->obj, SIG_NAME_LOADED, NULL);
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Elm_Map_Name *
|
|
|
|
_utils_convert_name(const Evas_Object *obj, int method, char *address, double lon, double lat)
|
|
|
|
{
|
2011-04-27 22:40:48 -07:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) NULL;
|
2011-04-17 23:42:47 -07:00
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
|
|
|
char buf[PATH_MAX];
|
|
|
|
char *source;
|
|
|
|
int fd;
|
2011-04-27 22:40:48 -07:00
|
|
|
|
2011-05-11 08:23:35 -07:00
|
|
|
if ((!wd) || (!wd->src)) return NULL;
|
2011-04-17 23:42:47 -07:00
|
|
|
Elm_Map_Name *name = ELM_NEW(Elm_Map_Name);
|
|
|
|
if (!name) return NULL;
|
|
|
|
|
|
|
|
snprintf(buf, sizeof(buf), DEST_NAME_XML_FILE);
|
|
|
|
fd = mkstemp(buf);
|
|
|
|
if (fd < 0)
|
|
|
|
{
|
|
|
|
free(name);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
name->con_url = ecore_con_url_new(NULL);
|
|
|
|
name->ud.fname = strdup(buf);
|
|
|
|
INF("xml file : %s", name->ud.fname);
|
|
|
|
|
|
|
|
name->ud.fd = fdopen(fd, "w+");
|
|
|
|
if ((!name->con_url) || (!name->ud.fd))
|
|
|
|
{
|
|
|
|
ecore_con_url_free(name->con_url);
|
|
|
|
free(name);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
name->wd = wd;
|
|
|
|
name->handler = ecore_event_handler_add (ECORE_CON_EVENT_URL_COMPLETE, _name_complete_cb, name);
|
|
|
|
name->method = method;
|
|
|
|
if (method == ELM_MAP_NAME_METHOD_SEARCH) name->address = strdup(address);
|
|
|
|
else if (method == ELM_MAP_NAME_METHOD_REVERSE) name->address = NULL;
|
|
|
|
name->lon = lon;
|
|
|
|
name->lat = lat;
|
|
|
|
|
2011-05-11 08:23:35 -07:00
|
|
|
source = wd->src->name_url_cb(wd->obj, method, address, lon, lat);
|
2011-04-17 23:42:47 -07:00
|
|
|
INF("name url = %s", source);
|
|
|
|
|
|
|
|
wd->names = eina_list_append(wd->names, name);
|
|
|
|
ecore_con_url_url_set(name->con_url, source);
|
|
|
|
ecore_con_url_fd_set(name->con_url, fileno(name->ud.fd));
|
|
|
|
ecore_con_url_data_set(name->con_url, name);
|
|
|
|
|
|
|
|
edje_object_signal_emit(elm_smart_scroller_edje_object_get(wd->scr),
|
|
|
|
"elm,state,busy,start", "elm");
|
|
|
|
evas_object_smart_callback_call(wd->obj, SIG_NAME_LOAD, NULL);
|
|
|
|
ecore_con_url_get(name->con_url);
|
|
|
|
if (source) free(source);
|
|
|
|
|
|
|
|
return name;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2011-12-20 22:12:08 -08:00
|
|
|
static Evas_Event_Flags
|
|
|
|
zoom_start_cb(void *data, void *event_info __UNUSED__)
|
|
|
|
{
|
|
|
|
Widget_Data *wd = data;
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(wd, EVAS_EVENT_FLAG_NONE);
|
|
|
|
|
|
|
|
// FIXME: scroller can be jumping strangely when resizing & scrolling at the sametime (els_scr bug?)
|
|
|
|
elm_smart_scroller_hold_set(wd->scr, 1);
|
|
|
|
elm_smart_scroller_freeze_set(wd->scr, 1);
|
|
|
|
_scr_drag_start(wd->obj, NULL, NULL);
|
|
|
|
|
2011-12-29 18:57:17 -08:00
|
|
|
wd->pinch.diff += 0.001;
|
|
|
|
|
2011-12-20 22:12:08 -08:00
|
|
|
return EVAS_EVENT_FLAG_NONE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Evas_Event_Flags
|
|
|
|
zoom_end_cb(void *data, void *event_info __UNUSED__)
|
|
|
|
{
|
|
|
|
Widget_Data *wd = data;
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(wd, EVAS_EVENT_FLAG_NONE);
|
|
|
|
|
|
|
|
// FIXME: scroller can be jumping strangely when resizing & scrolling at the sametime (els_scr bug?)
|
|
|
|
elm_smart_scroller_hold_set(wd->scr, 0);
|
|
|
|
elm_smart_scroller_freeze_set(wd->scr, 0);
|
|
|
|
_scr_drag_stop(wd->obj, NULL, NULL);
|
|
|
|
|
|
|
|
wd->pinch.diff = wd->pinch.level;
|
|
|
|
|
|
|
|
return EVAS_EVENT_FLAG_NONE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Evas_Event_Flags
|
|
|
|
zoom_cb(void *data, void *event_info)
|
|
|
|
{
|
|
|
|
Widget_Data *wd = data;
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(wd, EVAS_EVENT_FLAG_NONE);
|
|
|
|
|
|
|
|
if (!wd->paused)
|
|
|
|
{
|
|
|
|
int zoom_diff = 0;
|
|
|
|
int x, y, w, h;
|
|
|
|
Elm_Gesture_Zoom_Info *ei = event_info;
|
|
|
|
evas_object_geometry_get(wd->obj, &x, &y, &w, &h);
|
|
|
|
|
|
|
|
wd->pinch.level = wd->pinch.diff * ei->zoom;
|
|
|
|
wd->pinch.cx = x + ((double)w * 0.5);
|
|
|
|
wd->pinch.cy = y + ((double)h * 0.5);
|
|
|
|
|
2011-12-29 18:57:17 -08:00
|
|
|
if (wd->pinch.level > 1.999 || wd->pinch.level < 1.001)
|
2011-12-20 22:12:08 -08:00
|
|
|
{
|
2011-12-29 18:57:17 -08:00
|
|
|
if (wd->pinch.level > 1.999)
|
2011-12-20 22:12:08 -08:00
|
|
|
{
|
|
|
|
zoom_diff = 1;
|
2011-12-29 18:57:17 -08:00
|
|
|
wd->pinch.diff = wd->pinch.level / 2.0;
|
|
|
|
wd->pinch.level = wd->pinch.level / 2.0;
|
2011-12-20 22:12:08 -08:00
|
|
|
}
|
2011-12-29 18:57:17 -08:00
|
|
|
else if (wd->pinch.level < 1.001)
|
2011-12-20 22:12:08 -08:00
|
|
|
{
|
|
|
|
zoom_diff = -1;
|
2011-12-29 18:57:17 -08:00
|
|
|
wd->pinch.diff = wd->pinch.level * 2.0;
|
|
|
|
wd->pinch.level = wd->pinch.level * 2.0;
|
2011-12-20 22:12:08 -08:00
|
|
|
}
|
|
|
|
Elm_Map_Zoom_Mode temp;
|
|
|
|
elm_gesture_layer_cb_set(wd->ges, ELM_GESTURE_ZOOM, ELM_GESTURE_STATE_MOVE, NULL, wd); // ei->zoom is refreshed
|
|
|
|
temp = wd->mode;
|
|
|
|
wd->mode = ELM_MAP_ZOOM_MODE_MANUAL;
|
|
|
|
wd->paused = EINA_TRUE;
|
|
|
|
elm_map_zoom_set(wd->obj, wd->zoom + zoom_diff);
|
|
|
|
wd->paused = EINA_FALSE;
|
|
|
|
wd->mode = temp;
|
|
|
|
elm_gesture_layer_cb_set(wd->ges, ELM_GESTURE_ZOOM, ELM_GESTURE_STATE_MOVE, zoom_cb, wd); // ei->zoom is refreshed
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (wd->calc_job) ecore_job_del(wd->calc_job);
|
|
|
|
wd->calc_job = ecore_job_add(_calc_job, wd);
|
|
|
|
}
|
|
|
|
evas_object_smart_callback_call(wd->obj, SIG_ZOOM_CHANGE, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
// FIXME: scroller can be jumping strangely when resizing & scrolling at the sametime (els_scr bug?)
|
|
|
|
_scr_scroll(wd->obj, NULL, NULL);
|
|
|
|
|
|
|
|
return EVAS_EVENT_FLAG_NONE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Evas_Event_Flags
|
|
|
|
rotate_cb(void *data, void *event_info)
|
|
|
|
{
|
|
|
|
Widget_Data *wd = data;
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(wd, EVAS_EVENT_FLAG_NONE);
|
|
|
|
|
|
|
|
if (!wd->paused)
|
|
|
|
{
|
|
|
|
int x, y, w, h;
|
|
|
|
Elm_Gesture_Rotate_Info *ei = event_info;
|
|
|
|
evas_object_geometry_get(wd->obj, &x, &y, &w, &h);
|
|
|
|
|
|
|
|
wd->rotate.d = wd->rotate.a + (ei->base_angle-ei->angle)*50;
|
|
|
|
wd->rotate.cx = x + ((double)w * 0.5);
|
|
|
|
wd->rotate.cy = y + ((double)h * 0.5);
|
|
|
|
|
|
|
|
if (wd->calc_job) ecore_job_del(wd->calc_job);
|
|
|
|
wd->calc_job = ecore_job_add(_calc_job, wd);
|
|
|
|
}
|
|
|
|
return EVAS_EVENT_FLAG_NONE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Evas_Event_Flags
|
|
|
|
rotate_end_cb(void *data, void *event_info __UNUSED__)
|
|
|
|
{
|
|
|
|
Widget_Data *wd = data;
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(wd, EVAS_EVENT_FLAG_NONE);
|
|
|
|
|
|
|
|
wd->rotate.a = wd->rotate.d;
|
|
|
|
|
|
|
|
return EVAS_EVENT_FLAG_NONE;
|
|
|
|
}
|
2010-03-09 08:27:46 -08:00
|
|
|
|
From: Bluezery <ohpowel@gmail.com>
Subject: [E-devel] [Patch][elm_map] Fix zoom & rotated coordinates bug
In my point of view, elm_map did not consider zooming & rotation by
using Evas_Map initially.
There are no problems if you use only elm_map_zoom_set(). But if you
use pinch gesture or wheel to do subtle zooming & rotating, the
calculations of coordinates are not correct currently.
I have fixed these problem and also made some utility APIs for user
convenience.
I made following 3 APIs.
1. elm_map_utils_size_get()
Currently users can only get integer zoom level by using
elm_map_zoom_get().
So if user want to calculate full map size, user should calculate
pow(2.0, zoom level) * tile size. Furthermore, user assumes tile size
as 256. (tile size can be changed!!)
Also it's not correct sometimes because Evas_map is used for subtle
zooming between zoom levels.
Above APIs return correct full map size.
2. elm_map_utils_region_get()
It can used for getting left top coordinates, center coordinates and
width, height of currently shown map area.
3. elm_map_utils_convert_canvas_into_geo()
Currently it is hard to converting x, y coordinates to geographical
longitude, latitude because of subtle zooming & rotating.
If use wants to get it, user uses combination of above functions and
more. It is harsh job.
This function is used for getting longitude, latitude from x, y
coordinates of current viewport.
SVN revision: 67286
2012-01-17 19:55:40 -08:00
|
|
|
static void
|
|
|
|
_region_get(Widget_Data *wd, Evas_Coord *x, Evas_Coord *y, Evas_Coord *cx, Evas_Coord *cy, Evas_Coord *w, Evas_Coord *h)
|
|
|
|
{
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN(wd);
|
|
|
|
Evas_Coord sx, sy, tx, ty, tcx, tcy, sw, sh, tw, th, rw, rh;
|
|
|
|
|
|
|
|
elm_smart_scroller_child_pos_get(wd->scr, &sx, &sy);
|
|
|
|
elm_smart_scroller_child_viewport_size_get(wd->scr, &sw, &sh);
|
|
|
|
rw = wd->size.w * wd->pinch.level;
|
|
|
|
rh = wd->size.h * wd->pinch.level;
|
|
|
|
|
|
|
|
if (wd->size.w < sw)
|
|
|
|
{
|
|
|
|
tw = rw;
|
|
|
|
tcx = sx + tw/2;
|
|
|
|
tx = sx + (sw - tw)/2;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
tw = sw;
|
|
|
|
tcx = (sx + tw/2) * wd->pinch.level;
|
|
|
|
tx = tcx - tw/2;
|
|
|
|
|
|
|
|
}
|
|
|
|
if (wd->size.h < sh)
|
|
|
|
{
|
|
|
|
th = rh;
|
|
|
|
ty = sy + (sh - th)/2;
|
|
|
|
tcy = sy + th/2;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
th = sw;
|
|
|
|
tcy = (sy + th/2) * wd->pinch.level;
|
|
|
|
ty = tcy - th/2;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (x) *x = tx;
|
|
|
|
if (y) *y = ty;
|
|
|
|
if (cx) *cx= tcx;
|
|
|
|
if (cy) *cy = tcy;
|
|
|
|
if (w) *w = tw;
|
|
|
|
if (h) *h = th;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_coord_rotate(const Evas_Coord x, const Evas_Coord y, const Evas_Coord cx, const Evas_Coord cy, const double degree, Evas_Coord *xx, Evas_Coord *yy)
|
|
|
|
{
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN(xx);
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN(yy);
|
|
|
|
|
|
|
|
double r = (degree * M_PI) / 180.0;
|
|
|
|
double tx, ty, ttx, tty;
|
|
|
|
|
|
|
|
tx = x - cx;
|
|
|
|
ty = y - cy;
|
|
|
|
|
|
|
|
ttx = tx * cos(r);
|
|
|
|
tty = tx * sin(r);
|
|
|
|
tx = ttx + (ty * cos(r + M_PI_2));
|
|
|
|
ty = tty + (ty * sin(r + M_PI_2));
|
|
|
|
|
|
|
|
*xx = tx + cx;
|
|
|
|
*yy = ty + cy;
|
|
|
|
}
|
|
|
|
|
2011-11-20 07:00:43 -08:00
|
|
|
#endif
|
|
|
|
|
2009-12-07 10:05:04 -08:00
|
|
|
EAPI Evas_Object *
|
2009-11-13 07:22:23 -08:00
|
|
|
elm_map_add(Evas_Object *parent)
|
|
|
|
{
|
2011-11-20 07:00:43 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_ECORE_CON
|
2009-11-13 07:22:23 -08:00
|
|
|
Evas *e;
|
|
|
|
Widget_Data *wd;
|
|
|
|
Evas_Coord minw, minh;
|
2010-03-09 08:27:46 -08:00
|
|
|
Evas_Object *obj;
|
2009-11-13 07:22:23 -08:00
|
|
|
static Evas_Smart *smart = NULL;
|
2010-10-21 12:57:43 -07:00
|
|
|
Eina_Bool bounce = _elm_config->thumbscroll_bounce_enable;
|
2009-11-15 07:53:37 -08:00
|
|
|
|
2011-03-31 23:08:02 -07:00
|
|
|
ELM_WIDGET_STANDARD_SETUP(wd, Widget_Data, parent, e, obj, NULL);
|
2011-04-01 04:26:58 -07:00
|
|
|
|
2010-03-08 22:15:39 -08:00
|
|
|
ELM_SET_WIDTYPE(widtype, "map");
|
2009-11-13 07:22:23 -08:00
|
|
|
elm_widget_type_set(obj, "map");
|
|
|
|
elm_widget_sub_object_add(parent, obj);
|
2010-09-29 05:22:30 -07:00
|
|
|
elm_widget_on_focus_hook_set(obj, _on_focus_hook, NULL);
|
2009-11-13 07:22:23 -08:00
|
|
|
elm_widget_data_set(obj, wd);
|
|
|
|
elm_widget_del_hook_set(obj, _del_hook);
|
2009-11-13 14:22:05 -08:00
|
|
|
elm_widget_del_pre_hook_set(obj, _del_pre_hook);
|
2009-11-13 07:22:23 -08:00
|
|
|
elm_widget_theme_hook_set(obj, _theme_hook);
|
2010-09-29 05:22:30 -07:00
|
|
|
elm_widget_can_focus_set(obj, EINA_TRUE);
|
2011-01-04 00:45:27 -08:00
|
|
|
elm_widget_event_hook_set(obj, _event_hook);
|
2009-11-13 07:22:23 -08:00
|
|
|
|
|
|
|
wd->scr = elm_smart_scroller_add(e);
|
2010-05-07 06:24:29 -07:00
|
|
|
elm_smart_scroller_widget_set(wd->scr, obj);
|
2010-05-11 18:03:46 -07:00
|
|
|
elm_smart_scroller_object_theme_set(obj, wd->scr, "map", "base", "default");
|
2009-11-13 07:22:23 -08:00
|
|
|
evas_object_smart_callback_add(wd->scr, "scroll", _scr, obj);
|
|
|
|
evas_object_smart_callback_add(wd->scr, "drag", _scr, obj);
|
|
|
|
elm_widget_resize_object_set(obj, wd->scr);
|
2011-04-27 19:47:12 -07:00
|
|
|
elm_smart_scroller_wheel_disabled_set(wd->scr, EINA_TRUE);
|
2009-11-13 07:22:23 -08:00
|
|
|
|
|
|
|
evas_object_smart_callback_add(wd->scr, "animate,start", _scr_anim_start, obj);
|
|
|
|
evas_object_smart_callback_add(wd->scr, "animate,stop", _scr_anim_stop, obj);
|
|
|
|
evas_object_smart_callback_add(wd->scr, "drag,start", _scr_drag_start, obj);
|
|
|
|
evas_object_smart_callback_add(wd->scr, "drag,stop", _scr_drag_stop, obj);
|
|
|
|
evas_object_smart_callback_add(wd->scr, "scroll", _scr_scroll, obj);
|
|
|
|
|
2010-10-21 12:57:43 -07:00
|
|
|
elm_smart_scroller_bounce_allow_set(wd->scr, bounce, bounce);
|
2011-11-30 19:54:52 -08:00
|
|
|
|
|
|
|
wd->zoom_min = 0xFF;
|
|
|
|
wd->zoom_max = 0X00;
|
2011-05-04 02:44:53 -07:00
|
|
|
source_init(obj);
|
2010-12-21 01:14:47 -08:00
|
|
|
|
2009-11-13 07:22:23 -08:00
|
|
|
wd->obj = obj;
|
2011-05-06 23:32:34 -07:00
|
|
|
wd->map = evas_map_new(4);
|
|
|
|
if (!wd->map) return NULL;
|
2009-11-13 07:22:23 -08:00
|
|
|
|
2009-11-18 13:07:01 -08:00
|
|
|
wd->markers_max_num = 30;
|
2011-04-21 01:55:02 -07:00
|
|
|
wd->pinch.level = 1.0;
|
2011-12-20 22:12:08 -08:00
|
|
|
wd->pinch.diff = 1.0;
|
2011-05-21 06:13:53 -07:00
|
|
|
wd->markers = calloc(wd->zoom_max + 1, sizeof(void*));
|
2009-11-18 13:07:01 -08:00
|
|
|
|
2009-11-13 07:22:23 -08:00
|
|
|
evas_object_smart_callback_add(obj, "scroll-hold-on", _hold_on, obj);
|
|
|
|
evas_object_smart_callback_add(obj, "scroll-hold-off", _hold_off, obj);
|
|
|
|
evas_object_smart_callback_add(obj, "scroll-freeze-on", _freeze_on, obj);
|
|
|
|
evas_object_smart_callback_add(obj, "scroll-freeze-off", _freeze_off, obj);
|
|
|
|
|
|
|
|
if (!smart)
|
|
|
|
{
|
2011-04-01 04:26:58 -07:00
|
|
|
static Evas_Smart_Class sc;
|
2009-11-13 07:22:23 -08:00
|
|
|
|
2011-04-01 04:26:58 -07:00
|
|
|
evas_object_smart_clipped_smart_set(&_pan_sc);
|
|
|
|
sc = _pan_sc;
|
|
|
|
sc.name = "elm_map_pan";
|
|
|
|
sc.version = EVAS_SMART_CLASS_VERSION;
|
|
|
|
sc.add = _pan_add;
|
|
|
|
sc.del = _pan_del;
|
|
|
|
sc.resize = _pan_resize;
|
|
|
|
sc.move = _pan_move;
|
|
|
|
sc.calculate = _pan_calculate;
|
|
|
|
smart = evas_smart_class_new(&sc);
|
2009-11-13 07:22:23 -08:00
|
|
|
}
|
|
|
|
if (smart)
|
|
|
|
{
|
2011-04-01 04:26:58 -07:00
|
|
|
wd->pan_smart = evas_object_smart_add(e, smart);
|
|
|
|
wd->pan = evas_object_smart_data_get(wd->pan_smart);
|
|
|
|
wd->pan->wd = wd;
|
2009-11-13 07:22:23 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
elm_smart_scroller_extern_pan_set(wd->scr, wd->pan_smart,
|
2010-11-23 12:20:41 -08:00
|
|
|
_pan_set, _pan_get, _pan_max_get,
|
|
|
|
_pan_min_get, _pan_child_size_get);
|
2009-11-13 07:22:23 -08:00
|
|
|
|
|
|
|
wd->rect = evas_object_rectangle_add(e);
|
2011-01-05 19:43:51 -08:00
|
|
|
evas_object_event_callback_add(wd->rect, EVAS_CALLBACK_RESIZE,
|
|
|
|
_rect_resize_cb, obj);
|
2009-11-13 07:22:23 -08:00
|
|
|
evas_object_event_callback_add(wd->rect, EVAS_CALLBACK_MOUSE_DOWN,
|
2011-04-01 04:26:58 -07:00
|
|
|
_mouse_down, obj);
|
2009-11-13 07:22:23 -08:00
|
|
|
evas_object_event_callback_add(wd->rect, EVAS_CALLBACK_MOUSE_UP,
|
2011-04-01 04:26:58 -07:00
|
|
|
_mouse_up, obj);
|
2011-04-27 19:47:12 -07:00
|
|
|
evas_object_event_callback_add(wd->rect, EVAS_CALLBACK_MOUSE_WHEEL,
|
|
|
|
_mouse_wheel_cb, obj);
|
2011-01-05 19:43:51 -08:00
|
|
|
|
2009-11-13 07:22:23 -08:00
|
|
|
evas_object_smart_member_add(wd->rect, wd->pan_smart);
|
|
|
|
elm_widget_sub_object_add(obj, wd->rect);
|
|
|
|
evas_object_show(wd->rect);
|
|
|
|
evas_object_color_set(wd->rect, 0, 0, 0, 0);
|
|
|
|
|
2011-12-20 22:12:08 -08:00
|
|
|
wd->ges = elm_gesture_layer_add(obj);
|
|
|
|
if (!wd->ges) ERR("elm_gesture_layer_add() failed");
|
|
|
|
elm_gesture_layer_attach(wd->ges, wd->rect);
|
|
|
|
elm_gesture_layer_cb_set(wd->ges, ELM_GESTURE_ZOOM, ELM_GESTURE_STATE_START,
|
|
|
|
zoom_start_cb, wd);
|
|
|
|
elm_gesture_layer_cb_set(wd->ges, ELM_GESTURE_ZOOM, ELM_GESTURE_STATE_MOVE,
|
|
|
|
zoom_cb, wd);
|
|
|
|
elm_gesture_layer_cb_set(wd->ges, ELM_GESTURE_ZOOM, ELM_GESTURE_STATE_END,
|
|
|
|
zoom_end_cb, wd);
|
|
|
|
elm_gesture_layer_cb_set(wd->ges, ELM_GESTURE_ZOOM, ELM_GESTURE_STATE_ABORT,
|
|
|
|
zoom_end_cb, wd);
|
|
|
|
elm_gesture_layer_cb_set(wd->ges, ELM_GESTURE_ROTATE, ELM_GESTURE_STATE_MOVE,
|
|
|
|
rotate_cb, wd);
|
|
|
|
elm_gesture_layer_cb_set(wd->ges, ELM_GESTURE_ROTATE, ELM_GESTURE_STATE_END,
|
|
|
|
rotate_end_cb, wd);
|
|
|
|
elm_gesture_layer_cb_set(wd->ges, ELM_GESTURE_ROTATE, ELM_GESTURE_STATE_ABORT,
|
|
|
|
rotate_end_cb, wd);
|
|
|
|
|
2009-11-15 15:10:31 -08:00
|
|
|
wd->mode = ELM_MAP_ZOOM_MODE_MANUAL;
|
2010-03-09 08:27:46 -08:00
|
|
|
wd->id = ((int)getpid() << 16) | idnum;
|
|
|
|
idnum++;
|
2009-11-13 07:22:23 -08:00
|
|
|
|
|
|
|
wd->tsize = 256;
|
|
|
|
edje_object_size_min_calc(elm_smart_scroller_edje_object_get(wd->scr),
|
2011-01-05 19:43:51 -08:00
|
|
|
&minw, &minh);
|
2009-11-13 07:22:23 -08:00
|
|
|
evas_object_size_hint_min_set(obj, minw, minh);
|
|
|
|
|
2010-06-30 12:26:53 -07:00
|
|
|
wd->sep_maps_markers = evas_object_rectangle_add(evas_object_evas_get(obj));
|
|
|
|
evas_object_smart_member_add(wd->sep_maps_markers, wd->pan_smart);
|
|
|
|
|
2011-12-12 19:48:18 -08:00
|
|
|
grid_create_all(obj);
|
|
|
|
|
2011-05-11 18:54:01 -07:00
|
|
|
wd->paused = EINA_TRUE;
|
|
|
|
elm_map_zoom_set(obj, 0);
|
|
|
|
wd->paused = EINA_FALSE;
|
|
|
|
_sizing_eval(obj);
|
|
|
|
|
2010-04-05 12:21:22 -07:00
|
|
|
// TODO: convert Elementary to subclassing of Evas_Smart_Class
|
|
|
|
// TODO: and save some bytes, making descriptions per-class and not instance!
|
|
|
|
evas_object_smart_callbacks_descriptions_set(obj, _signals);
|
2011-04-01 04:26:58 -07:00
|
|
|
|
2011-03-31 23:08:02 -07:00
|
|
|
if (!ecore_file_download_protocol_available("http://"))
|
|
|
|
{
|
2011-04-01 04:26:58 -07:00
|
|
|
ERR("Ecore must be built with curl support for the map widget!");
|
2011-03-31 23:08:02 -07:00
|
|
|
}
|
2011-05-06 23:32:34 -07:00
|
|
|
|
2009-11-13 07:22:23 -08:00
|
|
|
return obj;
|
2011-11-20 07:00:43 -08:00
|
|
|
#else
|
|
|
|
(void) parent;
|
|
|
|
return NULL;
|
|
|
|
#endif
|
2009-11-13 07:22:23 -08:00
|
|
|
}
|
|
|
|
|
2009-12-07 10:05:04 -08:00
|
|
|
EAPI void
|
2009-11-13 07:22:23 -08:00
|
|
|
elm_map_zoom_set(Evas_Object *obj, int zoom)
|
|
|
|
{
|
2011-11-20 07:00:43 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_ECORE_CON
|
2010-03-08 22:15:39 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
2009-11-13 07:22:23 -08:00
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
2011-05-11 08:23:35 -07:00
|
|
|
Eina_List *l;
|
2009-11-25 12:51:28 -08:00
|
|
|
Evas_Coord rx, ry, rw, rh;
|
2011-04-07 23:14:10 -07:00
|
|
|
Evas_Object *p;
|
|
|
|
Elm_Map_Route *r;
|
2011-06-26 10:36:18 -07:00
|
|
|
Evas_Object *route;
|
2011-12-20 22:12:08 -08:00
|
|
|
int z = 0;
|
|
|
|
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN(wd);
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN(wd->src);
|
|
|
|
if (wd->zoom_animator) return;
|
2011-04-01 04:26:58 -07:00
|
|
|
|
2011-12-20 22:12:08 -08:00
|
|
|
if (zoom < 0) zoom = 0;
|
2011-05-11 08:23:35 -07:00
|
|
|
if (zoom > wd->src->zoom_max) zoom = wd->src->zoom_max;
|
|
|
|
if (zoom < wd->src->zoom_min) zoom = wd->src->zoom_min;
|
2011-01-05 19:43:51 -08:00
|
|
|
|
2011-04-25 01:11:46 -07:00
|
|
|
if ((wd->zoom - zoom) > 0) wd->zoom_method = ZOOM_METHOD_OUT;
|
|
|
|
else if ((wd->zoom - zoom) < 0) wd->zoom_method = ZOOM_METHOD_IN;
|
|
|
|
else wd->zoom_method = ZOOM_METHOD_NONE;
|
2011-12-20 22:12:08 -08:00
|
|
|
|
2009-11-13 07:22:23 -08:00
|
|
|
wd->zoom = zoom;
|
|
|
|
wd->size.ow = wd->size.w;
|
|
|
|
wd->size.oh = wd->size.h;
|
|
|
|
elm_smart_scroller_child_pos_get(wd->scr, &rx, &ry);
|
|
|
|
elm_smart_scroller_child_viewport_size_get(wd->scr, &rw, &rh);
|
|
|
|
|
2011-05-11 08:23:35 -07:00
|
|
|
EINA_LIST_FOREACH(wd->route, l, r)
|
2011-04-07 23:14:10 -07:00
|
|
|
{
|
|
|
|
if (r)
|
|
|
|
{
|
|
|
|
EINA_LIST_FOREACH(r->path, l, p)
|
|
|
|
{
|
2011-04-28 09:52:52 -07:00
|
|
|
evas_object_polygon_points_clear(p);
|
2011-04-07 23:14:10 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-06-26 10:36:18 -07:00
|
|
|
EINA_LIST_FOREACH(wd->track, l, route)
|
2011-05-19 22:55:15 -07:00
|
|
|
{
|
2011-06-26 10:36:18 -07:00
|
|
|
evas_object_hide(route);
|
2011-05-19 22:55:15 -07:00
|
|
|
}
|
|
|
|
|
2011-05-06 23:32:34 -07:00
|
|
|
if (wd->mode != ELM_MAP_ZOOM_MODE_MANUAL)
|
2009-11-13 07:22:23 -08:00
|
|
|
{
|
2011-04-01 04:26:58 -07:00
|
|
|
int p2w, p2h;
|
|
|
|
int cumulw, cumulh;
|
|
|
|
|
|
|
|
cumulw = wd->tsize;
|
|
|
|
p2w = 0;
|
|
|
|
while (cumulw <= rw)
|
|
|
|
{
|
|
|
|
p2w++;
|
|
|
|
cumulw *= 2;
|
|
|
|
}
|
|
|
|
p2w--;
|
|
|
|
|
|
|
|
cumulh = wd->tsize;
|
|
|
|
p2h = 0;
|
|
|
|
while (cumulh <= rh)
|
|
|
|
{
|
|
|
|
p2h++;
|
|
|
|
cumulh *= 2;
|
|
|
|
}
|
|
|
|
p2h--;
|
|
|
|
|
2011-05-06 23:32:34 -07:00
|
|
|
if (wd->mode == ELM_MAP_ZOOM_MODE_AUTO_FIT)
|
2011-04-01 04:26:58 -07:00
|
|
|
{
|
2011-05-06 23:32:34 -07:00
|
|
|
if (p2w < p2h) z = p2w;
|
|
|
|
else z = p2h;
|
2011-04-01 04:26:58 -07:00
|
|
|
}
|
2011-05-06 23:32:34 -07:00
|
|
|
else if (wd->mode == ELM_MAP_ZOOM_MODE_AUTO_FILL)
|
2011-04-01 04:26:58 -07:00
|
|
|
{
|
2011-05-06 23:32:34 -07:00
|
|
|
if (p2w > p2h) z = p2w;
|
|
|
|
else z = p2h;
|
2011-04-01 04:26:58 -07:00
|
|
|
}
|
|
|
|
wd->zoom = z;
|
2009-11-13 07:22:23 -08:00
|
|
|
}
|
2011-12-12 19:48:18 -08:00
|
|
|
|
2011-05-05 08:15:43 -07:00
|
|
|
wd->size.nw = pow(2.0, wd->zoom) * wd->tsize;
|
|
|
|
wd->size.nh = pow(2.0, wd->zoom) * wd->tsize;
|
|
|
|
wd->t = 1.0;
|
2011-12-12 19:48:18 -08:00
|
|
|
|
2011-04-28 00:51:46 -07:00
|
|
|
if ((wd->size.w > 0) && (wd->size.h > 0))
|
|
|
|
{
|
2011-04-28 09:52:52 -07:00
|
|
|
wd->size.spos.x = (double)(rx + (rw / 2)) / (double)wd->size.ow;
|
|
|
|
wd->size.spos.y = (double)(ry + (rh / 2)) / (double)wd->size.oh;
|
2011-04-28 00:51:46 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2011-04-28 09:52:52 -07:00
|
|
|
wd->size.spos.x = 0.5;
|
|
|
|
wd->size.spos.y = 0.5;
|
2011-04-28 00:51:46 -07:00
|
|
|
}
|
2011-05-06 23:32:34 -07:00
|
|
|
|
2011-04-28 00:51:46 -07:00
|
|
|
if (rw > wd->size.ow) wd->size.spos.x = 0.5;
|
|
|
|
if (rh > wd->size.oh) wd->size.spos.y = 0.5;
|
|
|
|
if (wd->size.spos.x > 1.0) wd->size.spos.x = 1.0;
|
|
|
|
if (wd->size.spos.y > 1.0) wd->size.spos.y = 1.0;
|
|
|
|
|
2009-11-13 07:22:23 -08:00
|
|
|
if (wd->paused)
|
|
|
|
{
|
2011-04-25 01:11:46 -07:00
|
|
|
zoom_do(obj);
|
2009-11-13 07:22:23 -08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2011-04-01 04:26:58 -07:00
|
|
|
if (!wd->zoom_animator)
|
|
|
|
{
|
|
|
|
wd->zoom_animator = ecore_animator_add(_zoom_anim, obj);
|
|
|
|
wd->nosmooth++;
|
|
|
|
if (wd->nosmooth == 1) _smooth_update(obj);
|
2011-12-20 22:12:08 -08:00
|
|
|
evas_object_smart_callback_call(obj, SIG_ZOOM_START, NULL);
|
2011-04-01 04:26:58 -07:00
|
|
|
}
|
2009-11-13 07:22:23 -08:00
|
|
|
}
|
2011-05-06 23:32:34 -07:00
|
|
|
|
2011-12-20 22:12:08 -08:00
|
|
|
if (wd->zoom_method != ZOOM_METHOD_NONE) evas_object_smart_callback_call(obj, SIG_ZOOM_CHANGE, NULL);
|
2011-11-20 07:00:43 -08:00
|
|
|
#else
|
|
|
|
(void) obj;
|
|
|
|
(void) zoom;
|
|
|
|
#endif
|
2009-11-13 07:22:23 -08:00
|
|
|
}
|
|
|
|
|
2011-05-05 08:15:43 -07:00
|
|
|
EAPI int
|
2010-03-23 20:06:00 -07:00
|
|
|
elm_map_zoom_get(const Evas_Object *obj)
|
2009-11-13 07:22:23 -08:00
|
|
|
{
|
2011-11-20 07:00:43 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_ECORE_CON
|
2011-05-05 08:15:43 -07:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) 0;
|
2009-11-13 07:22:23 -08:00
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
2011-04-27 22:40:48 -07:00
|
|
|
|
2011-05-05 08:15:43 -07:00
|
|
|
if (!wd) return 0;
|
2009-11-13 07:22:23 -08:00
|
|
|
return wd->zoom;
|
2011-11-20 07:00:43 -08:00
|
|
|
#else
|
|
|
|
(void) obj;
|
|
|
|
return 0;
|
|
|
|
#endif
|
2009-11-13 07:22:23 -08:00
|
|
|
}
|
|
|
|
|
2009-12-07 10:05:04 -08:00
|
|
|
EAPI void
|
2009-11-13 07:22:23 -08:00
|
|
|
elm_map_zoom_mode_set(Evas_Object *obj, Elm_Map_Zoom_Mode mode)
|
|
|
|
{
|
2011-11-20 07:00:43 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_ECORE_CON
|
2010-03-08 22:15:39 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
2009-11-13 07:22:23 -08:00
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
2011-04-27 22:40:48 -07:00
|
|
|
|
2010-03-09 08:27:46 -08:00
|
|
|
if (!wd) return;
|
2009-11-13 07:22:23 -08:00
|
|
|
if (wd->mode == mode) return;
|
|
|
|
wd->mode = mode;
|
2011-05-06 23:32:34 -07:00
|
|
|
|
|
|
|
if (wd->mode != ELM_MAP_ZOOM_MODE_MANUAL)
|
2009-11-13 07:22:23 -08:00
|
|
|
{
|
2011-05-06 23:32:34 -07:00
|
|
|
int tz = wd->zoom;
|
|
|
|
wd->zoom = 0;
|
2011-04-01 04:26:58 -07:00
|
|
|
elm_map_zoom_set(wd->obj, tz);
|
2009-11-13 07:22:23 -08:00
|
|
|
}
|
2011-11-20 07:00:43 -08:00
|
|
|
#else
|
|
|
|
(void) obj;
|
|
|
|
(void) mode;
|
|
|
|
#endif
|
2009-11-13 07:22:23 -08:00
|
|
|
}
|
|
|
|
|
2009-12-07 10:05:04 -08:00
|
|
|
EAPI Elm_Map_Zoom_Mode
|
2010-03-23 20:06:00 -07:00
|
|
|
elm_map_zoom_mode_get(const Evas_Object *obj)
|
2009-11-13 07:22:23 -08:00
|
|
|
{
|
2011-11-20 07:00:43 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_ECORE_CON
|
2010-03-09 08:27:46 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) ELM_MAP_ZOOM_MODE_MANUAL;
|
2009-11-13 07:22:23 -08:00
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
2011-04-27 22:40:48 -07:00
|
|
|
|
2010-03-09 08:27:46 -08:00
|
|
|
if (!wd) return ELM_MAP_ZOOM_MODE_MANUAL;
|
2009-11-13 07:22:23 -08:00
|
|
|
return wd->mode;
|
2011-11-20 07:00:43 -08:00
|
|
|
#else
|
|
|
|
(void) obj;
|
|
|
|
return ELM_MAP_ZOOM_MODE_MANUAL;
|
|
|
|
#endif
|
2009-11-13 07:22:23 -08:00
|
|
|
}
|
|
|
|
|
2009-12-07 10:05:04 -08:00
|
|
|
EAPI void
|
2009-11-15 07:53:37 -08:00
|
|
|
elm_map_geo_region_bring_in(Evas_Object *obj, double lon, double lat)
|
2009-11-13 07:22:23 -08:00
|
|
|
{
|
2011-11-20 07:00:43 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_ECORE_CON
|
2010-03-08 22:15:39 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
2009-11-13 07:22:23 -08:00
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
|
|
|
int rx, ry, rw, rh;
|
|
|
|
|
2010-03-09 08:27:46 -08:00
|
|
|
if (!wd) return;
|
2010-12-21 01:14:47 -08:00
|
|
|
elm_map_utils_convert_geo_into_coord(obj, lon, lat, wd->size.w, &rx, &ry);
|
2009-11-13 07:22:23 -08:00
|
|
|
elm_smart_scroller_child_viewport_size_get(wd->scr, &rw, &rh);
|
|
|
|
|
2010-03-09 08:27:46 -08:00
|
|
|
rx = rx - rw / 2;
|
|
|
|
ry = ry - rh / 2;
|
2009-11-13 07:22:23 -08:00
|
|
|
|
|
|
|
if (wd->zoom_animator)
|
|
|
|
{
|
2011-04-01 04:26:58 -07:00
|
|
|
wd->nosmooth--;
|
|
|
|
if (!wd->nosmooth) _smooth_update(obj);
|
|
|
|
ecore_animator_del(wd->zoom_animator);
|
|
|
|
wd->zoom_animator = NULL;
|
2011-04-25 01:11:46 -07:00
|
|
|
zoom_do(obj);
|
2011-04-01 04:26:58 -07:00
|
|
|
evas_object_smart_callback_call(obj, SIG_ZOOM_STOP, NULL);
|
2009-11-13 07:22:23 -08:00
|
|
|
}
|
|
|
|
elm_smart_scroller_region_bring_in(wd->scr, rx, ry, rw, rh);
|
2009-11-15 13:36:44 -08:00
|
|
|
|
|
|
|
wd->center_on.enabled = EINA_TRUE;
|
|
|
|
wd->center_on.lon = lon;
|
|
|
|
wd->center_on.lat = lat;
|
2011-11-20 07:00:43 -08:00
|
|
|
#else
|
|
|
|
(void) obj;
|
|
|
|
(void) lon;
|
|
|
|
(void) lat;
|
|
|
|
#endif
|
2009-11-13 07:22:23 -08:00
|
|
|
}
|
|
|
|
|
2009-12-07 10:05:04 -08:00
|
|
|
EAPI void
|
2009-11-15 07:53:37 -08:00
|
|
|
elm_map_geo_region_show(Evas_Object *obj, double lon, double lat)
|
2009-11-13 07:22:23 -08:00
|
|
|
{
|
2011-11-20 07:00:43 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_ECORE_CON
|
2010-03-08 22:15:39 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
2009-11-13 07:22:23 -08:00
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
|
|
|
int rx, ry, rw, rh;
|
|
|
|
|
2010-03-09 08:27:46 -08:00
|
|
|
if (!wd) return;
|
2010-12-21 01:14:47 -08:00
|
|
|
elm_map_utils_convert_geo_into_coord(obj, lon, lat, wd->size.w, &rx, &ry);
|
2009-11-13 07:22:23 -08:00
|
|
|
elm_smart_scroller_child_viewport_size_get(wd->scr, &rw, &rh);
|
|
|
|
|
2010-03-09 08:27:46 -08:00
|
|
|
rx = rx - rw / 2;
|
|
|
|
ry = ry - rh / 2;
|
2009-11-13 07:22:23 -08:00
|
|
|
|
|
|
|
if (wd->zoom_animator)
|
|
|
|
{
|
2011-04-01 04:26:58 -07:00
|
|
|
wd->nosmooth--;
|
|
|
|
ecore_animator_del(wd->zoom_animator);
|
|
|
|
wd->zoom_animator = NULL;
|
2011-04-25 01:11:46 -07:00
|
|
|
zoom_do(obj);
|
2011-04-01 04:26:58 -07:00
|
|
|
evas_object_smart_callback_call(obj, SIG_ZOOM_STOP, NULL);
|
2009-11-13 07:22:23 -08:00
|
|
|
}
|
|
|
|
elm_smart_scroller_child_region_show(wd->scr, rx, ry, rw, rh);
|
2009-11-15 13:36:44 -08:00
|
|
|
|
|
|
|
wd->center_on.enabled = EINA_TRUE;
|
|
|
|
wd->center_on.lon = lon;
|
|
|
|
wd->center_on.lat = lat;
|
2011-11-20 07:00:43 -08:00
|
|
|
#else
|
|
|
|
(void) obj;
|
|
|
|
(void) lon;
|
|
|
|
(void) lat;
|
|
|
|
#endif
|
2009-11-13 07:22:23 -08:00
|
|
|
}
|
|
|
|
|
2009-12-07 10:05:04 -08:00
|
|
|
EAPI void
|
2010-03-23 20:06:00 -07:00
|
|
|
elm_map_geo_region_get(const Evas_Object *obj, double *lon, double *lat)
|
2009-11-13 07:22:23 -08:00
|
|
|
{
|
2011-11-20 07:00:43 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_ECORE_CON
|
2010-03-08 22:15:39 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
2009-11-13 07:22:23 -08:00
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
From: Bluezery <ohpowel@gmail.com>
Subject: [E-devel] [Patch][elm_map] Fix zoom & rotated coordinates bug
In my point of view, elm_map did not consider zooming & rotation by
using Evas_Map initially.
There are no problems if you use only elm_map_zoom_set(). But if you
use pinch gesture or wheel to do subtle zooming & rotating, the
calculations of coordinates are not correct currently.
I have fixed these problem and also made some utility APIs for user
convenience.
I made following 3 APIs.
1. elm_map_utils_size_get()
Currently users can only get integer zoom level by using
elm_map_zoom_get().
So if user want to calculate full map size, user should calculate
pow(2.0, zoom level) * tile size. Furthermore, user assumes tile size
as 256. (tile size can be changed!!)
Also it's not correct sometimes because Evas_map is used for subtle
zooming between zoom levels.
Above APIs return correct full map size.
2. elm_map_utils_region_get()
It can used for getting left top coordinates, center coordinates and
width, height of currently shown map area.
3. elm_map_utils_convert_canvas_into_geo()
Currently it is hard to converting x, y coordinates to geographical
longitude, latitude because of subtle zooming & rotating.
If use wants to get it, user uses combination of above functions and
more. It is harsh job.
This function is used for getting longitude, latitude from x, y
coordinates of current viewport.
SVN revision: 67286
2012-01-17 19:55:40 -08:00
|
|
|
Evas_Coord cx, cy;
|
|
|
|
int rw;
|
|
|
|
double tlon, tlat;
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN(wd);
|
2009-11-13 07:22:23 -08:00
|
|
|
|
From: Bluezery <ohpowel@gmail.com>
Subject: [E-devel] [Patch][elm_map] Fix zoom & rotated coordinates bug
In my point of view, elm_map did not consider zooming & rotation by
using Evas_Map initially.
There are no problems if you use only elm_map_zoom_set(). But if you
use pinch gesture or wheel to do subtle zooming & rotating, the
calculations of coordinates are not correct currently.
I have fixed these problem and also made some utility APIs for user
convenience.
I made following 3 APIs.
1. elm_map_utils_size_get()
Currently users can only get integer zoom level by using
elm_map_zoom_get().
So if user want to calculate full map size, user should calculate
pow(2.0, zoom level) * tile size. Furthermore, user assumes tile size
as 256. (tile size can be changed!!)
Also it's not correct sometimes because Evas_map is used for subtle
zooming between zoom levels.
Above APIs return correct full map size.
2. elm_map_utils_region_get()
It can used for getting left top coordinates, center coordinates and
width, height of currently shown map area.
3. elm_map_utils_convert_canvas_into_geo()
Currently it is hard to converting x, y coordinates to geographical
longitude, latitude because of subtle zooming & rotating.
If use wants to get it, user uses combination of above functions and
more. It is harsh job.
This function is used for getting longitude, latitude from x, y
coordinates of current viewport.
SVN revision: 67286
2012-01-17 19:55:40 -08:00
|
|
|
_region_get(wd, NULL, NULL, &cx, &cy, NULL, NULL);
|
|
|
|
rw = wd->size.w * wd->pinch.level;
|
|
|
|
elm_map_utils_convert_coord_into_geo(obj, cx, cy, rw, &tlon, &tlat);
|
|
|
|
if (lon) *lon = tlon;
|
|
|
|
if (lat) *lat = tlat;
|
2011-11-20 07:00:43 -08:00
|
|
|
#else
|
|
|
|
(void) obj;
|
|
|
|
(void) lon;
|
|
|
|
(void) lat;
|
|
|
|
#endif
|
2009-11-13 07:22:23 -08:00
|
|
|
}
|
|
|
|
|
2009-12-07 10:05:04 -08:00
|
|
|
EAPI void
|
2009-11-13 07:22:23 -08:00
|
|
|
elm_map_paused_set(Evas_Object *obj, Eina_Bool paused)
|
|
|
|
{
|
2011-11-20 07:00:43 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_ECORE_CON
|
2010-03-08 22:15:39 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
2009-11-13 07:22:23 -08:00
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
2011-04-27 22:40:48 -07:00
|
|
|
|
2010-03-09 08:27:46 -08:00
|
|
|
if (!wd) return;
|
2009-11-13 07:22:23 -08:00
|
|
|
if (wd->paused == !!paused) return;
|
2011-12-26 21:43:04 -08:00
|
|
|
wd->paused = !!paused;
|
2009-11-13 07:22:23 -08:00
|
|
|
if (wd->paused)
|
|
|
|
{
|
2011-04-01 04:26:58 -07:00
|
|
|
if (wd->zoom_animator)
|
|
|
|
{
|
2011-05-06 23:32:34 -07:00
|
|
|
if (wd->zoom_animator) ecore_animator_del(wd->zoom_animator);
|
2011-04-01 04:26:58 -07:00
|
|
|
wd->zoom_animator = NULL;
|
2011-04-25 01:11:46 -07:00
|
|
|
zoom_do(obj);
|
2011-04-01 04:26:58 -07:00
|
|
|
evas_object_smart_callback_call(obj, SIG_ZOOM_STOP, NULL);
|
|
|
|
}
|
2011-12-27 20:18:59 -08:00
|
|
|
edje_object_signal_emit(elm_smart_scroller_edje_object_get(wd->scr),
|
|
|
|
"elm,state,busy,stop", "elm");
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (wd->download_num >= 1)
|
|
|
|
edje_object_signal_emit(elm_smart_scroller_edje_object_get(wd->scr),
|
|
|
|
"elm,state,busy,start", "elm");
|
2009-11-13 07:22:23 -08:00
|
|
|
}
|
2011-11-20 07:00:43 -08:00
|
|
|
#else
|
|
|
|
(void) obj;
|
|
|
|
(void) paused;
|
|
|
|
#endif
|
2009-11-13 07:22:23 -08:00
|
|
|
}
|
|
|
|
|
2009-12-18 13:28:06 -08:00
|
|
|
EAPI void
|
|
|
|
elm_map_paused_markers_set(Evas_Object *obj, Eina_Bool paused)
|
|
|
|
{
|
2011-11-20 07:00:43 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_ECORE_CON
|
2010-03-08 22:15:39 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
2009-12-18 13:28:06 -08:00
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
2011-04-27 22:40:48 -07:00
|
|
|
|
2010-03-09 08:27:46 -08:00
|
|
|
if (!wd) return;
|
2009-12-18 13:28:06 -08:00
|
|
|
if (wd->paused_markers == !!paused) return;
|
|
|
|
wd->paused_markers = paused;
|
2011-11-20 07:00:43 -08:00
|
|
|
#else
|
|
|
|
(void) obj;
|
|
|
|
(void) paused;
|
|
|
|
#endif
|
2009-12-18 13:28:06 -08:00
|
|
|
}
|
|
|
|
|
2009-12-07 10:05:04 -08:00
|
|
|
EAPI Eina_Bool
|
2010-03-23 20:06:00 -07:00
|
|
|
elm_map_paused_get(const Evas_Object *obj)
|
2009-11-13 07:22:23 -08:00
|
|
|
{
|
2011-11-20 07:00:43 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_ECORE_CON
|
2010-03-09 08:27:46 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
|
2009-11-13 07:22:23 -08:00
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
2011-04-27 22:40:48 -07:00
|
|
|
|
2010-03-09 08:27:46 -08:00
|
|
|
if (!wd) return EINA_FALSE;
|
2009-11-13 07:22:23 -08:00
|
|
|
return wd->paused;
|
2011-11-20 07:00:43 -08:00
|
|
|
#else
|
|
|
|
(void) obj;
|
|
|
|
return EINA_FALSE;
|
|
|
|
#endif
|
2009-11-13 07:22:23 -08:00
|
|
|
}
|
2009-11-15 07:53:37 -08:00
|
|
|
|
2009-12-18 13:28:06 -08:00
|
|
|
EAPI Eina_Bool
|
2010-03-23 20:06:00 -07:00
|
|
|
elm_map_paused_markers_get(const Evas_Object *obj)
|
2009-12-18 13:28:06 -08:00
|
|
|
{
|
2011-11-20 07:00:43 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_ECORE_CON
|
2010-03-09 08:27:46 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
|
2009-12-18 13:28:06 -08:00
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
2011-04-27 22:40:48 -07:00
|
|
|
|
2010-03-09 08:27:46 -08:00
|
|
|
if (!wd) return EINA_FALSE;
|
2009-12-18 13:28:06 -08:00
|
|
|
return wd->paused_markers;
|
2011-11-20 07:00:43 -08:00
|
|
|
#else
|
|
|
|
(void) obj;
|
|
|
|
return EINA_FALSE;
|
|
|
|
#endif
|
2009-12-18 13:28:06 -08:00
|
|
|
}
|
2009-11-15 07:53:37 -08:00
|
|
|
|
2011-04-01 04:26:58 -07:00
|
|
|
EAPI void
|
2011-01-10 21:48:28 -08:00
|
|
|
elm_map_utils_downloading_status_get(const Evas_Object *obj, int *try_num, int *finish_num)
|
|
|
|
{
|
2011-11-20 07:00:43 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_ECORE_CON
|
2011-01-11 01:47:56 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
2011-01-10 21:48:28 -08:00
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
|
|
|
|
2011-04-27 22:40:48 -07:00
|
|
|
if (!wd) return;
|
2011-01-10 21:48:28 -08:00
|
|
|
if (try_num)
|
|
|
|
{
|
|
|
|
*try_num = wd->try_num;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (finish_num)
|
|
|
|
{
|
|
|
|
*finish_num = wd->finish_num;
|
|
|
|
}
|
2011-11-20 07:00:43 -08:00
|
|
|
#else
|
|
|
|
(void) obj;
|
|
|
|
(void) try_num;
|
|
|
|
(void) finish_num;
|
|
|
|
#endif
|
2011-01-10 21:48:28 -08:00
|
|
|
}
|
2011-08-03 14:05:20 -07:00
|
|
|
|
2009-12-07 10:05:04 -08:00
|
|
|
EAPI void
|
2010-12-21 01:14:47 -08:00
|
|
|
elm_map_utils_convert_coord_into_geo(const Evas_Object *obj, int x, int y, int size, double *lon, double *lat)
|
2009-11-15 07:53:37 -08:00
|
|
|
{
|
2011-11-20 07:00:43 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_ECORE_CON
|
2011-04-27 22:40:48 -07:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
2010-12-21 01:14:47 -08:00
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
2011-04-27 22:40:48 -07:00
|
|
|
|
2011-04-27 21:16:00 -07:00
|
|
|
if (!wd) return;
|
2011-05-11 08:23:35 -07:00
|
|
|
int zoom = floor(log(size / 256) / log(2));
|
|
|
|
if ((wd->src) && (wd->src->coord_into_geo))
|
2011-05-04 02:44:53 -07:00
|
|
|
{
|
2011-05-11 08:23:35 -07:00
|
|
|
if (wd->src->coord_into_geo(obj, zoom, x, y, size, lon, lat)) return;
|
2011-05-04 02:44:53 -07:00
|
|
|
}
|
2010-12-21 01:14:47 -08:00
|
|
|
|
2009-11-15 07:53:37 -08:00
|
|
|
if (lon)
|
|
|
|
{
|
2011-04-01 04:26:58 -07:00
|
|
|
*lon = x / (double)size * 360.0 - 180;
|
2009-11-15 07:53:37 -08:00
|
|
|
}
|
|
|
|
if (lat)
|
|
|
|
{
|
2011-04-01 04:26:58 -07:00
|
|
|
double n = ELM_PI - 2.0 * ELM_PI * y / size;
|
|
|
|
*lat = 180.0 / ELM_PI * atan(0.5 * (exp(n) - exp(-n)));
|
2009-11-15 07:53:37 -08:00
|
|
|
}
|
2011-11-20 07:00:43 -08:00
|
|
|
#else
|
|
|
|
(void) obj;
|
|
|
|
(void) x;
|
|
|
|
(void) y;
|
|
|
|
(void) size;
|
|
|
|
(void) lon;
|
|
|
|
(void) lat;
|
|
|
|
#endif
|
2009-11-15 07:53:37 -08:00
|
|
|
}
|
|
|
|
|
2009-12-07 10:05:04 -08:00
|
|
|
EAPI void
|
2010-12-21 01:14:47 -08:00
|
|
|
elm_map_utils_convert_geo_into_coord(const Evas_Object *obj, double lon, double lat, int size, int *x, int *y)
|
2009-11-15 07:53:37 -08:00
|
|
|
{
|
2011-11-20 07:00:43 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_ECORE_CON
|
2011-04-27 22:40:48 -07:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
2010-12-21 01:14:47 -08:00
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
2011-04-27 22:40:48 -07:00
|
|
|
|
2011-04-27 21:16:00 -07:00
|
|
|
if (!wd) return;
|
2011-05-11 08:23:35 -07:00
|
|
|
int zoom = floor(log(size / 256) / log(2));
|
|
|
|
if ((wd->src) && (wd->src->geo_into_coord))
|
2011-05-04 02:44:53 -07:00
|
|
|
{
|
2011-05-11 08:23:35 -07:00
|
|
|
if (wd->src->geo_into_coord(obj, zoom, lon, lat, size, x, y)) return;
|
2011-05-04 02:44:53 -07:00
|
|
|
}
|
2010-12-21 01:14:47 -08:00
|
|
|
|
2010-03-09 08:27:46 -08:00
|
|
|
if (x)
|
2009-11-15 07:53:37 -08:00
|
|
|
*x = floor((lon + 180.0) / 360.0 * size);
|
2010-03-09 08:27:46 -08:00
|
|
|
if (y)
|
2011-05-11 08:23:35 -07:00
|
|
|
*y = floor((1.0 - log( tan(lat * ELM_PI / 180.0) + 1.0 / cos(lat * ELM_PI / 180.0)) / ELM_PI) / 2.0 * size);
|
2011-11-20 07:00:43 -08:00
|
|
|
#else
|
|
|
|
(void) obj;
|
|
|
|
(void) lon;
|
|
|
|
(void) lat;
|
|
|
|
(void) size;
|
|
|
|
(void) x;
|
|
|
|
(void) y;
|
|
|
|
#endif
|
2009-11-15 07:53:37 -08:00
|
|
|
}
|
|
|
|
|
2011-04-17 23:42:47 -07:00
|
|
|
EAPI Elm_Map_Name *
|
|
|
|
elm_map_utils_convert_coord_into_name(const Evas_Object *obj, double lon, double lat)
|
|
|
|
{
|
2011-11-20 07:00:43 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_ECORE_CON
|
2011-04-17 23:42:47 -07:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) NULL;
|
|
|
|
return _utils_convert_name(obj, ELM_MAP_NAME_METHOD_REVERSE, NULL, lon, lat);
|
2011-11-20 07:00:43 -08:00
|
|
|
#else
|
|
|
|
(void) obj;
|
|
|
|
(void) lon;
|
|
|
|
(void) lat;
|
|
|
|
return NULL;
|
|
|
|
#endif
|
2011-04-17 23:42:47 -07:00
|
|
|
}
|
2009-11-15 07:53:37 -08:00
|
|
|
|
2011-04-17 23:42:47 -07:00
|
|
|
EAPI Elm_Map_Name *
|
|
|
|
elm_map_utils_convert_name_into_coord(const Evas_Object *obj, char *address)
|
|
|
|
{
|
2011-11-20 07:00:43 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_ECORE_CON
|
2011-04-17 23:42:47 -07:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) NULL;
|
|
|
|
if (!address) return NULL;
|
|
|
|
return _utils_convert_name(obj, ELM_MAP_NAME_METHOD_SEARCH, address, 0.0, 0.0);
|
2011-11-20 07:00:43 -08:00
|
|
|
#else
|
|
|
|
(void) obj;
|
|
|
|
(void) address;
|
|
|
|
return NULL;
|
|
|
|
#endif
|
2011-04-17 23:42:47 -07:00
|
|
|
}
|
2009-11-15 07:53:37 -08:00
|
|
|
|
From: Bluezery <ohpowel@gmail.com>
Subject: [E-devel] [Patch][elm_map] Fix zoom & rotated coordinates bug
In my point of view, elm_map did not consider zooming & rotation by
using Evas_Map initially.
There are no problems if you use only elm_map_zoom_set(). But if you
use pinch gesture or wheel to do subtle zooming & rotating, the
calculations of coordinates are not correct currently.
I have fixed these problem and also made some utility APIs for user
convenience.
I made following 3 APIs.
1. elm_map_utils_size_get()
Currently users can only get integer zoom level by using
elm_map_zoom_get().
So if user want to calculate full map size, user should calculate
pow(2.0, zoom level) * tile size. Furthermore, user assumes tile size
as 256. (tile size can be changed!!)
Also it's not correct sometimes because Evas_map is used for subtle
zooming between zoom levels.
Above APIs return correct full map size.
2. elm_map_utils_region_get()
It can used for getting left top coordinates, center coordinates and
width, height of currently shown map area.
3. elm_map_utils_convert_canvas_into_geo()
Currently it is hard to converting x, y coordinates to geographical
longitude, latitude because of subtle zooming & rotating.
If use wants to get it, user uses combination of above functions and
more. It is harsh job.
This function is used for getting longitude, latitude from x, y
coordinates of current viewport.
SVN revision: 67286
2012-01-17 19:55:40 -08:00
|
|
|
EINA_DEPRECATED EAPI void
|
|
|
|
elm_map_utils_rotate_coord(const Evas_Object *obj, const Evas_Coord x, const Evas_Coord y, const Evas_Coord cx, const Evas_Coord cy, const double degree, Evas_Coord *xx, Evas_Coord *yy)
|
2011-04-21 01:55:02 -07:00
|
|
|
{
|
2011-11-20 07:00:43 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_ECORE_CON
|
From: Bluezery <ohpowel@gmail.com>
Subject: [E-devel] [Patch][elm_map] Fix zoom & rotated coordinates bug
In my point of view, elm_map did not consider zooming & rotation by
using Evas_Map initially.
There are no problems if you use only elm_map_zoom_set(). But if you
use pinch gesture or wheel to do subtle zooming & rotating, the
calculations of coordinates are not correct currently.
I have fixed these problem and also made some utility APIs for user
convenience.
I made following 3 APIs.
1. elm_map_utils_size_get()
Currently users can only get integer zoom level by using
elm_map_zoom_get().
So if user want to calculate full map size, user should calculate
pow(2.0, zoom level) * tile size. Furthermore, user assumes tile size
as 256. (tile size can be changed!!)
Also it's not correct sometimes because Evas_map is used for subtle
zooming between zoom levels.
Above APIs return correct full map size.
2. elm_map_utils_region_get()
It can used for getting left top coordinates, center coordinates and
width, height of currently shown map area.
3. elm_map_utils_convert_canvas_into_geo()
Currently it is hard to converting x, y coordinates to geographical
longitude, latitude because of subtle zooming & rotating.
If use wants to get it, user uses combination of above functions and
more. It is harsh job.
This function is used for getting longitude, latitude from x, y
coordinates of current viewport.
SVN revision: 67286
2012-01-17 19:55:40 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
|
|
|
_coord_rotate(x, y, cx, cy, degree, xx, yy);
|
2011-11-20 07:00:43 -08:00
|
|
|
#else
|
|
|
|
(void) x;
|
|
|
|
(void) y;
|
|
|
|
(void) cx;
|
|
|
|
(void) cy;
|
|
|
|
(void) degree;
|
|
|
|
(void) xx;
|
|
|
|
(void) yy;
|
|
|
|
#endif
|
2011-04-21 01:55:02 -07:00
|
|
|
}
|
|
|
|
|
From: Bluezery <ohpowel@gmail.com>
Subject: [E-devel] [Patch][elm_map] Fix zoom & rotated coordinates bug
In my point of view, elm_map did not consider zooming & rotation by
using Evas_Map initially.
There are no problems if you use only elm_map_zoom_set(). But if you
use pinch gesture or wheel to do subtle zooming & rotating, the
calculations of coordinates are not correct currently.
I have fixed these problem and also made some utility APIs for user
convenience.
I made following 3 APIs.
1. elm_map_utils_size_get()
Currently users can only get integer zoom level by using
elm_map_zoom_get().
So if user want to calculate full map size, user should calculate
pow(2.0, zoom level) * tile size. Furthermore, user assumes tile size
as 256. (tile size can be changed!!)
Also it's not correct sometimes because Evas_map is used for subtle
zooming between zoom levels.
Above APIs return correct full map size.
2. elm_map_utils_region_get()
It can used for getting left top coordinates, center coordinates and
width, height of currently shown map area.
3. elm_map_utils_convert_canvas_into_geo()
Currently it is hard to converting x, y coordinates to geographical
longitude, latitude because of subtle zooming & rotating.
If use wants to get it, user uses combination of above functions and
more. It is harsh job.
This function is used for getting longitude, latitude from x, y
coordinates of current viewport.
SVN revision: 67286
2012-01-17 19:55:40 -08:00
|
|
|
EAPI void
|
|
|
|
elm_map_canvas_to_geo_convert(const Evas_Object *obj, const Evas_Coord x, const Evas_Coord y, double *lon, double *lat)
|
|
|
|
{
|
|
|
|
#ifdef HAVE_ELEMENTARY_ECORE_CON
|
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN(lon);
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN(lat);
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN(wd);
|
|
|
|
|
|
|
|
Evas_Coord xx, yy, w, h, mw, tx, ty, cx, cy;
|
|
|
|
double d;
|
|
|
|
|
|
|
|
_region_get(wd, &xx, &yy, &cx, &cy, &w, &h);
|
|
|
|
mw = wd->size.w * wd->pinch.level;
|
|
|
|
if (w < mw)
|
|
|
|
{
|
|
|
|
xx += x;
|
|
|
|
yy += y;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
xx = x - xx;
|
|
|
|
yy = y - yy;
|
|
|
|
}
|
|
|
|
|
|
|
|
elm_map_rotate_get(obj, &d, NULL, NULL);
|
|
|
|
_coord_rotate(xx, yy, cx, cy, -d, &tx, &ty);
|
|
|
|
elm_map_utils_convert_coord_into_geo(obj, tx, ty, mw, lon, lat);
|
|
|
|
#else
|
|
|
|
(void) obj;
|
|
|
|
(void) x;
|
|
|
|
(void) y;
|
|
|
|
(void) lon;
|
|
|
|
(void) lat;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2009-12-07 10:05:04 -08:00
|
|
|
EAPI Elm_Map_Marker *
|
2009-12-20 08:34:45 -08:00
|
|
|
elm_map_marker_add(Evas_Object *obj, double lon, double lat, Elm_Map_Marker_Class *clas, Elm_Map_Group_Class *clas_group, void *data)
|
2009-11-15 07:53:37 -08:00
|
|
|
{
|
2011-11-20 07:00:43 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_ECORE_CON
|
2011-04-27 22:40:48 -07:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) NULL;
|
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
2009-12-18 06:28:36 -08:00
|
|
|
int i, j;
|
2009-11-17 07:44:11 -08:00
|
|
|
Eina_List *l;
|
2009-11-15 07:53:37 -08:00
|
|
|
Marker_Group *group;
|
2009-12-18 06:28:36 -08:00
|
|
|
int mpi, mpj;
|
|
|
|
int tabi[9];
|
|
|
|
int tabj[9];
|
2009-12-20 08:34:45 -08:00
|
|
|
const char *s;
|
|
|
|
const char *style;
|
|
|
|
Evas_Object *o;
|
|
|
|
|
2010-03-09 08:27:46 -08:00
|
|
|
if (!wd) return NULL;
|
2010-12-03 06:08:33 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(clas_group, NULL);
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(clas, NULL);
|
2009-11-15 07:53:37 -08:00
|
|
|
|
2009-12-07 10:05:04 -08:00
|
|
|
Elm_Map_Marker *marker = ELM_NEW(Elm_Map_Marker);
|
2009-11-15 07:53:37 -08:00
|
|
|
|
|
|
|
marker->wd = wd;
|
2009-11-18 02:59:17 -08:00
|
|
|
marker->clas = clas;
|
2009-12-20 08:34:45 -08:00
|
|
|
marker->clas_group = clas_group;
|
2009-11-15 07:53:37 -08:00
|
|
|
marker->longitude = lon;
|
|
|
|
marker->latitude = lat;
|
|
|
|
marker->data = data;
|
2011-05-21 06:13:53 -07:00
|
|
|
marker->x = calloc(wd->zoom_max + 1, sizeof(Evas_Coord));
|
|
|
|
marker->y = calloc(wd->zoom_max + 1, sizeof(Evas_Coord));
|
|
|
|
marker->groups = calloc(wd->zoom_max + 1, sizeof(Marker_Group*));
|
2009-11-15 07:53:37 -08:00
|
|
|
|
2009-12-18 09:00:01 -08:00
|
|
|
tabi[1] = tabi[4] = tabi[6] = -1;
|
|
|
|
tabi[2] = tabi[0] = tabi[7] = 0;
|
|
|
|
tabi[3] = tabi[5] = tabi[8] = 1;
|
2009-12-18 09:45:47 -08:00
|
|
|
|
2009-12-18 09:00:01 -08:00
|
|
|
tabj[1] = tabj[2] = tabj[3] = -1;
|
|
|
|
tabj[4] = tabj[0] = tabj[5] = 0;
|
2009-12-18 06:28:36 -08:00
|
|
|
tabj[6] = tabj[7] = tabj[8] = 1;
|
|
|
|
|
2010-03-09 08:27:46 -08:00
|
|
|
if (!clas_group->priv.set)
|
2009-11-15 07:53:37 -08:00
|
|
|
{
|
2011-04-01 04:26:58 -07:00
|
|
|
style = "radio";
|
|
|
|
if (marker->clas_group && marker->clas_group->style)
|
|
|
|
style = marker->clas_group->style;
|
|
|
|
|
|
|
|
o = edje_object_add(evas_object_evas_get(obj));
|
|
|
|
_elm_theme_object_set(obj, o, "map/marker", style, elm_widget_style_get(obj));
|
|
|
|
s = edje_object_data_get(o, "size_w");
|
|
|
|
if (s) clas_group->priv.edje_w = atoi(s);
|
|
|
|
else clas_group->priv.edje_w = 0;
|
|
|
|
s = edje_object_data_get(o, "size_h");
|
|
|
|
if (s) clas_group->priv.edje_h = atoi(s);
|
|
|
|
else clas_group->priv.edje_h = 0;
|
|
|
|
s = edje_object_data_get(o, "size_max_w");
|
|
|
|
if (s) clas_group->priv.edje_max_w = atoi(s);
|
|
|
|
else clas_group->priv.edje_max_w = 0;
|
|
|
|
s = edje_object_data_get(o, "size_max_h");
|
|
|
|
if (s) clas_group->priv.edje_max_h = atoi(s);
|
|
|
|
else clas_group->priv.edje_max_h = 0;
|
|
|
|
evas_object_del(o);
|
|
|
|
|
|
|
|
clas_group->priv.set = EINA_TRUE;
|
2009-12-20 08:34:45 -08:00
|
|
|
}
|
2009-11-15 07:53:37 -08:00
|
|
|
|
2010-03-09 08:27:46 -08:00
|
|
|
if (!clas->priv.set)
|
2009-12-20 08:34:45 -08:00
|
|
|
{
|
2011-04-01 04:26:58 -07:00
|
|
|
style = "radio";
|
|
|
|
if (marker->clas && marker->clas->style)
|
|
|
|
style = marker->clas->style;
|
2009-12-20 08:34:45 -08:00
|
|
|
|
2011-04-01 04:26:58 -07:00
|
|
|
o = edje_object_add(evas_object_evas_get(obj));
|
|
|
|
_elm_theme_object_set(obj, o, "map/marker", style, elm_widget_style_get(obj));
|
|
|
|
s = edje_object_data_get(o, "size_w");
|
|
|
|
if (s) clas->priv.edje_w = atoi(s);
|
|
|
|
else clas->priv.edje_w = 0;
|
|
|
|
s = edje_object_data_get(o, "size_h");
|
|
|
|
if (s) clas->priv.edje_h = atoi(s);
|
|
|
|
else clas->priv.edje_h = 0;
|
|
|
|
evas_object_del(o);
|
|
|
|
|
|
|
|
clas->priv.set = EINA_TRUE;
|
2009-12-20 08:34:45 -08:00
|
|
|
}
|
|
|
|
|
2011-05-21 06:13:53 -07:00
|
|
|
for (i = clas_group->zoom_displayed; i <= wd->zoom_max; i++)
|
2009-12-20 08:34:45 -08:00
|
|
|
{
|
2011-04-01 04:26:58 -07:00
|
|
|
elm_map_utils_convert_geo_into_coord(obj, lon, lat, pow(2.0, i)*wd->tsize,
|
2010-03-09 08:27:46 -08:00
|
|
|
&(marker->x[i]), &(marker->y[i]));
|
2011-04-01 04:26:58 -07:00
|
|
|
|
|
|
|
//search in the matrixsparse the region where the marker will be
|
|
|
|
mpi = marker->x[i] / wd->tsize;
|
|
|
|
mpj = marker->y[i] / wd->tsize;
|
|
|
|
|
|
|
|
if (!wd->markers[i])
|
|
|
|
{
|
|
|
|
int size = pow(2.0, i);
|
|
|
|
wd->markers[i] = eina_matrixsparse_new(size, size, NULL, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
group = NULL;
|
|
|
|
if (i <= clas_group->zoom_grouped)
|
|
|
|
{
|
|
|
|
for (j = 0, group = NULL; j < 9 && !group; j++)
|
|
|
|
{
|
|
|
|
EINA_LIST_FOREACH(eina_matrixsparse_data_idx_get(wd->markers[i], mpj + tabj[j], mpi + tabi[j]),
|
2010-03-09 08:27:46 -08:00
|
|
|
l, group)
|
2011-04-01 04:26:58 -07:00
|
|
|
{
|
|
|
|
if (group->clas == marker->clas_group
|
2010-03-09 08:27:46 -08:00
|
|
|
&& ELM_RECTS_INTERSECT(marker->x[i]-clas->priv.edje_w/4,
|
|
|
|
marker->y[i]-clas->priv.edje_h/4, clas->priv.edje_w, clas->priv.edje_h,
|
|
|
|
group->x-group->w/4, group->y-group->h/4, group->w, group->h))
|
2011-04-01 04:26:58 -07:00
|
|
|
{
|
|
|
|
group->markers = eina_list_append(group->markers, marker);
|
|
|
|
group->update_nbelems = EINA_TRUE;
|
|
|
|
group->update_resize = EINA_TRUE;
|
|
|
|
|
|
|
|
group->sum_x += marker->x[i];
|
|
|
|
group->sum_y += marker->y[i];
|
|
|
|
group->x = group->sum_x / eina_list_count(group->markers);
|
|
|
|
group->y = group->sum_y / eina_list_count(group->markers);
|
|
|
|
|
|
|
|
group->w = group->clas->priv.edje_w + group->clas->priv.edje_w/8.
|
|
|
|
* eina_list_count(group->markers);
|
|
|
|
group->h = group->clas->priv.edje_h + group->clas->priv.edje_h/8.
|
|
|
|
* eina_list_count(group->markers);
|
|
|
|
if (group->w > group->clas->priv.edje_max_w) group->w = group->clas->priv.edje_max_w;
|
|
|
|
if (group->h > group->clas->priv.edje_max_h) group->h = group->clas->priv.edje_max_h;
|
|
|
|
|
|
|
|
if (group->obj && eina_list_count(group->markers) == 2)
|
|
|
|
{
|
|
|
|
_group_object_free(group);
|
|
|
|
_group_object_create(group);
|
|
|
|
}
|
|
|
|
if (group->bubble)
|
|
|
|
_group_bubble_content_update(group);
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!group)
|
|
|
|
{
|
|
|
|
group = calloc(1, sizeof(Marker_Group));
|
|
|
|
group->wd = wd;
|
|
|
|
group->sum_x = marker->x[i];
|
|
|
|
group->sum_y = marker->y[i];
|
|
|
|
group->x = marker->x[i];
|
|
|
|
group->y = marker->y[i];
|
|
|
|
group->w = clas_group->priv.edje_w;
|
|
|
|
group->h = clas_group->priv.edje_h;
|
|
|
|
group->clas = clas_group;
|
|
|
|
|
|
|
|
group->markers = eina_list_append(group->markers, marker);
|
|
|
|
group->update_nbelems = EINA_TRUE;
|
|
|
|
group->update_resize = EINA_TRUE;
|
|
|
|
|
|
|
|
eina_matrixsparse_cell_idx_get(wd->markers[i], mpj, mpi, &(group->cell));
|
|
|
|
|
|
|
|
if (!group->cell)
|
|
|
|
{
|
|
|
|
l = eina_list_append(NULL, group);
|
|
|
|
eina_matrixsparse_data_idx_set(wd->markers[i], mpj, mpi, l);
|
|
|
|
eina_matrixsparse_cell_idx_get(wd->markers[i], mpj, mpi, &(group->cell));
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
l = eina_matrixsparse_cell_data_get(group->cell);
|
|
|
|
l = eina_list_append(l, group);
|
|
|
|
eina_matrixsparse_cell_data_set(group->cell, l);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
marker->groups[i] = group;
|
2009-11-15 07:53:37 -08:00
|
|
|
}
|
|
|
|
|
2010-03-09 08:27:46 -08:00
|
|
|
if (wd->grids)
|
2009-11-15 07:53:37 -08:00
|
|
|
{
|
2011-12-12 19:48:18 -08:00
|
|
|
Grid *g;
|
2011-04-01 04:26:58 -07:00
|
|
|
Evas_Coord ox, oy, ow, oh;
|
|
|
|
evas_object_geometry_get(obj, &ox, &oy, &ow, &oh);
|
2011-12-13 01:07:00 -08:00
|
|
|
g = _get_current_grid(wd);
|
2011-12-12 19:48:18 -08:00
|
|
|
marker_place(obj, g, wd->pan_x, wd->pan_y, ox, oy, ow, oh);
|
2009-11-15 07:53:37 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
return marker;
|
2011-11-20 07:00:43 -08:00
|
|
|
#else
|
|
|
|
(void) obj;
|
|
|
|
(void) lon;
|
|
|
|
(void) lat;
|
|
|
|
(void) clas;
|
|
|
|
(void) clas_group;
|
|
|
|
(void) data;
|
|
|
|
return NULL;
|
|
|
|
#endif
|
2009-11-15 07:53:37 -08:00
|
|
|
}
|
|
|
|
|
2009-12-07 10:05:04 -08:00
|
|
|
EAPI void
|
2009-11-18 13:07:01 -08:00
|
|
|
elm_map_marker_remove(Elm_Map_Marker *marker)
|
|
|
|
{
|
2011-11-20 07:00:43 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_ECORE_CON
|
2009-11-18 13:07:01 -08:00
|
|
|
int i;
|
2009-12-18 06:28:36 -08:00
|
|
|
Eina_List *groups;
|
2010-07-21 16:33:35 -07:00
|
|
|
Widget_Data *wd;
|
2009-11-18 13:07:01 -08:00
|
|
|
|
2010-12-03 06:08:33 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN(marker);
|
2010-07-21 16:33:35 -07:00
|
|
|
wd = marker->wd;
|
|
|
|
if (!wd) return;
|
2011-05-21 06:13:53 -07:00
|
|
|
for (i = marker->clas_group->zoom_displayed; i <= wd->zoom_max; i++)
|
2009-11-25 05:21:02 -08:00
|
|
|
{
|
2011-02-09 08:44:47 -08:00
|
|
|
marker->groups[i]->markers = eina_list_remove(marker->groups[i]->markers, marker);
|
|
|
|
if (!eina_list_count(marker->groups[i]->markers))
|
|
|
|
{
|
2010-03-09 08:27:46 -08:00
|
|
|
groups = eina_matrixsparse_cell_data_get(marker->groups[i]->cell);
|
|
|
|
groups = eina_list_remove(groups, marker->groups[i]);
|
|
|
|
eina_matrixsparse_cell_data_set(marker->groups[i]->cell, groups);
|
2011-02-09 08:44:47 -08:00
|
|
|
|
2010-03-09 08:27:46 -08:00
|
|
|
_group_object_free(marker->groups[i]);
|
|
|
|
_group_bubble_free(marker->groups[i]);
|
|
|
|
free(marker->groups[i]);
|
2011-02-09 08:44:47 -08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
marker->groups[i]->sum_x -= marker->x[i];
|
|
|
|
marker->groups[i]->sum_y -= marker->y[i];
|
|
|
|
|
|
|
|
marker->groups[i]->x = marker->groups[i]->sum_x / eina_list_count(marker->groups[i]->markers);
|
|
|
|
marker->groups[i]->y = marker->groups[i]->sum_y / eina_list_count(marker->groups[i]->markers);
|
|
|
|
|
|
|
|
marker->groups[i]->w = marker->groups[i]->clas->priv.edje_w
|
|
|
|
+ marker->groups[i]->clas->priv.edje_w/8. * eina_list_count(marker->groups[i]->markers);
|
|
|
|
marker->groups[i]->h = marker->groups[i]->clas->priv.edje_h
|
|
|
|
+ marker->groups[i]->clas->priv.edje_h/8. * eina_list_count(marker->groups[i]->markers);
|
|
|
|
if (marker->groups[i]->w > marker->groups[i]->clas->priv.edje_max_w)
|
|
|
|
marker->groups[i]->w = marker->groups[i]->clas->priv.edje_max_w;
|
|
|
|
if (marker->groups[i]->h > marker->groups[i]->clas->priv.edje_max_h)
|
|
|
|
marker->groups[i]->h = marker->groups[i]->clas->priv.edje_max_h;
|
|
|
|
|
|
|
|
if ((marker->groups[i]->obj) && (eina_list_count(marker->groups[i]->markers) == 1))
|
|
|
|
{
|
|
|
|
_group_object_free(marker->groups[i]);
|
|
|
|
_group_object_create(marker->groups[i]);
|
|
|
|
}
|
|
|
|
}
|
2009-11-25 05:21:02 -08:00
|
|
|
}
|
2009-11-18 13:07:01 -08:00
|
|
|
|
2010-10-22 14:41:22 -07:00
|
|
|
if ((marker->content) && (marker->clas->func.del))
|
2009-11-18 13:07:01 -08:00
|
|
|
marker->clas->func.del(marker->wd->obj, marker, marker->data, marker->content);
|
2010-03-09 08:27:46 -08:00
|
|
|
else if (marker->content)
|
2009-11-18 13:07:01 -08:00
|
|
|
evas_object_del(marker->content);
|
2011-04-01 04:26:58 -07:00
|
|
|
|
2011-05-21 06:13:53 -07:00
|
|
|
if (marker->x) free(marker->x);
|
|
|
|
if (marker->y) free(marker->y);
|
|
|
|
if (marker->groups) free(marker->groups);
|
|
|
|
|
2009-11-18 13:07:01 -08:00
|
|
|
free(marker);
|
2011-04-01 04:26:58 -07:00
|
|
|
|
2010-03-09 08:27:46 -08:00
|
|
|
if (wd->grids)
|
2009-11-18 13:07:01 -08:00
|
|
|
{
|
2011-12-12 19:48:18 -08:00
|
|
|
Grid *g;
|
2011-04-01 04:26:58 -07:00
|
|
|
Evas_Coord ox, oy, ow, oh;
|
|
|
|
evas_object_geometry_get(wd->obj, &ox, &oy, &ow, &oh);
|
2011-12-13 01:07:00 -08:00
|
|
|
g = _get_current_grid(wd);
|
2011-12-12 19:48:18 -08:00
|
|
|
marker_place(wd->obj, g, wd->pan_x, wd->pan_y, ox, oy, ow, oh);
|
2009-11-18 13:07:01 -08:00
|
|
|
}
|
2011-11-20 07:00:43 -08:00
|
|
|
#else
|
|
|
|
(void) marker;
|
|
|
|
#endif
|
2009-11-18 13:07:01 -08:00
|
|
|
}
|
|
|
|
|
2011-03-10 02:19:32 -08:00
|
|
|
EAPI void
|
|
|
|
elm_map_marker_region_get(const Elm_Map_Marker *marker, double *lon, double *lat)
|
|
|
|
{
|
2011-11-20 07:00:43 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_ECORE_CON
|
2011-03-10 02:19:32 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN(marker);
|
|
|
|
if (lon) *lon = marker->longitude;
|
|
|
|
if (lat) *lat = marker->latitude;
|
2011-11-20 07:00:43 -08:00
|
|
|
#else
|
|
|
|
(void) marker;
|
|
|
|
(void) lon;
|
|
|
|
(void) lat;
|
|
|
|
#endif
|
2011-03-10 02:19:32 -08:00
|
|
|
}
|
|
|
|
|
2009-12-07 10:05:04 -08:00
|
|
|
EAPI void
|
2009-11-18 13:07:01 -08:00
|
|
|
elm_map_marker_bring_in(Elm_Map_Marker *marker)
|
|
|
|
{
|
2011-11-20 07:00:43 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_ECORE_CON
|
2010-12-03 06:08:33 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN(marker);
|
2009-11-18 13:07:01 -08:00
|
|
|
elm_map_geo_region_bring_in(marker->wd->obj, marker->longitude, marker->latitude);
|
2011-11-20 07:00:43 -08:00
|
|
|
#else
|
|
|
|
(void) marker;
|
|
|
|
#endif
|
2009-11-18 13:07:01 -08:00
|
|
|
}
|
|
|
|
|
2009-12-07 10:05:04 -08:00
|
|
|
EAPI void
|
2009-11-18 13:07:01 -08:00
|
|
|
elm_map_marker_show(Elm_Map_Marker *marker)
|
|
|
|
{
|
2011-11-20 07:00:43 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_ECORE_CON
|
2010-12-03 06:08:33 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN(marker);
|
2009-11-18 13:07:01 -08:00
|
|
|
elm_map_geo_region_show(marker->wd->obj, marker->longitude, marker->latitude);
|
2011-11-20 07:00:43 -08:00
|
|
|
#else
|
|
|
|
(void) marker;
|
|
|
|
#endif
|
2009-11-18 13:07:01 -08:00
|
|
|
}
|
|
|
|
|
2009-12-07 10:05:04 -08:00
|
|
|
EAPI void
|
2009-11-18 13:07:01 -08:00
|
|
|
elm_map_markers_list_show(Eina_List *markers)
|
|
|
|
{
|
2011-11-20 07:00:43 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_ECORE_CON
|
2009-11-18 13:07:01 -08:00
|
|
|
int zoom;
|
|
|
|
double lon, lat;
|
|
|
|
Eina_List *l;
|
|
|
|
Elm_Map_Marker *marker, *m_max_lon = NULL, *m_max_lat = NULL, *m_min_lon = NULL, *m_min_lat = NULL;
|
|
|
|
Evas_Coord rw, rh, xc, yc;
|
|
|
|
Widget_Data *wd;
|
|
|
|
|
2010-12-03 06:08:33 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN(markers);
|
2009-11-18 13:07:01 -08:00
|
|
|
EINA_LIST_FOREACH(markers, l, marker)
|
|
|
|
{
|
2011-04-01 04:26:58 -07:00
|
|
|
wd = marker->wd;
|
|
|
|
|
|
|
|
if ((!m_min_lon) || (marker->longitude < m_min_lon->longitude))
|
|
|
|
m_min_lon = marker;
|
|
|
|
|
|
|
|
if ((!m_max_lon) || (marker->longitude > m_max_lon->longitude))
|
|
|
|
m_max_lon = marker;
|
|
|
|
|
|
|
|
if ((!m_min_lat) || (marker->latitude > m_min_lat->latitude))
|
|
|
|
m_min_lat = marker;
|
|
|
|
|
|
|
|
if ((!m_max_lat) || (marker->latitude < m_max_lat->latitude))
|
|
|
|
m_max_lat = marker;
|
|
|
|
}
|
|
|
|
|
2009-11-18 13:07:01 -08:00
|
|
|
lon = (m_max_lon->longitude - m_min_lon->longitude) / 2. + m_min_lon->longitude;
|
|
|
|
lat = (m_max_lat->latitude - m_min_lat->latitude) / 2. + m_min_lat->latitude;
|
2011-04-01 04:26:58 -07:00
|
|
|
|
2009-11-18 13:07:01 -08:00
|
|
|
elm_smart_scroller_child_viewport_size_get(wd->scr, &rw, &rh);
|
2011-05-11 08:23:35 -07:00
|
|
|
for (zoom = wd->src->zoom_max; zoom > wd->src->zoom_min; zoom--)
|
2009-11-18 13:07:01 -08:00
|
|
|
{
|
2011-04-01 04:26:58 -07:00
|
|
|
Evas_Coord size = pow(2.0, zoom)*wd->tsize;
|
|
|
|
elm_map_utils_convert_geo_into_coord(wd->obj, lon, lat, size, &xc, &yc);
|
|
|
|
|
|
|
|
if ((m_min_lon->x[zoom] - wd->marker_max_w >= xc-rw/2)
|
2010-10-22 14:41:22 -07:00
|
|
|
&& (m_min_lat->y[zoom] - wd->marker_max_h >= yc-rh/2)
|
|
|
|
&& (m_max_lon->x[zoom] + wd->marker_max_w <= xc+rw/2)
|
|
|
|
&& (m_max_lat->y[zoom] + wd->marker_max_h <= yc+rh/2))
|
2011-04-01 04:26:58 -07:00
|
|
|
break;
|
2009-11-18 13:07:01 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
elm_map_geo_region_show(wd->obj, lon, lat);
|
|
|
|
elm_map_zoom_set(wd->obj, zoom);
|
2011-11-20 07:00:43 -08:00
|
|
|
#else
|
|
|
|
(void) markers;
|
|
|
|
#endif
|
2009-11-18 13:07:01 -08:00
|
|
|
}
|
|
|
|
|
2009-12-07 10:05:04 -08:00
|
|
|
EAPI void
|
2009-11-18 13:07:01 -08:00
|
|
|
elm_map_max_marker_per_group_set(Evas_Object *obj, int max)
|
|
|
|
{
|
2011-11-20 07:00:43 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_ECORE_CON
|
2010-03-08 22:15:39 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
2009-11-18 13:07:01 -08:00
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
2011-04-27 22:40:48 -07:00
|
|
|
|
2010-03-09 08:27:46 -08:00
|
|
|
if (!wd) return;
|
2009-11-18 13:07:01 -08:00
|
|
|
wd->markers_max_num = max;
|
2011-11-20 07:00:43 -08:00
|
|
|
#else
|
|
|
|
(void) obj;
|
|
|
|
(void) max;
|
|
|
|
#endif
|
2009-11-18 13:07:01 -08:00
|
|
|
}
|
|
|
|
|
2009-12-07 10:05:04 -08:00
|
|
|
EAPI Evas_Object *
|
2010-10-25 07:34:22 -07:00
|
|
|
elm_map_marker_object_get(const Elm_Map_Marker *marker)
|
2009-11-18 13:07:01 -08:00
|
|
|
{
|
2011-11-20 07:00:43 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_ECORE_CON
|
2010-12-03 06:08:33 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(marker, NULL);
|
2009-11-18 13:07:01 -08:00
|
|
|
return marker->content;
|
2011-11-20 07:00:43 -08:00
|
|
|
#else
|
|
|
|
(void) marker;
|
|
|
|
return NULL;
|
|
|
|
#endif
|
2009-11-18 13:07:01 -08:00
|
|
|
}
|
|
|
|
|
2009-12-18 09:45:47 -08:00
|
|
|
EAPI void
|
2009-11-18 13:07:01 -08:00
|
|
|
elm_map_marker_update(Elm_Map_Marker *marker)
|
|
|
|
{
|
2011-11-20 07:00:43 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_ECORE_CON
|
2010-12-03 06:08:33 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN(marker);
|
2010-03-09 08:27:46 -08:00
|
|
|
if (marker->content)
|
2009-11-18 13:07:01 -08:00
|
|
|
{
|
2011-04-01 04:26:58 -07:00
|
|
|
if (marker->clas->func.del)
|
|
|
|
marker->clas->func.del(marker->wd->obj, marker, marker->data, marker->content);
|
|
|
|
else
|
|
|
|
evas_object_del(marker->content);
|
|
|
|
marker->content = NULL;
|
|
|
|
_group_bubble_content_update(marker->groups[marker->wd->zoom]);
|
2009-11-18 13:07:01 -08:00
|
|
|
}
|
2011-11-20 07:00:43 -08:00
|
|
|
#else
|
|
|
|
(void) marker;
|
|
|
|
#endif
|
2009-11-18 13:07:01 -08:00
|
|
|
}
|
|
|
|
|
2009-12-07 10:05:04 -08:00
|
|
|
EAPI void
|
2009-11-21 14:38:07 -08:00
|
|
|
elm_map_bubbles_close(Evas_Object *obj)
|
|
|
|
{
|
2011-11-20 07:00:43 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_ECORE_CON
|
2010-03-08 22:15:39 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
2009-11-21 14:38:07 -08:00
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
|
|
|
Marker_Group *group;
|
|
|
|
Eina_List *l, *l_next;
|
2011-04-27 22:40:48 -07:00
|
|
|
|
2010-03-09 08:27:46 -08:00
|
|
|
if (!wd) return;
|
2009-11-21 14:38:07 -08:00
|
|
|
EINA_LIST_FOREACH_SAFE(wd->opened_bubbles, l, l_next, group)
|
2011-04-01 04:26:58 -07:00
|
|
|
_group_bubble_free(group);
|
2011-11-20 07:00:43 -08:00
|
|
|
#else
|
|
|
|
(void) obj;
|
|
|
|
#endif
|
2009-11-21 14:38:07 -08:00
|
|
|
}
|
2009-11-18 13:07:01 -08:00
|
|
|
|
2009-12-20 08:34:45 -08:00
|
|
|
EAPI Elm_Map_Group_Class *
|
|
|
|
elm_map_group_class_new(Evas_Object *obj)
|
|
|
|
{
|
2011-11-20 07:00:43 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_ECORE_CON
|
2010-03-09 08:27:46 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) NULL;
|
2009-12-20 08:34:45 -08:00
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
2011-04-27 22:40:48 -07:00
|
|
|
|
2010-03-09 08:27:46 -08:00
|
|
|
if (!wd) return NULL;
|
2009-12-20 08:34:45 -08:00
|
|
|
Elm_Map_Group_Class *clas = calloc(1, sizeof(Elm_Map_Group_Class));
|
2011-05-21 06:13:53 -07:00
|
|
|
clas->zoom_grouped = wd->zoom_max;
|
2009-12-20 08:34:45 -08:00
|
|
|
wd->groups_clas = eina_list_append(wd->groups_clas, clas);
|
|
|
|
return clas;
|
2011-11-20 07:00:43 -08:00
|
|
|
#else
|
|
|
|
(void) obj;
|
|
|
|
return NULL;
|
|
|
|
#endif
|
2009-12-20 08:34:45 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_map_group_class_style_set(Elm_Map_Group_Class *clas, const char *style)
|
|
|
|
{
|
2011-11-20 07:00:43 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_ECORE_CON
|
2010-12-03 06:08:33 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN(clas);
|
2010-03-13 13:01:26 -08:00
|
|
|
eina_stringshare_replace(&clas->style, style);
|
2011-11-20 07:00:43 -08:00
|
|
|
#else
|
|
|
|
(void) clas;
|
|
|
|
(void) style;
|
|
|
|
#endif
|
2009-12-20 08:34:45 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_map_group_class_icon_cb_set(Elm_Map_Group_Class *clas, ElmMapGroupIconGetFunc icon_get)
|
|
|
|
{
|
2011-11-20 07:00:43 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_ECORE_CON
|
2010-12-03 06:08:33 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN(clas);
|
2010-03-09 08:27:46 -08:00
|
|
|
clas->func.icon_get = icon_get;
|
2011-11-20 07:00:43 -08:00
|
|
|
#else
|
|
|
|
(void) clas;
|
|
|
|
(void) icon_get;
|
|
|
|
#endif
|
2009-12-20 08:34:45 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_map_group_class_data_set(Elm_Map_Group_Class *clas, void *data)
|
|
|
|
{
|
2011-11-20 07:00:43 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_ECORE_CON
|
2010-12-03 06:08:33 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN(clas);
|
2010-03-09 08:27:46 -08:00
|
|
|
clas->data = data;
|
2011-11-20 07:00:43 -08:00
|
|
|
#else
|
|
|
|
(void) clas;
|
|
|
|
(void) data;
|
|
|
|
#endif
|
2009-12-20 08:34:45 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_map_group_class_zoom_displayed_set(Elm_Map_Group_Class *clas, int zoom)
|
|
|
|
{
|
2011-11-20 07:00:43 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_ECORE_CON
|
2010-12-03 06:08:33 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN(clas);
|
2010-03-09 08:27:46 -08:00
|
|
|
clas->zoom_displayed = zoom;
|
2011-11-20 07:00:43 -08:00
|
|
|
#else
|
|
|
|
(void) clas;
|
|
|
|
(void) zoom;
|
|
|
|
#endif
|
2009-12-20 08:34:45 -08:00
|
|
|
}
|
|
|
|
|
2009-12-20 10:48:31 -08:00
|
|
|
EAPI void
|
|
|
|
elm_map_group_class_zoom_grouped_set(Elm_Map_Group_Class *clas, int zoom)
|
|
|
|
{
|
2011-11-20 07:00:43 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_ECORE_CON
|
2010-12-03 06:08:33 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN(clas);
|
2010-03-09 08:27:46 -08:00
|
|
|
clas->zoom_grouped = zoom;
|
2011-11-20 07:00:43 -08:00
|
|
|
#else
|
|
|
|
(void) clas;
|
|
|
|
(void) zoom;
|
|
|
|
#endif
|
2009-12-20 10:48:31 -08:00
|
|
|
}
|
|
|
|
|
2009-12-20 12:40:55 -08:00
|
|
|
EAPI void
|
|
|
|
elm_map_group_class_hide_set(Evas_Object *obj, Elm_Map_Group_Class *clas, Eina_Bool hide)
|
|
|
|
{
|
2011-11-20 07:00:43 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_ECORE_CON
|
2010-03-08 22:15:39 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
2009-12-20 12:40:55 -08:00
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
2011-04-27 22:40:48 -07:00
|
|
|
|
2010-03-09 08:27:46 -08:00
|
|
|
if (!wd) return;
|
2010-12-03 06:08:33 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN(clas);
|
2010-03-09 08:27:46 -08:00
|
|
|
if (clas->hide == hide) return;
|
2009-12-20 12:40:55 -08:00
|
|
|
clas->hide = hide;
|
2010-03-09 08:27:46 -08:00
|
|
|
if (wd->grids)
|
2009-12-20 12:40:55 -08:00
|
|
|
{
|
2011-12-12 19:48:18 -08:00
|
|
|
Grid *g;
|
2011-04-01 04:26:58 -07:00
|
|
|
Evas_Coord ox, oy, ow, oh;
|
|
|
|
evas_object_geometry_get(obj, &ox, &oy, &ow, &oh);
|
2011-12-13 01:07:00 -08:00
|
|
|
g = _get_current_grid(wd);
|
2011-12-12 19:48:18 -08:00
|
|
|
marker_place(obj, g, wd->pan_x, wd->pan_y, ox, oy, ow, oh);
|
2009-12-20 12:40:55 -08:00
|
|
|
}
|
2011-11-20 07:00:43 -08:00
|
|
|
#else
|
|
|
|
(void) obj;
|
|
|
|
(void) clas;
|
|
|
|
(void) hide;
|
|
|
|
#endif
|
2009-12-20 12:40:55 -08:00
|
|
|
}
|
|
|
|
|
2009-12-20 08:34:45 -08:00
|
|
|
EAPI Elm_Map_Marker_Class *
|
|
|
|
elm_map_marker_class_new(Evas_Object *obj)
|
|
|
|
{
|
2011-11-20 07:00:43 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_ECORE_CON
|
2010-03-09 08:27:46 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) NULL;
|
2009-12-20 08:34:45 -08:00
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
2011-04-27 22:40:48 -07:00
|
|
|
|
2010-03-09 08:27:46 -08:00
|
|
|
if (!wd) return NULL;
|
2009-12-20 08:34:45 -08:00
|
|
|
Elm_Map_Marker_Class *clas = calloc(1, sizeof(Elm_Map_Marker_Class));
|
|
|
|
wd->markers_clas = eina_list_append(wd->markers_clas, clas);
|
|
|
|
return clas;
|
2011-11-20 07:00:43 -08:00
|
|
|
#else
|
|
|
|
(void) obj;
|
|
|
|
return NULL;
|
|
|
|
#endif
|
2009-12-20 08:34:45 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_map_marker_class_style_set(Elm_Map_Marker_Class *clas, const char *style)
|
|
|
|
{
|
2011-11-20 07:00:43 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_ECORE_CON
|
2010-12-03 06:08:33 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN(clas);
|
2010-03-13 13:01:26 -08:00
|
|
|
eina_stringshare_replace(&clas->style, style);
|
2011-11-20 07:00:43 -08:00
|
|
|
#else
|
|
|
|
(void) clas;
|
|
|
|
(void) style;
|
|
|
|
#endif
|
2009-12-20 08:34:45 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_map_marker_class_icon_cb_set(Elm_Map_Marker_Class *clas, ElmMapMarkerIconGetFunc icon_get)
|
|
|
|
{
|
2011-11-20 07:00:43 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_ECORE_CON
|
2010-12-03 06:08:33 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN(clas);
|
2010-03-09 08:27:46 -08:00
|
|
|
clas->func.icon_get = icon_get;
|
2011-11-20 07:00:43 -08:00
|
|
|
#else
|
|
|
|
(void) clas;
|
|
|
|
(void) icon_get;
|
|
|
|
#endif
|
2009-12-20 08:34:45 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_map_marker_class_get_cb_set(Elm_Map_Marker_Class *clas, ElmMapMarkerGetFunc get)
|
|
|
|
{
|
2011-11-20 07:00:43 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_ECORE_CON
|
2010-12-03 06:08:33 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN(clas);
|
2010-03-09 08:27:46 -08:00
|
|
|
clas->func.get = get;
|
2011-11-20 07:00:43 -08:00
|
|
|
#else
|
|
|
|
(void) clas;
|
|
|
|
(void) get;
|
|
|
|
#endif
|
2009-12-20 08:34:45 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_map_marker_class_del_cb_set(Elm_Map_Marker_Class *clas, ElmMapMarkerDelFunc del)
|
|
|
|
{
|
2011-11-20 07:00:43 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_ECORE_CON
|
2010-12-03 06:08:33 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN(clas);
|
2010-03-09 08:27:46 -08:00
|
|
|
clas->func.del = del;
|
2011-11-20 07:00:43 -08:00
|
|
|
#else
|
|
|
|
(void) clas;
|
|
|
|
(void) del;
|
|
|
|
#endif
|
2009-12-20 08:34:45 -08:00
|
|
|
}
|
2009-12-20 10:48:31 -08:00
|
|
|
|
2011-05-04 02:44:53 -07:00
|
|
|
EAPI const char **
|
|
|
|
elm_map_source_names_get(const Evas_Object *obj)
|
|
|
|
{
|
2011-11-20 07:00:43 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_ECORE_CON
|
2011-05-04 02:44:53 -07:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) NULL;
|
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
|
|
|
|
|
|
|
if (!wd) return NULL;
|
|
|
|
return wd->source_names;
|
2011-11-20 07:00:43 -08:00
|
|
|
#else
|
|
|
|
(void) obj;
|
|
|
|
return NULL;
|
|
|
|
#endif
|
2011-05-04 02:44:53 -07:00
|
|
|
}
|
|
|
|
|
2009-12-22 14:47:17 -08:00
|
|
|
EAPI void
|
2011-05-04 02:44:53 -07:00
|
|
|
elm_map_source_name_set(Evas_Object *obj, const char *source_name)
|
2009-12-22 14:47:17 -08:00
|
|
|
{
|
2011-11-20 07:00:43 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_ECORE_CON
|
2010-03-08 22:15:39 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
2009-12-22 14:47:17 -08:00
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
2011-05-11 08:23:35 -07:00
|
|
|
Map_Sources_Tab *s;
|
2011-05-04 02:44:53 -07:00
|
|
|
Eina_List *l;
|
2009-12-22 14:47:17 -08:00
|
|
|
int zoom;
|
2011-04-27 22:40:48 -07:00
|
|
|
|
2010-03-09 08:27:46 -08:00
|
|
|
if (!wd) return;
|
2011-08-05 16:11:28 -07:00
|
|
|
if (wd->src)
|
|
|
|
{
|
|
|
|
if (!strcmp(wd->src->name, source_name)) return;
|
|
|
|
if (!wd->src->url_cb) return;
|
|
|
|
}
|
2011-05-11 08:23:35 -07:00
|
|
|
|
2011-12-12 19:48:18 -08:00
|
|
|
grid_clear_all(obj);
|
2011-05-11 08:23:35 -07:00
|
|
|
EINA_LIST_FOREACH(wd->map_sources_tab, l, s)
|
2011-05-04 02:44:53 -07:00
|
|
|
{
|
2011-05-11 08:23:35 -07:00
|
|
|
if (!strcmp(s->name, source_name))
|
2011-05-04 02:44:53 -07:00
|
|
|
{
|
2011-05-11 08:23:35 -07:00
|
|
|
wd->src = s;
|
2011-05-04 02:44:53 -07:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2009-12-22 14:47:17 -08:00
|
|
|
zoom = wd->zoom;
|
|
|
|
wd->zoom = -1;
|
2011-04-01 04:26:58 -07:00
|
|
|
|
2011-08-05 16:11:28 -07:00
|
|
|
if (wd->src)
|
|
|
|
{
|
|
|
|
if (wd->src->zoom_max < zoom)
|
|
|
|
zoom = wd->src->zoom_max;
|
|
|
|
if (wd->src->zoom_min > zoom)
|
|
|
|
zoom = wd->src->zoom_min;
|
|
|
|
}
|
2011-12-12 19:48:18 -08:00
|
|
|
grid_create_all(obj);
|
2009-12-22 14:47:17 -08:00
|
|
|
elm_map_zoom_set(obj, zoom);
|
2011-11-20 07:00:43 -08:00
|
|
|
#else
|
|
|
|
(void) obj;
|
|
|
|
(void) source_name;
|
|
|
|
#endif
|
2009-12-22 14:47:17 -08:00
|
|
|
}
|
|
|
|
|
2011-05-04 02:44:53 -07:00
|
|
|
EAPI const char *
|
|
|
|
elm_map_source_name_get(const Evas_Object *obj)
|
2011-04-07 23:14:10 -07:00
|
|
|
{
|
2011-11-20 07:00:43 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_ECORE_CON
|
2011-05-04 02:44:53 -07:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) NULL;
|
2011-04-17 23:42:47 -07:00
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
2011-05-04 02:44:53 -07:00
|
|
|
|
2011-05-11 08:23:35 -07:00
|
|
|
if ((!wd) || (!wd->src)) return NULL;
|
|
|
|
return wd->src->name;
|
2011-11-20 07:00:43 -08:00
|
|
|
#else
|
|
|
|
(void) obj;
|
|
|
|
return NULL;
|
|
|
|
#endif
|
2011-04-07 23:14:10 -07:00
|
|
|
}
|
|
|
|
|
2011-05-04 02:44:53 -07:00
|
|
|
EAPI void
|
2011-05-11 08:23:35 -07:00
|
|
|
elm_map_route_source_set(Evas_Object *obj, Elm_Map_Route_Sources source)
|
2009-12-22 14:47:17 -08:00
|
|
|
{
|
2011-11-20 07:00:43 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_ECORE_CON
|
2011-05-04 02:44:53 -07:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
2009-12-22 14:47:17 -08:00
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
2011-04-27 22:40:48 -07:00
|
|
|
|
2011-05-04 02:44:53 -07:00
|
|
|
if (!wd) return;
|
2011-05-11 08:23:35 -07:00
|
|
|
wd->route_source = source;
|
2011-11-20 07:00:43 -08:00
|
|
|
#else
|
|
|
|
(void) obj;
|
|
|
|
(void) source;
|
|
|
|
#endif
|
2009-12-22 14:47:17 -08:00
|
|
|
}
|
|
|
|
|
2011-04-07 23:14:10 -07:00
|
|
|
EAPI Elm_Map_Route_Sources
|
|
|
|
elm_map_route_source_get(const Evas_Object *obj)
|
|
|
|
{
|
2011-11-20 07:00:43 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_ECORE_CON
|
2011-04-07 23:14:10 -07:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) ELM_MAP_ROUTE_SOURCE_YOURS;
|
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
2011-04-27 22:40:48 -07:00
|
|
|
|
2011-04-07 23:14:10 -07:00
|
|
|
if (!wd) return ELM_MAP_ROUTE_SOURCE_YOURS;
|
|
|
|
return wd->route_source;
|
2011-11-20 07:00:43 -08:00
|
|
|
#else
|
|
|
|
(void) obj;
|
|
|
|
return ELM_MAP_ROUTE_SOURCE_YOURS;
|
|
|
|
#endif
|
2011-04-07 23:14:10 -07:00
|
|
|
}
|
|
|
|
|
2011-05-26 05:40:29 -07:00
|
|
|
EAPI void
|
|
|
|
elm_map_source_zoom_max_set(Evas_Object *obj, int zoom)
|
|
|
|
{
|
2011-11-20 07:00:43 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_ECORE_CON
|
2011-05-26 05:40:29 -07:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
|
|
|
|
|
|
|
if ((!wd) || (!wd->src)) return;
|
|
|
|
if ((zoom > wd->zoom_max) || (zoom < wd->zoom_min)) return;
|
|
|
|
wd->src->zoom_max = zoom;
|
2011-11-20 07:00:43 -08:00
|
|
|
#else
|
|
|
|
(void) obj;
|
|
|
|
(void) zoom;
|
|
|
|
#endif
|
2011-05-26 05:40:29 -07:00
|
|
|
}
|
|
|
|
|
2009-12-22 14:47:17 -08:00
|
|
|
EAPI int
|
2011-05-04 02:44:53 -07:00
|
|
|
elm_map_source_zoom_max_get(const Evas_Object *obj)
|
2009-12-22 14:47:17 -08:00
|
|
|
{
|
2011-11-20 07:00:43 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_ECORE_CON
|
2011-05-04 02:44:53 -07:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) 18;
|
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
|
|
|
|
2011-05-11 08:23:35 -07:00
|
|
|
if ((!wd) || (!wd->src)) return 18;
|
|
|
|
return wd->src->zoom_max;
|
2011-11-20 07:00:43 -08:00
|
|
|
#else
|
|
|
|
(void) obj;
|
|
|
|
return 18;
|
|
|
|
#endif
|
2009-12-22 14:47:17 -08:00
|
|
|
}
|
|
|
|
|
2011-05-26 05:40:29 -07:00
|
|
|
EAPI void
|
|
|
|
elm_map_source_zoom_min_set(Evas_Object *obj, int zoom)
|
|
|
|
{
|
2011-11-20 07:00:43 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_ECORE_CON
|
2011-05-26 05:40:29 -07:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
|
|
|
|
|
|
|
if ((!wd) || (!wd->src)) return;
|
|
|
|
if ((zoom > wd->zoom_max) || (zoom < wd->zoom_min)) return;
|
|
|
|
wd->src->zoom_min = zoom;
|
2011-11-20 07:00:43 -08:00
|
|
|
#else
|
|
|
|
(void) obj;
|
|
|
|
(void) zoom;
|
|
|
|
#endif
|
2011-05-26 05:40:29 -07:00
|
|
|
}
|
|
|
|
|
2009-12-22 14:47:17 -08:00
|
|
|
EAPI int
|
2011-05-04 02:44:53 -07:00
|
|
|
elm_map_source_zoom_min_get(const Evas_Object *obj)
|
2009-12-22 14:47:17 -08:00
|
|
|
{
|
2011-11-20 07:00:43 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_ECORE_CON
|
2011-05-04 02:44:53 -07:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) 0;
|
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
|
|
|
|
2011-05-11 08:23:35 -07:00
|
|
|
if ((!wd) || (!wd->src)) return 0;
|
|
|
|
return wd->src->zoom_min;
|
2011-11-20 07:00:43 -08:00
|
|
|
#else
|
|
|
|
(void) obj;
|
|
|
|
return 0;
|
|
|
|
#endif
|
2009-12-22 14:47:17 -08:00
|
|
|
}
|
|
|
|
|
2011-02-27 01:00:22 -08:00
|
|
|
EAPI void
|
|
|
|
elm_map_user_agent_set(Evas_Object *obj, const char *user_agent)
|
|
|
|
{
|
2011-11-20 07:00:43 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_ECORE_CON
|
2011-02-27 01:00:22 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
|
|
|
|
|
|
|
if (!wd) return;
|
|
|
|
if (!wd->user_agent) wd->user_agent = eina_stringshare_add(user_agent);
|
|
|
|
else eina_stringshare_replace(&wd->user_agent, user_agent);
|
2011-04-01 04:26:58 -07:00
|
|
|
|
2011-02-27 01:00:22 -08:00
|
|
|
if (!wd->ua) wd->ua = eina_hash_string_small_new(NULL);
|
2011-02-27 01:16:33 -08:00
|
|
|
eina_hash_set(wd->ua, "User-Agent", wd->user_agent);
|
2011-11-20 07:00:43 -08:00
|
|
|
#else
|
|
|
|
(void) obj;
|
|
|
|
(void) user_agent;
|
|
|
|
#endif
|
2011-02-27 01:00:22 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI const char *
|
2011-05-04 02:44:53 -07:00
|
|
|
elm_map_user_agent_get(const Evas_Object *obj)
|
2011-02-27 01:00:22 -08:00
|
|
|
{
|
2011-11-20 07:00:43 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_ECORE_CON
|
2011-02-27 01:00:22 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) NULL;
|
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
|
|
|
|
|
|
|
if (!wd) return NULL;
|
|
|
|
return wd->user_agent;
|
2011-11-20 07:00:43 -08:00
|
|
|
#else
|
|
|
|
(void) obj;
|
|
|
|
return NULL;
|
|
|
|
#endif
|
2011-02-27 01:00:22 -08:00
|
|
|
}
|
|
|
|
|
2011-04-08 01:42:32 -07:00
|
|
|
EAPI Elm_Map_Route *
|
2011-04-07 23:14:10 -07:00
|
|
|
elm_map_route_add(Evas_Object *obj,
|
|
|
|
Elm_Map_Route_Type type,
|
|
|
|
Elm_Map_Route_Method method,
|
|
|
|
double flon,
|
|
|
|
double flat,
|
|
|
|
double tlon,
|
|
|
|
double tlat)
|
|
|
|
{
|
2011-11-20 07:00:43 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_ECORE_CON
|
2011-04-07 23:14:10 -07:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) NULL;
|
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
2011-04-08 01:42:32 -07:00
|
|
|
char buf[PATH_MAX];
|
|
|
|
char *source;
|
|
|
|
char *type_name = NULL;
|
|
|
|
int fd;
|
2011-05-04 02:44:53 -07:00
|
|
|
|
2011-05-11 08:23:35 -07:00
|
|
|
if ((!wd) || (!wd->src)) return NULL;
|
2011-05-04 02:44:53 -07:00
|
|
|
|
2011-04-07 23:14:10 -07:00
|
|
|
Elm_Map_Route *route = ELM_NEW(Elm_Map_Route);
|
|
|
|
if (!route) return NULL;
|
|
|
|
|
2011-04-17 23:42:47 -07:00
|
|
|
snprintf(buf, sizeof(buf), DEST_ROUTE_XML_FILE);
|
2011-04-08 01:42:32 -07:00
|
|
|
fd = mkstemp(buf);
|
|
|
|
if (fd < 0)
|
|
|
|
{
|
|
|
|
free(route);
|
|
|
|
return NULL;
|
|
|
|
}
|
2011-04-08 07:36:29 -07:00
|
|
|
|
2011-04-07 23:14:10 -07:00
|
|
|
route->con_url = ecore_con_url_new(NULL);
|
|
|
|
route->ud.fname = strdup(buf);
|
|
|
|
INF("xml file : %s", route->ud.fname);
|
|
|
|
|
2011-04-08 01:42:32 -07:00
|
|
|
route->ud.fd = fdopen(fd, "w+");
|
|
|
|
if ((!route->con_url) || (!route->ud.fd))
|
2011-04-07 23:14:10 -07:00
|
|
|
{
|
2011-04-08 01:42:32 -07:00
|
|
|
ecore_con_url_free(route->con_url);
|
2011-04-07 23:14:10 -07:00
|
|
|
free(route);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
route->wd = wd;
|
|
|
|
route->color.r = 255;
|
|
|
|
route->color.g = 0;
|
|
|
|
route->color.b = 0;
|
|
|
|
route->color.a = 255;
|
|
|
|
route->handlers = eina_list_append
|
2011-04-08 01:42:32 -07:00
|
|
|
(route->handlers, (void *)ecore_event_handler_add
|
2011-04-17 23:42:47 -07:00
|
|
|
(ECORE_CON_EVENT_URL_COMPLETE, _route_complete_cb, route));
|
2011-04-07 23:14:10 -07:00
|
|
|
|
|
|
|
route->inbound = EINA_FALSE;
|
|
|
|
route->type = type;
|
|
|
|
route->method = method;
|
|
|
|
route->flon = flon;
|
|
|
|
route->flat = flat;
|
|
|
|
route->tlon = tlon;
|
|
|
|
route->tlat = tlat;
|
|
|
|
|
|
|
|
switch (type)
|
|
|
|
{
|
|
|
|
case ELM_MAP_ROUTE_TYPE_MOTOCAR:
|
|
|
|
type_name = strdup(ROUTE_TYPE_MOTORCAR);
|
|
|
|
break;
|
|
|
|
case ELM_MAP_ROUTE_TYPE_BICYCLE:
|
|
|
|
type_name = strdup(ROUTE_TYPE_BICYCLE);
|
|
|
|
break;
|
|
|
|
case ELM_MAP_ROUTE_TYPE_FOOT:
|
|
|
|
type_name = strdup(ROUTE_TYPE_FOOT);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2011-05-11 08:23:35 -07:00
|
|
|
source = wd->src->route_url_cb(obj, type_name, method, flon, flat, tlon, tlat);
|
2011-04-07 23:14:10 -07:00
|
|
|
INF("route url = %s", source);
|
|
|
|
|
|
|
|
wd->route = eina_list_append(wd->route, route);
|
|
|
|
|
|
|
|
ecore_con_url_url_set(route->con_url, source);
|
|
|
|
ecore_con_url_fd_set(route->con_url, fileno(route->ud.fd));
|
|
|
|
ecore_con_url_data_set(route->con_url, route);
|
|
|
|
ecore_con_url_get(route->con_url);
|
|
|
|
if (type_name) free(type_name);
|
|
|
|
if (source) free(source);
|
|
|
|
|
|
|
|
edje_object_signal_emit(elm_smart_scroller_edje_object_get(wd->scr),
|
|
|
|
"elm,state,busy,start", "elm");
|
|
|
|
evas_object_smart_callback_call(wd->obj, SIG_ROUTE_LOAD, NULL);
|
|
|
|
return route;
|
2011-11-20 07:00:43 -08:00
|
|
|
#else
|
|
|
|
(void) obj;
|
|
|
|
(void) type;
|
|
|
|
(void) method;
|
|
|
|
(void) flon;
|
|
|
|
(void) flat;
|
|
|
|
(void) tlon;
|
|
|
|
(void) tlat;
|
|
|
|
return NULL;
|
|
|
|
#endif
|
2011-04-07 23:14:10 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_map_route_remove(Elm_Map_Route *route)
|
|
|
|
{
|
2011-11-20 07:00:43 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_ECORE_CON
|
2011-04-07 23:14:10 -07:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN(route);
|
|
|
|
|
2011-05-19 22:55:15 -07:00
|
|
|
Path_Waypoint *w;
|
|
|
|
Path_Node *n;
|
2011-04-07 23:14:10 -07:00
|
|
|
Evas_Object *p;
|
|
|
|
Ecore_Event_Handler *h;
|
|
|
|
|
|
|
|
EINA_LIST_FREE(route->path, p)
|
|
|
|
{
|
|
|
|
evas_object_del(p);
|
|
|
|
}
|
|
|
|
|
|
|
|
EINA_LIST_FREE(route->waypoint, w)
|
|
|
|
{
|
|
|
|
if (w->point) eina_stringshare_del(w->point);
|
|
|
|
free(w);
|
|
|
|
}
|
|
|
|
|
|
|
|
EINA_LIST_FREE(route->nodes, n)
|
|
|
|
{
|
|
|
|
if (n->pos.address) eina_stringshare_del(n->pos.address);
|
|
|
|
free(n);
|
|
|
|
}
|
|
|
|
|
|
|
|
EINA_LIST_FREE(route->handlers, h)
|
|
|
|
{
|
|
|
|
ecore_event_handler_del(h);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (route->ud.fname)
|
|
|
|
{
|
|
|
|
ecore_file_remove(route->ud.fname);
|
|
|
|
free(route->ud.fname);
|
|
|
|
route->ud.fname = NULL;
|
|
|
|
}
|
2011-11-20 07:00:43 -08:00
|
|
|
#else
|
|
|
|
(void) route;
|
|
|
|
#endif
|
2011-04-07 23:14:10 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_map_route_color_set(Elm_Map_Route *route, int r, int g , int b, int a)
|
|
|
|
{
|
2011-11-20 07:00:43 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_ECORE_CON
|
2011-04-08 05:13:29 -07:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN(route);
|
2011-04-07 23:14:10 -07:00
|
|
|
route->color.r = r;
|
|
|
|
route->color.g = g;
|
|
|
|
route->color.b = b;
|
|
|
|
route->color.a = a;
|
2011-11-20 07:00:43 -08:00
|
|
|
#else
|
|
|
|
(void) route;
|
|
|
|
(void) r;
|
|
|
|
(void) g;
|
|
|
|
(void) b;
|
|
|
|
(void) a;
|
|
|
|
#endif
|
2011-04-07 23:14:10 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
2011-05-04 02:44:53 -07:00
|
|
|
elm_map_route_color_get(const Elm_Map_Route *route, int *r, int *g , int *b, int *a)
|
2011-04-07 23:14:10 -07:00
|
|
|
{
|
2011-11-20 07:00:43 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_ECORE_CON
|
2011-04-08 05:13:29 -07:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN(route);
|
2011-04-21 01:55:02 -07:00
|
|
|
if (r) *r = route->color.r;
|
|
|
|
if (g) *g = route->color.g;
|
|
|
|
if (b) *b = route->color.b;
|
|
|
|
if (a) *a = route->color.a;
|
2011-11-20 07:00:43 -08:00
|
|
|
#else
|
|
|
|
(void) route;
|
|
|
|
(void) r;
|
|
|
|
(void) g;
|
|
|
|
(void) b;
|
|
|
|
(void) a;
|
|
|
|
#endif
|
2011-04-07 23:14:10 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI double
|
2011-05-04 02:44:53 -07:00
|
|
|
elm_map_route_distance_get(const Elm_Map_Route *route)
|
2011-04-07 23:14:10 -07:00
|
|
|
{
|
2011-11-20 07:00:43 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_ECORE_CON
|
2011-04-08 05:13:29 -07:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(route, 0.0);
|
2011-04-07 23:14:10 -07:00
|
|
|
return route->info.distance;
|
2011-11-20 07:00:43 -08:00
|
|
|
#else
|
|
|
|
(void) route;
|
|
|
|
return 0.0;
|
|
|
|
#endif
|
2011-04-07 23:14:10 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI const char*
|
2011-05-04 02:44:53 -07:00
|
|
|
elm_map_route_node_get(const Elm_Map_Route *route)
|
2011-04-07 23:14:10 -07:00
|
|
|
{
|
2011-11-20 07:00:43 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_ECORE_CON
|
2011-04-08 05:13:29 -07:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(route, NULL);
|
2011-04-07 23:14:10 -07:00
|
|
|
return route->info.nodes;
|
2011-11-20 07:00:43 -08:00
|
|
|
#else
|
|
|
|
(void) route;
|
|
|
|
return NULL;
|
|
|
|
#endif
|
2011-04-07 23:14:10 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI const char*
|
2011-05-04 02:44:53 -07:00
|
|
|
elm_map_route_waypoint_get(const Elm_Map_Route *route)
|
2011-04-07 23:14:10 -07:00
|
|
|
{
|
2011-11-20 07:00:43 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_ECORE_CON
|
2011-04-08 05:13:29 -07:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(route, NULL);
|
2011-04-07 23:14:10 -07:00
|
|
|
return route->info.waypoints;
|
2011-11-20 07:00:43 -08:00
|
|
|
#else
|
|
|
|
(void) route;
|
|
|
|
return NULL;
|
|
|
|
#endif
|
2011-04-07 23:14:10 -07:00
|
|
|
}
|
2009-12-22 14:47:17 -08:00
|
|
|
|
2011-04-17 23:42:47 -07:00
|
|
|
EAPI const char *
|
2011-05-04 02:44:53 -07:00
|
|
|
elm_map_name_address_get(const Elm_Map_Name *name)
|
2011-04-17 23:42:47 -07:00
|
|
|
{
|
2011-11-20 07:00:43 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_ECORE_CON
|
2011-04-17 23:42:47 -07:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(name, NULL);
|
|
|
|
return name->address;
|
2011-11-20 07:00:43 -08:00
|
|
|
#else
|
|
|
|
(void) name;
|
|
|
|
return NULL;
|
|
|
|
#endif
|
2011-04-17 23:42:47 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
2011-05-04 02:44:53 -07:00
|
|
|
elm_map_name_region_get(const Elm_Map_Name *name, double *lon, double *lat)
|
2011-04-17 23:42:47 -07:00
|
|
|
{
|
2011-11-20 07:00:43 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_ECORE_CON
|
2011-04-17 23:42:47 -07:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN(name);
|
2011-04-21 01:55:02 -07:00
|
|
|
if (lon) *lon = name->lon;
|
|
|
|
if (lat) *lat = name->lat;
|
2011-11-20 07:00:43 -08:00
|
|
|
#else
|
|
|
|
(void) name;
|
|
|
|
(void) lon;
|
|
|
|
(void) lat;
|
|
|
|
#endif
|
2011-04-17 23:42:47 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_map_name_remove(Elm_Map_Name *name)
|
|
|
|
{
|
2011-11-20 07:00:43 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_ECORE_CON
|
2011-04-17 23:42:47 -07:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN(name);
|
|
|
|
if (name->address)
|
|
|
|
{
|
|
|
|
free(name->address);
|
|
|
|
name->address = NULL;
|
|
|
|
}
|
|
|
|
if (name->handler)
|
|
|
|
{
|
|
|
|
ecore_event_handler_del(name->handler);
|
|
|
|
name->handler = NULL;
|
|
|
|
}
|
|
|
|
if (name->ud.fname)
|
|
|
|
{
|
|
|
|
ecore_file_remove(name->ud.fname);
|
|
|
|
free(name->ud.fname);
|
|
|
|
name->ud.fname = NULL;
|
|
|
|
}
|
2011-11-20 07:00:43 -08:00
|
|
|
#else
|
|
|
|
(void) name;
|
|
|
|
#endif
|
2011-04-17 23:42:47 -07:00
|
|
|
}
|
|
|
|
|
2011-04-21 01:55:02 -07:00
|
|
|
EAPI void
|
|
|
|
elm_map_rotate_set(Evas_Object *obj, double degree, Evas_Coord cx, Evas_Coord cy)
|
|
|
|
{
|
2011-11-20 07:00:43 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_ECORE_CON
|
2011-04-21 01:55:02 -07:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
|
|
|
|
2011-04-27 21:16:00 -07:00
|
|
|
if (!wd) return;
|
2011-04-21 01:55:02 -07:00
|
|
|
wd->rotate.d = degree;
|
|
|
|
wd->rotate.cx = cx;
|
|
|
|
wd->rotate.cy = cy;
|
|
|
|
wd->calc_job = ecore_job_add(_calc_job, wd);
|
2011-11-20 07:00:43 -08:00
|
|
|
#else
|
|
|
|
(void) obj;
|
|
|
|
(void) degree;
|
|
|
|
(void) cx;
|
|
|
|
(void) cy;
|
|
|
|
#endif
|
2011-04-21 01:55:02 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_map_rotate_get(const Evas_Object *obj, double *degree, Evas_Coord *cx, Evas_Coord *cy)
|
|
|
|
{
|
2011-11-20 07:00:43 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_ECORE_CON
|
2011-04-21 01:55:02 -07:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
|
|
|
|
2011-04-27 21:16:00 -07:00
|
|
|
if (!wd) return;
|
2011-04-21 01:55:02 -07:00
|
|
|
if (degree) *degree = wd->rotate.d;
|
|
|
|
if (cx) *cx = wd->rotate.cx;
|
|
|
|
if (cy) *cy = wd->rotate.cy;
|
2011-11-20 07:00:43 -08:00
|
|
|
#else
|
|
|
|
(void) obj;
|
|
|
|
(void) degree;
|
|
|
|
(void) cx;
|
|
|
|
(void) cy;
|
|
|
|
#endif
|
2011-04-21 01:55:02 -07:00
|
|
|
}
|
2011-04-17 23:42:47 -07:00
|
|
|
|
2011-04-27 19:47:12 -07:00
|
|
|
EAPI void
|
|
|
|
elm_map_wheel_disabled_set(Evas_Object *obj, Eina_Bool disabled)
|
|
|
|
{
|
2011-11-20 07:00:43 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_ECORE_CON
|
2011-04-27 19:47:12 -07:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
|
|
|
|
2011-04-27 21:16:00 -07:00
|
|
|
if (!wd) return;
|
2011-04-27 19:47:12 -07:00
|
|
|
if ((!wd->wheel_disabled) && (disabled))
|
|
|
|
evas_object_event_callback_del_full(wd->rect, EVAS_CALLBACK_MOUSE_WHEEL, _mouse_wheel_cb, obj);
|
|
|
|
else if ((wd->wheel_disabled) && (!disabled))
|
|
|
|
evas_object_event_callback_add(wd->rect, EVAS_CALLBACK_MOUSE_WHEEL, _mouse_wheel_cb, obj);
|
2011-04-28 08:12:28 -07:00
|
|
|
wd->wheel_disabled = !!disabled;
|
2011-11-20 07:00:43 -08:00
|
|
|
#else
|
|
|
|
(void) obj;
|
|
|
|
(void) disabled;
|
|
|
|
#endif
|
2011-04-27 19:47:12 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI Eina_Bool
|
|
|
|
elm_map_wheel_disabled_get(const Evas_Object *obj)
|
|
|
|
{
|
2011-11-20 07:00:43 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_ECORE_CON
|
2011-04-27 19:47:12 -07:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
|
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
2011-04-27 22:40:48 -07:00
|
|
|
|
2011-04-27 21:16:00 -07:00
|
|
|
if (!wd) return EINA_FALSE;
|
2011-04-27 19:47:12 -07:00
|
|
|
return wd->wheel_disabled;
|
2011-11-20 07:00:43 -08:00
|
|
|
#else
|
|
|
|
(void) obj;
|
|
|
|
return EINA_FALSE;
|
|
|
|
#endif
|
2011-04-27 19:47:12 -07:00
|
|
|
}
|
|
|
|
|
2011-06-25 10:48:55 -07:00
|
|
|
#ifdef ELM_EMAP
|
2011-06-26 10:36:18 -07:00
|
|
|
EAPI Evas_Object *
|
2011-06-25 07:30:10 -07:00
|
|
|
elm_map_track_add(Evas_Object *obj, EMap_Route *emap)
|
2011-05-19 22:55:15 -07:00
|
|
|
{
|
2011-11-20 07:00:43 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_ECORE_CON
|
2011-05-19 22:55:15 -07:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) NULL;
|
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
|
|
|
|
|
|
|
if (!wd) return EINA_FALSE;
|
|
|
|
|
2011-06-26 10:36:18 -07:00
|
|
|
Evas_Object *route = elm_route_add(obj);
|
|
|
|
elm_route_emap_set(route, emap);
|
|
|
|
wd->track = eina_list_append(wd->track, route);
|
2011-05-19 22:55:15 -07:00
|
|
|
|
2011-06-26 10:36:18 -07:00
|
|
|
return route;
|
2011-11-20 07:00:43 -08:00
|
|
|
#else
|
|
|
|
(void) obj;
|
|
|
|
(void) emap;
|
|
|
|
return NULL;
|
|
|
|
#endif
|
2011-05-19 22:55:15 -07:00
|
|
|
}
|
2011-06-25 07:30:10 -07:00
|
|
|
#endif
|
2011-05-19 22:55:15 -07:00
|
|
|
|
|
|
|
EAPI void
|
2011-06-26 10:36:18 -07:00
|
|
|
elm_map_track_remove(Evas_Object *obj, Evas_Object *route)
|
2011-05-19 22:55:15 -07:00
|
|
|
{
|
2011-11-20 07:00:43 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_ECORE_CON
|
2011-06-26 10:36:18 -07:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) ;
|
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
2011-05-19 22:55:15 -07:00
|
|
|
|
2011-06-26 10:36:18 -07:00
|
|
|
if (!wd) return ;
|
2011-05-19 22:55:15 -07:00
|
|
|
|
2011-06-26 10:36:18 -07:00
|
|
|
wd->track = eina_list_remove(wd->track, route);
|
|
|
|
evas_object_del(route);
|
2011-11-20 07:00:43 -08:00
|
|
|
#else
|
|
|
|
(void) obj;
|
|
|
|
(void) route;
|
|
|
|
#endif
|
2011-05-19 22:55:15 -07:00
|
|
|
}
|
|
|
|
|
2011-11-20 07:00:43 -08:00
|
|
|
#ifdef HAVE_ELEMENTARY_ECORE_CON
|
|
|
|
|
2010-03-09 08:27:46 -08:00
|
|
|
static char *
|
2010-12-30 17:08:01 -08:00
|
|
|
_mapnik_url_cb(Evas_Object *obj __UNUSED__, int x, int y, int zoom)
|
2009-12-22 14:47:17 -08:00
|
|
|
{
|
|
|
|
char buf[PATH_MAX];
|
2011-12-05 01:00:04 -08:00
|
|
|
// ((x+y+zoom)%3)+'a' is requesting map images from distributed tile servers (eg., a, b, c)
|
|
|
|
snprintf(buf, sizeof(buf), "http://%c.tile.openstreetmap.org/%d/%d/%d.png", ((x+y+zoom)%3)+'a', zoom, x, y);
|
2009-12-22 14:47:17 -08:00
|
|
|
return strdup(buf);
|
|
|
|
}
|
|
|
|
|
2010-03-09 08:27:46 -08:00
|
|
|
static char *
|
2010-12-30 17:08:01 -08:00
|
|
|
_osmarender_url_cb(Evas_Object *obj __UNUSED__, int x, int y, int zoom)
|
2009-12-22 14:47:17 -08:00
|
|
|
{
|
|
|
|
char buf[PATH_MAX];
|
2011-12-05 01:00:04 -08:00
|
|
|
snprintf(buf, sizeof(buf), "http://%c.tah.openstreetmap.org/Tiles/tile/%d/%d/%d.png", ((x+y+zoom)%3)+'a', zoom, x, y);
|
2009-12-22 14:47:17 -08:00
|
|
|
return strdup(buf);
|
|
|
|
}
|
|
|
|
|
2010-03-09 08:27:46 -08:00
|
|
|
static char *
|
2010-12-30 17:08:01 -08:00
|
|
|
_cyclemap_url_cb(Evas_Object *obj __UNUSED__, int x, int y, int zoom)
|
2009-12-22 14:47:17 -08:00
|
|
|
{
|
|
|
|
char buf[PATH_MAX];
|
2011-12-05 01:00:04 -08:00
|
|
|
snprintf(buf, sizeof(buf), "http://%c.tile.opencyclemap.org/cycle/%d/%d/%d.png", ((x+y+zoom)%3)+'a', zoom, x, y);
|
2009-12-22 14:47:17 -08:00
|
|
|
return strdup(buf);
|
|
|
|
}
|
|
|
|
|
2010-03-09 08:27:46 -08:00
|
|
|
static char *
|
2011-12-05 01:00:04 -08:00
|
|
|
_mapquest_url_cb(Evas_Object *obj __UNUSED__, int x, int y, int zoom)
|
2009-12-22 14:47:17 -08:00
|
|
|
{
|
|
|
|
char buf[PATH_MAX];
|
2011-12-05 01:00:04 -08:00
|
|
|
snprintf(buf, sizeof(buf), "http://otile%d.mqcdn.com/tiles/1.0.0/osm/%d/%d/%d.png", ((x+y+zoom)%4)+1, zoom, x, y);
|
|
|
|
return strdup(buf);
|
|
|
|
}
|
|
|
|
|
|
|
|
static char *
|
|
|
|
_mapquest_aerial_url_cb(Evas_Object *obj __UNUSED__, int x, int y, int zoom)
|
|
|
|
{
|
|
|
|
char buf[PATH_MAX];
|
|
|
|
snprintf(buf, sizeof(buf), "http://oatile%d.mqcdn.com/naip/%d/%d/%d.png", ((x+y+zoom)%4)+1, zoom, x, y);
|
2009-12-22 14:47:17 -08:00
|
|
|
return strdup(buf);
|
|
|
|
}
|
|
|
|
|
2011-04-07 23:14:10 -07:00
|
|
|
static char *_yours_url_cb(Evas_Object *obj __UNUSED__, char *type_name, int method, double flon, double flat, double tlon, double tlat)
|
|
|
|
{
|
|
|
|
char buf[PATH_MAX];
|
|
|
|
snprintf(buf, sizeof(buf),
|
2011-04-17 23:42:47 -07:00
|
|
|
"%s?flat=%lf&flon=%lf&tlat=%lf&tlon=%lf&v=%s&fast=%d&instructions=1",
|
2011-04-07 23:14:10 -07:00
|
|
|
ROUTE_YOURS_URL, flat, flon, tlat, tlon, type_name, method);
|
|
|
|
|
|
|
|
return strdup(buf);
|
|
|
|
}
|
|
|
|
|
|
|
|
// TODO: fix monav api
|
2011-04-08 01:42:32 -07:00
|
|
|
/*
|
2011-04-07 23:14:10 -07:00
|
|
|
static char *_monav_url_cb(Evas_Object *obj __UNUSED__, char *type_name, int method, double flon, double flat, double tlon, double tlat)
|
|
|
|
{
|
|
|
|
char buf[PATH_MAX];
|
|
|
|
snprintf(buf, sizeof(buf),
|
|
|
|
"%s?flat=%f&flon=%f&tlat=%f&tlon=%f&v=%s&fast=%d&instructions=1",
|
|
|
|
ROUTE_MONAV_URL, flat, flon, tlat, tlon, type_name, method);
|
|
|
|
|
|
|
|
return strdup(buf);
|
|
|
|
}
|
2011-04-08 01:42:32 -07:00
|
|
|
*/
|
2011-04-07 23:14:10 -07:00
|
|
|
|
|
|
|
// TODO: fix ors api
|
2011-04-08 01:42:32 -07:00
|
|
|
/*
|
2011-04-07 23:14:10 -07:00
|
|
|
static char *_ors_url_cb(Evas_Object *obj __UNUSED__, char *type_name, int method, double flon, double flat, double tlon, double tlat)
|
|
|
|
{
|
|
|
|
char buf[PATH_MAX];
|
|
|
|
snprintf(buf, sizeof(buf),
|
|
|
|
"%s?flat=%f&flon=%f&tlat=%f&tlon=%f&v=%s&fast=%d&instructions=1",
|
|
|
|
ROUTE_ORS_URL, flat, flon, tlat, tlon, type_name, method);
|
|
|
|
|
|
|
|
return strdup(buf);
|
|
|
|
}
|
2011-04-08 01:42:32 -07:00
|
|
|
*/
|
2011-04-07 23:14:10 -07:00
|
|
|
|
2011-04-17 23:42:47 -07:00
|
|
|
static char *
|
|
|
|
_nominatim_url_cb(Evas_Object *obj, int method, char *name, double lon, double lat)
|
|
|
|
{
|
2011-04-27 22:40:48 -07:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) strdup("");
|
2011-04-17 23:42:47 -07:00
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
|
|
|
char **str;
|
|
|
|
unsigned int ele, idx;
|
|
|
|
char search_url[PATH_MAX];
|
|
|
|
char buf[PATH_MAX];
|
2011-04-27 22:40:48 -07:00
|
|
|
|
|
|
|
if (!wd) return strdup("");
|
2011-04-17 23:42:47 -07:00
|
|
|
if (method == ELM_MAP_NAME_METHOD_SEARCH)
|
|
|
|
{
|
|
|
|
search_url[0] = '\0';
|
|
|
|
str = eina_str_split_full(name, " ", 0, &ele);
|
|
|
|
for (idx = 0 ; idx < ele ; idx++)
|
|
|
|
{
|
|
|
|
eina_strlcat(search_url, str[idx], sizeof(search_url));
|
|
|
|
if (!(idx == (ele-1))) eina_strlcat(search_url, "+", sizeof(search_url));
|
|
|
|
}
|
|
|
|
snprintf(buf, sizeof(buf), "%s/search?q=%s&format=xml&polygon=0&addressdetails=0", NAME_NOMINATIM_URL, search_url);
|
2011-11-30 00:37:55 -08:00
|
|
|
|
|
|
|
if (str && str[0])
|
|
|
|
{
|
|
|
|
free(str[0]);
|
|
|
|
free(str);
|
|
|
|
}
|
2011-04-17 23:42:47 -07:00
|
|
|
}
|
|
|
|
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);
|
|
|
|
else strcpy(buf, "");
|
|
|
|
|
|
|
|
return strdup(buf);
|
|
|
|
}
|
2011-11-20 07:00:43 -08:00
|
|
|
|
|
|
|
#endif
|