Prevent the program grinding to a halt if trying to deal with thousands of tiles

[andy/viking.git] / src / gpx.c

diff --git a/src/gpx.c b/src/gpx.c
index f030d6c0cec4d35ea72ffdf9865163df1f3efd0f..7892b2006365b88a498c15b69f82f6b65c3084ea 100644 (file)
--- a/src/gpx.c
+++ b/src/gpx.c
@@ -1,7 +1,11 @@
 /*
  * viking -- GPS Data and Topo Analyzer, Explorer, and Manager
  *
 /*
  * viking -- GPS Data and Topo Analyzer, Explorer, and Manager
  *

- * Copyright (C) 2003-2005, Evan Battaglia <gtoevan@gmx.net>
+ * Copyright (C) 2003-2007, Evan Battaglia <gtoevan@gmx.net>
+ * Copyright (C) 2007, Quy Tonthat <qtonthat@gmail.com>
+ * Copyright (C) 2008, Hein Ragas <viking@ragas.nl>
+ * Copyright (C) 2009, Tal B <tal.bav@gmail.com>
+ * Copyright (c) 2012, Rob Norris <rw_norris@hotmail.com>

  *
  * Some of the code adapted from GPSBabel 1.2.7
  * http://gpsbabel.sf.net/
  *
  * Some of the code adapted from GPSBabel 1.2.7
  * http://gpsbabel.sf.net/


@@ -22,15 +26,23 @@
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  *
  */
  * 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 */
 
 
 #define _XOPEN_SOURCE /* glibc2 needs this */
 

+#include "gpx.h"

 #include "viking.h"
 #include <expat.h>
 #include "viking.h"
 #include <expat.h>

+#ifdef HAVE_STRING_H

 #include <string.h>
 #include <string.h>

