X-Git-Url: https://git.street.me.uk/andy/viking.git/blobdiff_plain/5092de80d905b2500af04ec610db0e05a8a24225..b4926b44bfca24583073b4cf7567016c5e71f7d7:/src/gpx.c diff --git a/src/gpx.c b/src/gpx.c index 53c08b88..cd54ba9a 100644 --- a/src/gpx.c +++ b/src/gpx.c @@ -1,7 +1,11 @@ /* * viking -- GPS Data and Topo Analyzer, Explorer, and Manager * - * Copyright (C) 2003-2005, Evan Battaglia + * Copyright (C) 2003-2007, Evan Battaglia + * Copyright (C) 2007, Quy Tonthat + * Copyright (C) 2008, Hein Ragas + * Copyright (C) 2009, Tal B + * Copyright (c) 2012, Rob Norris * * Some of the code adapted from GPSBabel 1.2.7 * http://gpsbabel.sf.net/ @@ -22,17 +26,23 @@ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA * */ - +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif #define _XOPEN_SOURCE /* glibc2 needs this */ +#include "gpx.h" #include "viking.h" #include +#ifdef HAVE_STRING_H #include +#endif #include +#ifdef HAVE_MATH_H #include - -#define GPX_TIME_FORMAT "%Y-%m-%dT%H:%M:%SZ" +#endif +#include typedef enum { tt_unknown = 0, @@ -40,20 +50,35 @@ typedef enum { tt_gpx, tt_wpt, + tt_wpt_cmt, tt_wpt_desc, tt_wpt_name, tt_wpt_ele, - tt_wpt_sym, + tt_wpt_sym, + tt_wpt_time, tt_wpt_link, /* New in GPX 1.1 */ tt_trk, + tt_trk_cmt, tt_trk_desc, tt_trk_name, + tt_rte, + tt_trk_trkseg, tt_trk_trkseg_trkpt, tt_trk_trkseg_trkpt_ele, tt_trk_trkseg_trkpt_time, + tt_trk_trkseg_trkpt_name, + /* extended */ + tt_trk_trkseg_trkpt_course, + tt_trk_trkseg_trkpt_speed, + tt_trk_trkseg_trkpt_fix, + tt_trk_trkseg_trkpt_sat, + + tt_trk_trkseg_trkpt_hdop, + tt_trk_trkseg_trkpt_vdop, + tt_trk_trkseg_trkpt_pdop, tt_waypoint, tt_waypoint_coord, @@ -65,6 +90,11 @@ typedef struct tag_mapping { const char *tag_name; /* xpath-ish tag name */ } tag_mapping; +typedef struct { + GpxWritingOptions *options; + FILE *file; +} GpxWritingContext; + /* * xpath(ish) mappings between full tag paths and internal identifers. * These appear in the order they appear in the GPX specification. @@ -80,21 +110,41 @@ tag_mapping tag_path_map[] = { { tt_waypoint_name, "/loc/waypoint/name" }, { tt_wpt_ele, "/gpx/wpt/ele" }, + { tt_wpt_time, "/gpx/wpt/time" }, { tt_wpt_name, "/gpx/wpt/name" }, + { tt_wpt_cmt, "/gpx/wpt/cmt" }, { tt_wpt_desc, "/gpx/wpt/desc" }, { tt_wpt_sym, "/gpx/wpt/sym" }, { tt_wpt_sym, "/loc/waypoint/type" }, { tt_wpt_link, "/gpx/wpt/link" }, /* GPX 1.1 */ { tt_trk, "/gpx/trk" }, - { tt_trk, "/gpx/rte" }, { tt_trk_name, "/gpx/trk/name" }, + { tt_trk_cmt, "/gpx/trk/cmt" }, { tt_trk_desc, "/gpx/trk/desc" }, { tt_trk_trkseg, "/gpx/trk/trkseg" }, { tt_trk_trkseg_trkpt, "/gpx/trk/trkseg/trkpt" }, - { tt_trk_trkseg_trkpt, "/gpx/rte/rtept" }, { tt_trk_trkseg_trkpt_ele, "/gpx/trk/trkseg/trkpt/ele" }, { tt_trk_trkseg_trkpt_time, "/gpx/trk/trkseg/trkpt/time" }, + { tt_trk_trkseg_trkpt_name, "/gpx/trk/trkseg/trkpt/name" }, + /* extended */ + { tt_trk_trkseg_trkpt_course, "/gpx/trk/trkseg/trkpt/course" }, + { tt_trk_trkseg_trkpt_speed, "/gpx/trk/trkseg/trkpt/speed" }, + { tt_trk_trkseg_trkpt_fix, "/gpx/trk/trkseg/trkpt/fix" }, + { tt_trk_trkseg_trkpt_sat, "/gpx/trk/trkseg/trkpt/sat" }, + + { tt_trk_trkseg_trkpt_hdop, "/gpx/trk/trkseg/trkpt/hdop" }, + { tt_trk_trkseg_trkpt_vdop, "/gpx/trk/trkseg/trkpt/vdop" }, + { tt_trk_trkseg_trkpt_pdop, "/gpx/trk/trkseg/trkpt/pdop" }, + + { tt_rte, "/gpx/rte" }, + // NB Route reuses track point feature tags + { tt_trk_name, "/gpx/rte/name" }, + { tt_trk_cmt, "/gpx/rte/cmt" }, + { tt_trk_desc, "/gpx/rte/desc" }, + { tt_trk_trkseg_trkpt, "/gpx/rte/rtept" }, + { tt_trk_trkseg_trkpt_name, "/gpx/rte/rtept/name" }, + { tt_trk_trkseg_trkpt_ele, "/gpx/rte/rtept/ele" }, {0} }; @@ -130,7 +180,7 @@ struct LatLon c_ll; gboolean f_tr_newseg; guint unnamed_waypoints = 0; guint unnamed_tracks = 0; - +guint unnamed_routes = 0; static const char *get_attr ( const char **attr, const char *key ) { @@ -145,8 +195,8 @@ static const char *get_attr ( const char **attr, const char *key ) static gboolean set_c_ll ( const char **attr ) { if ( (c_slat = get_attr ( attr, "lat" )) && (c_slon = get_attr ( attr, "lon" )) ) { - c_ll.lat = g_strtod(c_slat, NULL); - c_ll.lon = g_strtod(c_slon, NULL); + c_ll.lat = g_ascii_strtod(c_slat, NULL); + c_ll.lon = g_ascii_strtod(c_slon, NULL); return TRUE; } return FALSE; @@ -165,18 +215,22 @@ static void gpx_start(VikTrwLayer *vtl, const char *el, const char **attr) case tt_wpt: if ( set_c_ll( attr ) ) { c_wp = vik_waypoint_new (); - c_wp->altitude = VIK_DEFAULT_ALTITUDE; - if ( ! get_attr ( attr, "hidden" ) ) - c_wp->visible = TRUE; + c_wp->visible = TRUE; + if ( get_attr ( attr, "hidden" ) ) + c_wp->visible = FALSE; vik_coord_load_from_latlon ( &(c_wp->coord), vik_trw_layer_get_coord_mode ( vtl ), &c_ll ); } break; case tt_trk: + case tt_rte: c_tr = vik_track_new (); - if ( ! get_attr ( attr, "hidden" ) ) - c_tr->visible = TRUE; + vik_track_set_defaults ( c_tr ); + c_tr->is_route = (current_tag == tt_rte) ? TRUE : FALSE; + c_tr->visible = TRUE; + if ( get_attr ( attr, "hidden" ) ) + c_tr->visible = FALSE; break; case tt_trk_trkseg: @@ -186,7 +240,6 @@ static void gpx_start(VikTrwLayer *vtl, const char *el, const char **attr) case tt_trk_trkseg_trkpt: if ( set_c_ll( attr ) ) { c_tp = vik_trackpoint_new (); - c_tp->altitude = VIK_DEFAULT_ALTITUDE; vik_coord_load_from_latlon ( &(c_tp->coord), vik_trw_layer_get_coord_mode ( vtl ), &c_ll ); if ( f_tr_newseg ) { c_tp->newsegment = TRUE; @@ -196,12 +249,16 @@ static void gpx_start(VikTrwLayer *vtl, const char *el, const char **attr) } break; + case tt_trk_trkseg_trkpt_name: case tt_trk_trkseg_trkpt_ele: case tt_trk_trkseg_trkpt_time: + case tt_wpt_cmt: case tt_wpt_desc: case tt_wpt_name: case tt_wpt_ele: + case tt_wpt_time: case tt_wpt_link: + case tt_trk_cmt: case tt_trk_desc: case tt_trk_name: g_string_erase ( c_cdata, 0, -1 ); /* clear the cdata buffer */ @@ -209,7 +266,6 @@ static void gpx_start(VikTrwLayer *vtl, const char *el, const char **attr) case tt_waypoint: c_wp = vik_waypoint_new (); - c_wp->altitude = VIK_DEFAULT_ALTITUDE; c_wp->visible = TRUE; break; @@ -233,7 +289,9 @@ static void gpx_start(VikTrwLayer *vtl, const char *el, const char **attr) static void gpx_end(VikTrwLayer *vtl, const char *el) { - static struct tm tm; + static GTimeVal tp_time; + static GTimeVal wp_time; + g_string_truncate ( xpath, xpath->len - strlen(el) - 1 ); switch ( current_tag ) { @@ -241,7 +299,7 @@ static void gpx_end(VikTrwLayer *vtl, const char *el) case tt_waypoint: case tt_wpt: if ( ! c_wp_name ) - c_wp_name = g_strdup_printf("VIKING_WP%d", unnamed_waypoints++); + c_wp_name = g_strdup_printf("VIKING_WP%04d", unnamed_waypoints++); vik_trw_layer_filein_add_waypoint ( vtl, c_wp_name, c_wp ); g_free ( c_wp_name ); c_wp = NULL; @@ -250,7 +308,11 @@ static void gpx_end(VikTrwLayer *vtl, const char *el) case tt_trk: if ( ! c_tr_name ) - c_tr_name = g_strdup_printf("VIKING_TR%d", unnamed_waypoints++); + c_tr_name = g_strdup_printf("VIKING_TR%03d", unnamed_tracks++); + // Delibrate fall through + case tt_rte: + if ( ! c_tr_name ) + c_tr_name = g_strdup_printf("VIKING_RT%03d", unnamed_routes++); vik_trw_layer_filein_add_track ( vtl, c_tr_name, c_tr ); g_free ( c_tr_name ); c_tr = NULL; @@ -272,17 +334,22 @@ static void gpx_end(VikTrwLayer *vtl, const char *el) break; case tt_wpt_ele: - c_wp->altitude = g_strtod ( c_cdata->str, NULL ); + c_wp->altitude = g_ascii_strtod ( c_cdata->str, NULL ); g_string_erase ( c_cdata, 0, -1 ); break; case tt_trk_trkseg_trkpt_ele: - c_tp->altitude = g_strtod ( c_cdata->str, NULL ); + c_tp->altitude = g_ascii_strtod ( c_cdata->str, NULL ); g_string_erase ( c_cdata, 0, -1 ); break; case tt_waypoint_name: /* .loc name is really description. */ case tt_wpt_desc: + vik_waypoint_set_description ( c_wp, c_cdata->str ); + g_string_erase ( c_cdata, 0, -1 ); + break; + + case tt_wpt_cmt: vik_waypoint_set_comment ( c_wp, c_cdata->str ); g_string_erase ( c_cdata, 0, -1 ); break; @@ -293,27 +360,82 @@ static void gpx_end(VikTrwLayer *vtl, const char *el) break; case tt_wpt_sym: { - gchar *tmp_lower = g_utf8_strdown(c_cdata->str, -1); /* for things like Geocache */ - vik_waypoint_set_symbol ( c_wp, tmp_lower ); - g_free ( tmp_lower ); + vik_waypoint_set_symbol ( c_wp, c_cdata->str ); g_string_erase ( c_cdata, 0, -1 ); break; } case tt_trk_desc: + vik_track_set_description ( c_tr, c_cdata->str ); + g_string_erase ( c_cdata, 0, -1 ); + break; + + case tt_trk_cmt: vik_track_set_comment ( c_tr, c_cdata->str ); g_string_erase ( c_cdata, 0, -1 ); break; - case tt_trk_trkseg_trkpt_time: + case tt_wpt_time: + if ( g_time_val_from_iso8601(c_cdata->str, &wp_time) ) { + c_wp->timestamp = wp_time.tv_sec; + c_wp->has_timestamp = TRUE; + } + g_string_erase ( c_cdata, 0, -1 ); + break; - if ( strptime(c_cdata->str, GPX_TIME_FORMAT, &tm) != c_cdata->str ) { /* it read at least one char */ - c_tp->timestamp = mktime(&tm); + case tt_trk_trkseg_trkpt_name: + vik_trackpoint_set_name ( c_tp, c_cdata->str ); + g_string_erase ( c_cdata, 0, -1 ); + break; + + case tt_trk_trkseg_trkpt_time: + if ( g_time_val_from_iso8601(c_cdata->str, &tp_time) ) { + c_tp->timestamp = tp_time.tv_sec; c_tp->has_timestamp = TRUE; } g_string_erase ( c_cdata, 0, -1 ); break; + case tt_trk_trkseg_trkpt_course: + c_tp->course = g_ascii_strtod ( c_cdata->str, NULL ); + g_string_erase ( c_cdata, 0, -1 ); + break; + + case tt_trk_trkseg_trkpt_speed: + c_tp->speed = g_ascii_strtod ( c_cdata->str, NULL ); + g_string_erase ( c_cdata, 0, -1 ); + break; + + case tt_trk_trkseg_trkpt_fix: + if (!strcmp("2d", c_cdata->str)) + c_tp->fix_mode = VIK_GPS_MODE_2D; + else if (!strcmp("3d", c_cdata->str)) + c_tp->fix_mode = VIK_GPS_MODE_3D; + else /* TODO: more fix modes here */ + c_tp->fix_mode = VIK_GPS_MODE_NOT_SEEN; + g_string_erase ( c_cdata, 0, -1 ); + break; + + case tt_trk_trkseg_trkpt_sat: + c_tp->nsats = atoi ( c_cdata->str ); + g_string_erase ( c_cdata, 0, -1 ); + break; + + case tt_trk_trkseg_trkpt_hdop: + c_tp->hdop = g_strtod ( c_cdata->str, NULL ); + g_string_erase ( c_cdata, 0, -1 ); + break; + + case tt_trk_trkseg_trkpt_vdop: + c_tp->vdop = g_strtod ( c_cdata->str, NULL ); + g_string_erase ( c_cdata, 0, -1 ); + break; + + case tt_trk_trkseg_trkpt_pdop: + c_tp->pdop = g_strtod ( c_cdata->str, NULL ); + g_string_erase ( c_cdata, 0, -1 ); + break; + default: break; } @@ -327,11 +449,22 @@ static void gpx_cdata(void *dta, const XML_Char *s, int len) case tt_trk_name: case tt_wpt_ele: case tt_trk_trkseg_trkpt_ele: + case tt_wpt_cmt: case tt_wpt_desc: case tt_wpt_sym: case tt_wpt_link: + case tt_trk_cmt: case tt_trk_desc: case tt_trk_trkseg_trkpt_time: + case tt_wpt_time: + case tt_trk_trkseg_trkpt_name: + case tt_trk_trkseg_trkpt_course: + case tt_trk_trkseg_trkpt_speed: + case tt_trk_trkseg_trkpt_fix: + case tt_trk_trkseg_trkpt_sat: + case tt_trk_trkseg_trkpt_hdop: + case tt_trk_trkseg_trkpt_vdop: + case tt_trk_trkseg_trkpt_pdop: case tt_waypoint_name: /* .loc name is really description. */ g_string_append_len ( c_cdata, s, len ); break; @@ -343,9 +476,10 @@ static void gpx_cdata(void *dta, const XML_Char *s, int len) // make like a "stack" of tag names // like gpspoint's separated like /gpx/wpt/whatever -void a_gpx_read_file( VikTrwLayer *vtl, FILE *f ) { +gboolean a_gpx_read_file( VikTrwLayer *vtl, FILE *f ) { XML_Parser parser = XML_ParserCreate(NULL); int done=0, len; + enum XML_Status status = XML_STATUS_ERROR; XML_SetElementHandler(parser, (XML_StartElementHandler) gpx_start, (XML_EndElementHandler) gpx_end); XML_SetUserData(parser, vtl); /* in the future we could remove all global variables */ @@ -358,17 +492,21 @@ void a_gpx_read_file( VikTrwLayer *vtl, FILE *f ) { xpath = g_string_new ( "" ); c_cdata = g_string_new ( "" ); - unnamed_waypoints = 0; - unnamed_tracks = 0; + unnamed_waypoints = 1; + unnamed_tracks = 1; + unnamed_routes = 1; while (!done) { len = fread(buf, 1, sizeof(buf)-7, f); done = feof(f) || !len; - XML_Parse(parser, buf, len, done); + status = XML_Parse(parser, buf, len, done); } + XML_ParserFree (parser); g_string_free ( xpath, TRUE ); g_string_free ( c_cdata, TRUE ); + + return status != XML_STATUS_ERROR; } /**** entitize from GPSBabel ****/ @@ -540,20 +678,32 @@ entitize(const char * str) /* export GPX */ -static void gpx_write_waypoint ( const gchar *name, VikWaypoint *wp, FILE *f ) +static void gpx_write_waypoint ( VikWaypoint *wp, GpxWritingContext *context ) { + // Don't write invisible waypoints when specified + if (context->options && !context->options->hidden && !wp->visible) + return; + + FILE *f = context->file; static struct LatLon ll; gchar *s_lat,*s_lon; gchar *tmp; vik_coord_to_latlon ( &(wp->coord), &ll ); s_lat = a_coords_dtostr( ll.lat ); s_lon = a_coords_dtostr( ll.lon ); + // NB 'hidden' is not part of any GPX standard - this appears to be a made up Viking 'extension' + // luckily most other GPX processing software ignores things they don't understand fprintf ( f, "\n", s_lat, s_lon, wp->visible ? "" : " hidden=\"hidden\"" ); g_free ( s_lat ); g_free ( s_lon ); - tmp = entitize ( name ); + // Sanity clause + if ( wp->name ) + tmp = entitize ( wp->name ); + else + tmp = g_strdup ("waypoint"); + fprintf ( f, " %s\n", tmp ); g_free ( tmp); @@ -563,9 +713,27 @@ static void gpx_write_waypoint ( const gchar *name, VikWaypoint *wp, FILE *f ) fprintf ( f, " %s\n", tmp ); g_free ( tmp ); } + + if ( wp->has_timestamp ) { + GTimeVal timestamp; + timestamp.tv_sec = wp->timestamp; + timestamp.tv_usec = 0; + + gchar *time_iso8601 = g_time_val_to_iso8601 ( ×tamp ); + if ( time_iso8601 != NULL ) + fprintf ( f, " \n", time_iso8601 ); + g_free ( time_iso8601 ); + } + if ( wp->comment ) { tmp = entitize(wp->comment); + fprintf ( f, " %s\n", tmp ); + g_free ( tmp ); + } + if ( wp->description ) + { + tmp = entitize(wp->description); fprintf ( f, " %s\n", tmp ); g_free ( tmp ); } @@ -578,69 +746,177 @@ static void gpx_write_waypoint ( const gchar *name, VikWaypoint *wp, FILE *f ) if ( wp->symbol ) { tmp = entitize(wp->symbol); - fprintf ( f, " %s\n", tmp); + if ( a_vik_gpx_export_wpt_sym_name ( ) ) { + // Lowercase the symbol name + gchar *tmp2 = g_utf8_strdown ( tmp, -1 ); + fprintf ( f, " %s\n", tmp2 ); + g_free ( tmp2 ); + } + else + fprintf ( f, " %s\n", tmp); g_free ( tmp ); } fprintf ( f, "\n" ); } -static void gpx_write_trackpoint ( VikTrackpoint *tp, FILE *f ) +static void gpx_write_trackpoint ( VikTrackpoint *tp, GpxWritingContext *context ) { + FILE *f = context->file; static struct LatLon ll; - gchar *s_lat,*s_lon, *s_alt; - static gchar time_buf[30]; + gchar *s_lat,*s_lon, *s_alt, *s_dop; + gchar *time_iso8601; vik_coord_to_latlon ( &(tp->coord), &ll ); - if ( tp->newsegment ) + // No such thing as a rteseg! So make sure we don't put them in + if ( context->options && !context->options->is_route && tp->newsegment ) fprintf ( f, " \n \n" ); s_lat = a_coords_dtostr( ll.lat ); s_lon = a_coords_dtostr( ll.lon ); - fprintf ( f, " \n", s_lat, s_lon ); - g_free ( s_lat ); - g_free ( s_lon ); + fprintf ( f, " <%spt lat=\"%s\" lon=\"%s\">\n", (context->options && context->options->is_route) ? "rte" : "trk", s_lat, s_lon ); + g_free ( s_lat ); s_lat = NULL; + g_free ( s_lon ); s_lon = NULL; + + if (tp->name) { + gchar *s_name = entitize(tp->name); + fprintf ( f, " %s\n", s_name ); + g_free(s_name); + } + s_alt = NULL; if ( tp->altitude != VIK_DEFAULT_ALTITUDE ) { s_alt = a_coords_dtostr ( tp->altitude ); - fprintf ( f, " %s\n", s_alt ); - g_free ( s_alt ); } + else if ( context->options != NULL && context->options->force_ele ) + { + s_alt = a_coords_dtostr ( 0 ); + } + if (s_alt != NULL) + fprintf ( f, " %s\n", s_alt ); + g_free ( s_alt ); s_alt = NULL; + + time_iso8601 = NULL; if ( tp->has_timestamp ) { - time_buf [ strftime ( time_buf, sizeof(time_buf)-1, GPX_TIME_FORMAT, localtime(&(tp->timestamp)) ) ] = '\0'; - fprintf ( f, " \n", time_buf ); + GTimeVal timestamp; + timestamp.tv_sec = tp->timestamp; + timestamp.tv_usec = 0; + + time_iso8601 = g_time_val_to_iso8601 ( ×tamp ); + } + else if ( context->options != NULL && context->options->force_time ) + { + GTimeVal current; + g_get_current_time ( ¤t ); + + time_iso8601 = g_time_val_to_iso8601 ( ¤t ); + } + if ( time_iso8601 != NULL ) + fprintf ( f, " \n", time_iso8601 ); + g_free(time_iso8601); + time_iso8601 = NULL; + + if (!isnan(tp->course)) { + gchar *s_course = a_coords_dtostr(tp->course); + fprintf ( f, " %s\n", s_course ); + g_free(s_course); + } + if (!isnan(tp->speed)) { + gchar *s_speed = a_coords_dtostr(tp->speed); + fprintf ( f, " %s\n", s_speed ); + g_free(s_speed); + } + if (tp->fix_mode == VIK_GPS_MODE_2D) + fprintf ( f, " 2d\n"); + if (tp->fix_mode == VIK_GPS_MODE_3D) + fprintf ( f, " 3d\n"); + if (tp->nsats > 0) + fprintf ( f, " %d\n", tp->nsats ); + + s_dop = NULL; + if ( tp->hdop != VIK_DEFAULT_DOP ) + { + s_dop = a_coords_dtostr ( tp->hdop ); + } + if (s_dop != NULL) + fprintf ( f, " %s\n", s_dop ); + g_free ( s_dop ); s_dop = NULL; + + if ( tp->vdop != VIK_DEFAULT_DOP ) + { + s_dop = a_coords_dtostr ( tp->vdop ); } - fprintf ( f, " \n" ); + if (s_dop != NULL) + fprintf ( f, " %s\n", s_dop ); + g_free ( s_dop ); s_dop = NULL; + + if ( tp->pdop != VIK_DEFAULT_DOP ) + { + s_dop = a_coords_dtostr ( tp->pdop ); + } + if (s_dop != NULL) + fprintf ( f, " %s\n", s_dop ); + g_free ( s_dop ); s_dop = NULL; + + fprintf ( f, " \n", (context->options && context->options->is_route) ? "rte" : "trk" ); } -static void gpx_write_track ( const gchar *name, VikTrack *t, FILE *f ) +static void gpx_write_track ( VikTrack *t, GpxWritingContext *context ) { + // Don't write invisible tracks when specified + if (context->options && !context->options->hidden && !t->visible) + return; + + FILE *f = context->file; gchar *tmp; gboolean first_tp_is_newsegment = FALSE; /* must temporarily make it not so, but we want to restore state. not that it matters. */ - tmp = entitize ( name ); - fprintf ( f, "\n %s\n", t->visible ? "" : " hidden=\"hidden\"", tmp ); + // Sanity clause + if ( t->name ) + tmp = entitize ( t->name ); + else + tmp = g_strdup ("track"); + + // NB 'hidden' is not part of any GPX standard - this appears to be a made up Viking 'extension' + // luckily most other GPX processing software ignores things they don't understand + fprintf ( f, "<%s%s>\n %s\n", + t->is_route ? "rte" : "trk", + t->visible ? "" : " hidden=\"hidden\"", + tmp ); g_free ( tmp ); if ( t->comment ) { tmp = entitize ( t->comment ); + fprintf ( f, " %s\n", tmp ); + g_free ( tmp ); + } + + if ( t->description ) + { + tmp = entitize ( t->description ); fprintf ( f, " %s\n", tmp ); g_free ( tmp ); } - fprintf ( f, " \n" ); + /* No such thing as a rteseg! */ + if ( !t->is_route ) + fprintf ( f, " \n" ); if ( t->trackpoints && t->trackpoints->data ) { first_tp_is_newsegment = VIK_TRACKPOINT(t->trackpoints->data)->newsegment; VIK_TRACKPOINT(t->trackpoints->data)->newsegment = FALSE; /* so we won't write already */ - g_list_foreach ( t->trackpoints, (GFunc) gpx_write_trackpoint, f ); + g_list_foreach ( t->trackpoints, (GFunc) gpx_write_trackpoint, context ); VIK_TRACKPOINT(t->trackpoints->data)->newsegment = first_tp_is_newsegment; /* restore state */ } - fprintf ( f, "\n\n" ); + /* NB apparently no such thing as a rteseg! */ + if (!t->is_route) + fprintf ( f, " \n"); + + fprintf ( f, "\n", t->is_route ? "rte" : "trk" ); } static void gpx_write_header( FILE *f ) @@ -657,17 +933,121 @@ static void gpx_write_footer( FILE *f ) fprintf(f, "\n"); } -void a_gpx_write_file( VikTrwLayer *vtl, FILE *f ) +static int gpx_waypoint_compare(const void *x, const void *y) { + VikWaypoint *a = (VikWaypoint *)x; + VikWaypoint *b = (VikWaypoint *)y; + return strcmp(a->name,b->name); +} + +static int gpx_track_compare_name(const void *x, const void *y) +{ + VikTrack *a = (VikTrack *)x; + VikTrack *b = (VikTrack *)y; + return strcmp(a->name,b->name); +} + +/* Function to compare two tracks by their first timestamp */ +static int gpx_track_compare_timestamp (const void *x, const void *y) +{ + VikTrack *a = (VikTrack *)x; + VikTrack *b = (VikTrack *)y; + + VikTrackpoint *tpa = NULL; + VikTrackpoint *tpb = NULL; + + if ( a->trackpoints ) + tpa = VIK_TRACKPOINT(g_list_first(a->trackpoints)->data); + + if ( b->trackpoints ) + tpb = VIK_TRACKPOINT(g_list_first(b->trackpoints)->data); + + if ( tpa && tpb ) { + if ( tpa->timestamp < tpb->timestamp ) + return -1; + if ( tpa->timestamp > tpb->timestamp ) + return 1; + } + + if ( tpa && !tpb ) + return 1; + + if ( !tpa && tpb ) + return -1; + + return 0; +} + +void a_gpx_write_file ( VikTrwLayer *vtl, FILE *f, GpxWritingOptions *options ) +{ + GpxWritingContext context = { options, f }; + gpx_write_header ( f ); - g_hash_table_foreach ( vik_trw_layer_get_waypoints ( vtl ), (GHFunc) gpx_write_waypoint, f ); - g_hash_table_foreach ( vik_trw_layer_get_tracks ( vtl ), (GHFunc) gpx_write_track, f ); + + // gather waypoints in a list, then sort + // g_hash_table_get_values: glib 2.14+ + GList *gl = g_hash_table_get_values ( vik_trw_layer_get_waypoints ( vtl ) ); + gl = g_list_sort ( gl, gpx_waypoint_compare ); + + GList *iter; + for (iter = g_list_first (gl); iter != NULL; iter = g_list_next (iter)) { + gpx_write_waypoint ( (VikWaypoint*)iter->data, &context ); + } + + g_list_free ( gl ); + + //gl = g_hash_table_get_values ( vik_trw_layer_get_tracks ( vtl ) ); + // Forming the list manually seems to produce one that is more likely to be nearer to the creation order + gl = NULL; + gpointer key, value; + GHashTableIter ght_iter; + g_hash_table_iter_init ( &ght_iter, vik_trw_layer_get_tracks ( vtl ) ); + while ( g_hash_table_iter_next (&ght_iter, &key, &value) ) { + gl = g_list_prepend ( gl ,value ); + } + gl = g_list_reverse ( gl ); + + // Sort method determined by preference + if ( a_vik_get_gpx_export_trk_sort() == VIK_GPX_EXPORT_TRK_SORT_TIME ) + gl = g_list_sort ( gl, gpx_track_compare_timestamp ); + else if ( a_vik_get_gpx_export_trk_sort() == VIK_GPX_EXPORT_TRK_SORT_ALPHA ) + gl = g_list_sort ( gl, gpx_track_compare_name ); + + // Routes sorted by name + GList *glrte = g_hash_table_get_values ( vik_trw_layer_get_routes ( vtl ) ); + glrte = g_list_sort ( glrte, gpx_track_compare_name ); + + // g_list_concat doesn't copy memory properly + // so process each list separately + + GpxWritingContext context_tmp = context; + GpxWritingOptions opt_tmp = { FALSE, FALSE, FALSE }; + // Force trackpoints on tracks + if ( !context.options ) + context_tmp.options = &opt_tmp; + context_tmp.options->is_route = FALSE; + + // Loop around each list and write each one + for (iter = g_list_first (gl); iter != NULL; iter = g_list_next (iter)) { + gpx_write_track ( (VikTrack*)iter->data, &context_tmp ); + } + + // Routes (to get routepoints) + context_tmp.options->is_route = TRUE; + for (iter = g_list_first (glrte); iter != NULL; iter = g_list_next (iter)) { + gpx_write_track ( (VikTrack*)iter->data, &context_tmp ); + } + + g_list_free ( gl ); + g_list_free ( glrte ); + gpx_write_footer ( f ); } -void a_gpx_write_track_file ( const gchar *name, VikTrack *t, FILE *f ) +void a_gpx_write_track_file ( VikTrack *trk, FILE *f, GpxWritingOptions *options ) { + GpxWritingContext context = {options, f}; gpx_write_header ( f ); - gpx_write_track ( name, t, f ); + gpx_write_track ( trk, &context ); gpx_write_footer ( f ); }