-
-#define GPX_TIME_FORMAT "%Y-%m-%dT%H:%M:%SZ"
+#endif
+#include <glib.h>
+#ifdef HAVE_MATH_H
+#include <math.h>
+#endif
+#include <time.h>

 
 typedef enum {
         tt_unknown = 0,
 
 typedef enum {
         tt_unknown = 0,


@@ -38,6 +50,7 @@ typedef enum {
         tt_gpx,
 
         tt_wpt,
         tt_gpx,
 
         tt_wpt,

+        tt_wpt_cmt,

         tt_wpt_desc,
         tt_wpt_name,
         tt_wpt_ele,
         tt_wpt_desc,
         tt_wpt_name,
         tt_wpt_ele,


@@ -45,13 +58,25 @@ typedef enum {
         tt_wpt_link,            /* New in GPX 1.1 */
 
         tt_trk,
         tt_wpt_link,            /* New in GPX 1.1 */
 
         tt_trk,

+        tt_trk_cmt,

         tt_trk_desc,
         tt_trk_name,
 
         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,
         tt_trk_trkseg_trkpt,
         tt_trk_trkseg_trkpt_ele,
         tt_trk_trkseg_trkpt_time,

+       /* 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,
 
         tt_waypoint,
         tt_waypoint_coord,


@@ -63,6 +88,11 @@ typedef struct tag_mapping {
         const char *tag_name;           /* xpath-ish tag name */
 } 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.
 /*
  * xpath(ish) mappings between full tag paths and internal identifers.
  * These appear in the order they appear in the GPX specification.


@@ -79,20 +109,37 @@ tag_mapping tag_path_map[] = {
 
         { tt_wpt_ele, "/gpx/wpt/ele" },
         { tt_wpt_name, "/gpx/wpt/name" },
 
         { tt_wpt_ele, "/gpx/wpt/ele" },
         { 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_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_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_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_ele, "/gpx/trk/trkseg/trkpt/ele" },
         { tt_trk_trkseg_trkpt_time, "/gpx/trk/trkseg/trkpt/time" },

+       /* 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_ele, "/gpx/rte/rtept/ele" },

 
         {0}
 };
 
         {0}
 };


@@ -143,8 +190,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" )) ) {
 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;
     return TRUE;
   }
   return FALSE;


@@ -163,18 +210,21 @@ 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 ();
      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:
 
          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 ();
        c_tr = vik_track_new ();

-       if ( ! get_attr ( attr, "hidden" ) )
-         c_tr->visible = TRUE;
+       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:
        break;
 
      case tt_trk_trkseg:


@@ -184,7 +234,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 ();
      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;
          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,10 +245,12 @@ static void gpx_start(VikTrwLayer *vtl, const char *el, const char **attr)
 
      case tt_trk_trkseg_trkpt_ele:
      case tt_trk_trkseg_trkpt_time:
 
      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_link:
      case tt_wpt_desc:
      case tt_wpt_name:
      case tt_wpt_ele:
      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 */
      case tt_trk_desc:
      case tt_trk_name:
        g_string_erase ( c_cdata, 0, -1 ); /* clear the cdata buffer */


@@ -207,7 +258,6 @@ static void gpx_start(VikTrwLayer *vtl, const char *el, const char **attr)
 
      case tt_waypoint:
        c_wp = vik_waypoint_new ();
 
      case tt_waypoint:
        c_wp = vik_waypoint_new ();

-       c_wp->altitude = VIK_DEFAULT_ALTITUDE;

        c_wp->visible = TRUE;
        break;
 
        c_wp->visible = TRUE;
        break;
 


@@ -231,7 +281,8 @@ static void gpx_start(VikTrwLayer *vtl, const char *el, const char **attr)
 
 static void gpx_end(VikTrwLayer *vtl, const char *el)
 {
 
 static void gpx_end(VikTrwLayer *vtl, const char *el)
 {

-  static struct tm tm;
+  static GTimeVal tp_time;
+

   g_string_truncate ( xpath, xpath->len - strlen(el) - 1 );
 
   switch ( current_tag ) {
   g_string_truncate ( xpath, xpath->len - strlen(el) - 1 );
 
   switch ( current_tag ) {


@@ -240,15 +291,18 @@ static void gpx_end(VikTrwLayer *vtl, const char *el)
      case tt_wpt:
        if ( ! c_wp_name )
          c_wp_name = g_strdup_printf("VIKING_WP%d", unnamed_waypoints++);
      case tt_wpt:
        if ( ! c_wp_name )
          c_wp_name = g_strdup_printf("VIKING_WP%d", unnamed_waypoints++);

-       g_hash_table_insert ( vik_trw_layer_get_waypoints ( vtl ), c_wp_name, c_wp );
+       vik_trw_layer_filein_add_waypoint ( vtl, c_wp_name, c_wp );
+       g_free ( c_wp_name );

        c_wp = NULL;
        c_wp_name = NULL;
        break;
 
      case tt_trk:
        c_wp = NULL;
        c_wp_name = NULL;
        break;
 
      case tt_trk:

+     case tt_rte:

        if ( ! c_tr_name )
        if ( ! c_tr_name )

-         c_tr_name = g_strdup_printf("VIKING_TR%d", unnamed_waypoints++);
-       g_hash_table_insert ( vik_trw_layer_get_tracks ( vtl ), c_tr_name, c_tr );
+         c_tr_name = g_strdup_printf("VIKING_TR%d", unnamed_tracks++);
+       vik_trw_layer_filein_add_track ( vtl, c_tr_name, c_tr );
+       g_free ( c_tr_name );

        c_tr = NULL;
        c_tr_name = NULL;
        break;
        c_tr = NULL;
        c_tr_name = NULL;
        break;


@@ -268,17 +322,22 @@ static void gpx_end(VikTrwLayer *vtl, const char *el)
        break;
 
      case tt_wpt_ele:
        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:
        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:
        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;
        vik_waypoint_set_comment ( c_wp, c_cdata->str );
        g_string_erase ( c_cdata, 0, -1 );
        break;


@@ -288,24 +347,72 @@ static void gpx_end(VikTrwLayer *vtl, const char *el)
        g_string_erase ( c_cdata, 0, -1 );
        break;
 
        g_string_erase ( c_cdata, 0, -1 );
        break;
 

-     case tt_wpt_sym:
-       vik_waypoint_set_symbol ( c_wp, c_cdata->str );
+     case tt_wpt_sym: {
+       gchar *tmp_lower = g_utf8_strdown(c_cdata->str, -1); /* for things like <type>Geocache</type> */
+       vik_waypoint_set_symbol ( c_wp, tmp_lower );
+       g_free ( tmp_lower );

        g_string_erase ( c_cdata, 0, -1 );
        break;
        g_string_erase ( c_cdata, 0, -1 );
        break;

+       }

 
      case tt_trk_desc:
 
      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:
        vik_track_set_comment ( c_tr, c_cdata->str );
        g_string_erase ( c_cdata, 0, -1 );
        break;
 
      case tt_trk_trkseg_trkpt_time:

-       if ( strptime(c_cdata->str, GPX_TIME_FORMAT, &tm) != c_cdata->str ) { /* it read at least one char */
-         c_tp->timestamp = mktime(&tm);
+       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;
 
          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;
   }
 
      default: break;
   }
 


@@ -319,11 +426,20 @@ 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_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_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_trk_desc:
     case tt_trk_trkseg_trkpt_time:

+    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;
     case tt_waypoint_name: /* .loc name is really description. */
       g_string_append_len ( c_cdata, s, len );
       break;


@@ -335,9 +451,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
 
 // 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;
   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 */
 
   XML_SetElementHandler(parser, (XML_StartElementHandler) gpx_start, (XML_EndElementHandler) gpx_end);
   XML_SetUserData(parser, vtl); /* in the future we could remove all global variables */


@@ -356,11 +473,14 @@ void a_gpx_read_file( VikTrwLayer *vtl, FILE *f ) {
   while (!done) {
     len = fread(buf, 1, sizeof(buf)-7, f);
     done = feof(f) || !len;
   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 );
   g_string_free ( xpath, TRUE );
   g_string_free ( c_cdata, TRUE );

+
+  return status != XML_STATUS_ERROR;

 }
 
 /**** entitize from GPSBabel ****/
 }
 
 /**** entitize from GPSBabel ****/


@@ -531,23 +651,51 @@ entitize(const char * str)
 /**** end GPSBabel code ****/
 
 /* export GPX */
 /**** end GPSBabel code ****/
 
 /* 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;
   static struct LatLon ll;

+  gchar *s_lat,*s_lon;

   gchar *tmp;
   vik_coord_to_latlon ( &(wp->coord), &ll );
   gchar *tmp;
   vik_coord_to_latlon ( &(wp->coord), &ll );

-  fprintf ( f, "<wpt lat=\"%f\" lon=\"%f\"%s>\n",
-               ll.lat, ll.lon, wp->visible ? "" : " hidden=\"hidden\"" );
+  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, "<wpt lat=\"%s\" lon=\"%s\"%s>\n",
+               s_lat, s_lon, wp->visible ? "" : " hidden=\"hidden\"" );
+  g_free ( s_lat );
+  g_free ( s_lon );
+
+  // Sanity clause
+  if ( wp->name )
+    tmp = entitize ( wp->name );
+  else
+    tmp = g_strdup ("waypoint");

 
 

-  tmp = entitize ( name );

   fprintf ( f, "  <name>%s</name>\n", tmp );
   g_free ( tmp);
 
   if ( wp->altitude != VIK_DEFAULT_ALTITUDE )
   fprintf ( f, "  <name>%s</name>\n", tmp );
   g_free ( tmp);
 
   if ( wp->altitude != VIK_DEFAULT_ALTITUDE )

-    fprintf ( f, "  <ele>%f</ele>\n", wp->altitude );
+  {
+    tmp = a_coords_dtostr ( wp->altitude );
+    fprintf ( f, "  <ele>%s</ele>\n", tmp );
+    g_free ( tmp );
+  }

   if ( wp->comment )
   {
     tmp = entitize(wp->comment);
   if ( wp->comment )
   {
     tmp = entitize(wp->comment);

+    fprintf ( f, "  <cmt>%s</cmt>\n", tmp );
+    g_free ( tmp );
+  }
+  if ( wp->description )
+  {
+    tmp = entitize(wp->description);

     fprintf ( f, "  <desc>%s</desc>\n", tmp );
     g_free ( tmp );
   }
     fprintf ( f, "  <desc>%s</desc>\n", tmp );
     g_free ( tmp );
   }


@@ -567,66 +715,278 @@ static void gpx_write_waypoint ( const gchar *name, VikWaypoint *wp, FILE *f )
   fprintf ( f, "</wpt>\n" );
 }
 
   fprintf ( f, "</wpt>\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;
   static struct LatLon ll;

-  static gchar time_buf[30];
+  gchar *s_lat,*s_lon, *s_alt, *s_dop;
+  gchar *time_iso8601;

   vik_coord_to_latlon ( &(tp->coord), &ll );
 
   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, "  </trkseg>\n  <trkseg>\n" );
 
     fprintf ( f, "  </trkseg>\n  <trkseg>\n" );
 

-  fprintf ( f, "  <trkpt lat=\"%f\" lon=\"%f\">\n", ll.lat, ll.lon );
+  s_lat = a_coords_dtostr( ll.lat );
+  s_lon = a_coords_dtostr( ll.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;

 
 

+  s_alt = NULL;

   if ( tp->altitude != VIK_DEFAULT_ALTITUDE )
   if ( tp->altitude != VIK_DEFAULT_ALTITUDE )

-    fprintf ( f, "    <ele>%f</ele>\n", tp->altitude );
+  {
+    s_alt = a_coords_dtostr ( tp->altitude );
+  }
+  else if ( context->options != NULL && context->options->force_ele )
+  {
+    s_alt = a_coords_dtostr ( 0 );
+  }
+  if (s_alt != NULL)
+    fprintf ( f, "    <ele>%s</ele>\n", s_alt );
+  g_free ( s_alt ); s_alt = NULL;
+  
+  time_iso8601 = NULL;

   if ( tp->has_timestamp ) {
   if ( tp->has_timestamp ) {

-    time_buf [ strftime ( time_buf, sizeof(time_buf)-1, GPX_TIME_FORMAT, localtime(&(tp->timestamp)) ) ] = '\0';
-    fprintf ( f, "    <time>%s</time>\n", time_buf );
+    GTimeVal timestamp;
+    timestamp.tv_sec = tp->timestamp;
+    timestamp.tv_usec = 0;
+  
+    time_iso8601 = g_time_val_to_iso8601 ( &timestamp );
+  }
+  else if ( context->options != NULL && context->options->force_time )
+  {
+    GTimeVal current;
+    g_get_current_time ( &current );
+  
+    time_iso8601 = g_time_val_to_iso8601 ( &current );
+  }
+  if ( time_iso8601 != NULL )
+    fprintf ( f, "    <time>%s</time>\n", time_iso8601 );
+  g_free(time_iso8601);
+  time_iso8601 = NULL;
+  
+  if (!isnan(tp->course)) {
+    gchar *s_course = a_coords_dtostr(tp->course);
+    fprintf ( f, "    <course>%s</course>\n", s_course );
+    g_free(s_course);
+  }
+  if (!isnan(tp->speed)) {
+    gchar *s_speed = a_coords_dtostr(tp->speed);
+    fprintf ( f, "    <speed>%s</speed>\n", s_speed );
+    g_free(s_speed);
+  }
+  if (tp->fix_mode == VIK_GPS_MODE_2D)
+    fprintf ( f, "    <fix>2d</fix>\n");
+  if (tp->fix_mode == VIK_GPS_MODE_3D)
+    fprintf ( f, "    <fix>3d</fix>\n");
+  if (tp->nsats > 0)
+    fprintf ( f, "    <sat>%d</sat>\n", tp->nsats );
+
+  s_dop = NULL;
+  if ( tp->hdop != VIK_DEFAULT_DOP )
+  {
+    s_dop = a_coords_dtostr ( tp->hdop );

   }
   }

-  fprintf ( f, "  </trkpt>\n" );
+  if (s_dop != NULL)
+    fprintf ( f, "    <hdop>%s</hdop>\n", s_dop );
+  g_free ( s_dop ); s_dop = NULL;
+
+  if ( tp->vdop != VIK_DEFAULT_DOP )
+  {
+    s_dop = a_coords_dtostr ( tp->vdop );
+  }
+  if (s_dop != NULL)
+    fprintf ( f, "    <vdop>%s</vdop>\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, "    <pdop>%s</pdop>\n", s_dop );
+  g_free ( s_dop ); s_dop = NULL;
+
+  fprintf ( f, "  </%spt>\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 )

 {
 {

-  gchar *tmp;
-  gboolean first_tp_is_newsegment; /* must temporarily make it not so, but we want to restore state. not that it matters. */
+  // Don't write invisible tracks when specified
+  if (context->options && !context->options->hidden && !t->visible)
+    return;

 
 

-  tmp = entitize ( name );
-  fprintf ( f, "<trk%s>\n  <name>%s</name>\n", t->visible ? "" : " hidden=\"hidden\"", tmp );
+  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. */
+
+  // 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  <name>%s</name>\n",
+           t->is_route ? "rte" : "trk",
+           t->visible ? "" : " hidden=\"hidden\"",
+           tmp );

   g_free ( tmp );
 
   if ( t->comment )
   {
     tmp = entitize ( t->comment );
   g_free ( tmp );
 
   if ( t->comment )
   {
     tmp = entitize ( t->comment );

+    fprintf ( f, "  <cmt>%s</cmt>\n", tmp );
+    g_free ( tmp );
+  }
+
+  if ( t->description )
+  {
+    tmp = entitize ( t->description );

     fprintf ( f, "  <desc>%s</desc>\n", tmp );
     g_free ( tmp );
   }
 
     fprintf ( f, "  <desc>%s</desc>\n", tmp );
     g_free ( tmp );
   }
 

-  fprintf ( f, "  <trkseg>\n" );
+  /* No such thing as a rteseg! */
+  if ( !t->is_route )
+    fprintf ( f, "  <trkseg>\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 </trkseg><trkseg> already */
 
   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 </trkseg><trkseg> already */

-  }
-  g_list_foreach ( t->trackpoints, (GFunc) gpx_write_trackpoint, f );
-  if ( t->trackpoints && t->trackpoints->data )
+    g_list_foreach ( t->trackpoints, (GFunc) gpx_write_trackpoint, context );

     VIK_TRACKPOINT(t->trackpoints->data)->newsegment = first_tp_is_newsegment; /* restore state */
     VIK_TRACKPOINT(t->trackpoints->data)->newsegment = first_tp_is_newsegment; /* restore state */

+  }
+
+  /* NB apparently no such thing as a rteseg! */
+  if (!t->is_route)
+    fprintf ( f, "  </trkseg>\n");

 
 

-  fprintf ( f, "</trkseg>\n</trk>\n" );
+  fprintf ( f, "</%s>\n", t->is_route ? "rte" : "trk" );

 }
 
 }
 

-void a_gpx_write_file( VikTrwLayer *vtl, FILE *f )
+static void gpx_write_header( FILE *f )

 {
   fprintf(f, "<?xml version=\"1.0\"?>\n"
           "<gpx version=\"1.0\" creator=\"Viking -- http://viking.sf.net/\"\n"
           "xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"\n"
           "xmlns=\"http://www.topografix.com/GPX/1/0\"\n"
           "xsi:schemaLocation=\"http://www.topografix.com/GPX/1/0 http://www.topografix.com/GPX/1/0/gpx.xsd\">\n");
 {
   fprintf(f, "<?xml version=\"1.0\"?>\n"
           "<gpx version=\"1.0\" creator=\"Viking -- http://viking.sf.net/\"\n"
           "xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"\n"
           "xmlns=\"http://www.topografix.com/GPX/1/0\"\n"
           "xsi:schemaLocation=\"http://www.topografix.com/GPX/1/0 http://www.topografix.com/GPX/1/0/gpx.xsd\">\n");

-  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 );
+}
+
+static void gpx_write_footer( FILE *f )
+{

   fprintf(f, "</gpx>\n");
   fprintf(f, "</gpx>\n");

+}
+
+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 );
+
+  // 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 ) );
+  // 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
+    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 ( VikTrack *trk, FILE *f, GpxWritingOptions *options )
+{
+  GpxWritingContext context = {options, f};
+  gpx_write_header ( f );
+  gpx_write_track ( trk, &context );
+  gpx_write_footer ( f );

 }
 }