]> git.street.me.uk Git - andy/viking.git/blobdiff - src/vikgpslayer.c
projects / andy / viking.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Fix right click on a selected waypoint image starts to move it.
[andy/viking.git] / src / vikgpslayer.c
diff --git a/src/vikgpslayer.c b/src/vikgpslayer.c
index 439005cf164f969d4e05471312dfb584c79e1b94..207f487f42974071117ca8aff9e398226d6409ef 100644 (file)
--- a/src/vikgpslayer.c
+++ b/src/vikgpslayer.c
@@ -43,19 +43,13 @@
 #include <glib/gi18n.h>
 #ifdef VIK_CONFIG_REALTIME_GPS_TRACKING
 #include <gps.h>
 #include <glib/gi18n.h>
 #ifdef VIK_CONFIG_REALTIME_GPS_TRACKING
 #include <gps.h>
+#include "vikutils.h"
 #endif
 
 #endif
 
-#if ! GLIB_CHECK_VERSION(2,14,0)
-inline guint g_timeout_add_seconds(guint interval, GSourceFunc function, gpointer data) {
-  return g_timeout_add(interval*1000, function, data);
-}
-#endif
-
-#define DISCONNECT_UPDATE_SIGNAL(vl, val) g_signal_handlers_disconnect_matched(vl, G_SIGNAL_MATCH_DATA, 0, 0, 0, 0, val)
 static VikGpsLayer *vik_gps_layer_create (VikViewport *vp);
 static void vik_gps_layer_realize ( VikGpsLayer *val, VikTreeview *vt, GtkTreeIter *layer_iter );
 static void vik_gps_layer_free ( VikGpsLayer *val );
 static VikGpsLayer *vik_gps_layer_create (VikViewport *vp);
 static void vik_gps_layer_realize ( VikGpsLayer *val, VikTreeview *vt, GtkTreeIter *layer_iter );
 static void vik_gps_layer_free ( VikGpsLayer *val );
-static void vik_gps_layer_draw ( VikGpsLayer *val, gpointer data );
+static void vik_gps_layer_draw ( VikGpsLayer *val, VikViewport *vp );
 static VikGpsLayer *vik_gps_layer_new ( VikViewport *vp );
 
 static void gps_layer_marshall( VikGpsLayer *val, guint8 **data, gint *len );
 static VikGpsLayer *vik_gps_layer_new ( VikViewport *vp );
 
 static void gps_layer_marshall( VikGpsLayer *val, guint8 **data, gint *len );
@@ -67,7 +61,6 @@ static const gchar* gps_layer_tooltip ( VikGpsLayer *vgl );
 
 static void gps_layer_change_coord_mode ( VikGpsLayer *val, VikCoordMode mode );
 static void gps_layer_add_menu_items( VikGpsLayer *vtl, GtkMenu *menu, gpointer vlp );
 
 static void gps_layer_change_coord_mode ( VikGpsLayer *val, VikCoordMode mode );
 static void gps_layer_add_menu_items( VikGpsLayer *vtl, GtkMenu *menu, gpointer vlp );
-static void gps_layer_drag_drop_request ( VikGpsLayer *val_src, VikGpsLayer *val_dest, GtkTreeIter *src_item_iter, GtkTreePath *dest_path );
 
 static void gps_upload_cb( gpointer layer_and_vlp[2] );
 static void gps_download_cb( gpointer layer_and_vlp[2] );
 
 static void gps_upload_cb( gpointer layer_and_vlp[2] );
 static void gps_download_cb( gpointer layer_and_vlp[2] );
@@ -118,8 +111,10 @@ typedef struct {
   GtkWidget *ver_label;
   GtkWidget *id_label;
   GtkWidget *wp_label;
   GtkWidget *ver_label;
   GtkWidget *id_label;
   GtkWidget *wp_label;
-  GtkWidget *progress_label;
   GtkWidget *trk_label;
   GtkWidget *trk_label;
+  GtkWidget *rte_label;
+  GtkWidget *progress_label;
+  vik_gps_xfer_type progress_type;
   VikViewport *vvp;
 #if defined (VIK_CONFIG_REALTIME_GPS_TRACKING) && defined (GPSD_API_MAJOR_VERSION)
   gboolean realtime_tracking;
   VikViewport *vvp;
 #if defined (VIK_CONFIG_REALTIME_GPS_TRACKING) && defined (GPSD_API_MAJOR_VERSION)
   gboolean realtime_tracking;
@@ -128,19 +123,48 @@ typedef struct {
 static void gps_session_delete(GpsSession *sess);
 
 static gchar *params_groups[] = {
 static void gps_session_delete(GpsSession *sess);
 
 static gchar *params_groups[] = {
-  "Data Mode",
+  N_("Data Mode"),
 #if defined (VIK_CONFIG_REALTIME_GPS_TRACKING) && defined (GPSD_API_MAJOR_VERSION)
 #if defined (VIK_CONFIG_REALTIME_GPS_TRACKING) && defined (GPSD_API_MAJOR_VERSION)
-  "Realtime Tracking Mode",
+  N_("Realtime Tracking Mode"),
 #endif
 };
 
 enum {GROUP_DATA_MODE, GROUP_REALTIME_MODE};
 
 #endif
 };
 
 enum {GROUP_DATA_MODE, GROUP_REALTIME_MODE};
 
+
+static VikLayerParamData gps_protocol_default ( void )
+{
+  VikLayerParamData data;
+  data.s = g_strdup ( "garmin" );
+  return data;
+}
+
+static VikLayerParamData gps_port_default ( void )
+{
+  VikLayerParamData data;
+  data.s = g_strdup ( "usb:" );
+#ifndef WINDOWS
+  /* Attempt to auto set default USB serial port entry */
+  /* Ordered to make lowest device favourite if available */
+  if (g_access ("/dev/ttyUSB1", R_OK) == 0) {
+       if ( data.s )
+         g_free ( (gchar *)data.s );
+    data.s = g_strdup ("/dev/ttyUSB1");
+  }
+  if (g_access ("/dev/ttyUSB0", R_OK) == 0) {
+       if ( data.s )
+         g_free ( (gchar *)data.s );
+    data.s = g_strdup ("/dev/ttyUSB0");
+  }
+#endif
+  return data;
+}
+
 #if defined (VIK_CONFIG_REALTIME_GPS_TRACKING) && defined (GPSD_API_MAJOR_VERSION)
 static gchar *params_vehicle_position[] = {
 #if defined (VIK_CONFIG_REALTIME_GPS_TRACKING) && defined (GPSD_API_MAJOR_VERSION)
 static gchar *params_vehicle_position[] = {
-  "Keep vehicle at center",
-  "Keep vehicle on screen",
-  "Disable",
+  N_("Keep vehicle at center"),
+  N_("Keep vehicle on screen"),
+  N_("Disable"),
   NULL
 };
 enum {
   NULL
 };
 enum {
@@ -148,34 +172,72 @@ enum {
   VEHICLE_POSITION_ON_SCREEN,
   VEHICLE_POSITION_NONE,
 };
   VEHICLE_POSITION_ON_SCREEN,
   VEHICLE_POSITION_NONE,
 };
+
+static VikLayerParamData moving_map_method_default ( void ) { return VIK_LPD_UINT ( VEHICLE_POSITION_ON_SCREEN ); }
+
+static VikLayerParamData gpsd_host_default ( void )
+{
+  VikLayerParamData data;
+  data.s = g_strdup ( "localhost" );
+  return data;
+}
+
+static VikLayerParamData gpsd_port_default ( void )
+{
+  VikLayerParamData data;
+  data.s = g_strdup ( DEFAULT_GPSD_PORT );
+  return data;
+}
+
+static VikLayerParamData gpsd_retry_interval_default ( void )
+{
+  VikLayerParamData data;
+  data.s = g_strdup ( "10" );
+  return data;
+}
+
 #endif
 
 static VikLayerParam gps_layer_params[] = {
 #endif
 
 static VikLayerParam gps_layer_params[] = {
-  { "gps_protocol", VIK_LAYER_PARAM_STRING, GROUP_DATA_MODE, N_("GPS Protocol:"), VIK_LAYER_WIDGET_COMBOBOX, NULL, NULL}, // List now assigned at runtime
-  { "gps_port", VIK_LAYER_PARAM_STRING, GROUP_DATA_MODE, N_("Serial Port:"), VIK_LAYER_WIDGET_COMBOBOX, params_ports, NULL},
-  { "gps_download_tracks", VIK_LAYER_PARAM_BOOLEAN, GROUP_DATA_MODE, N_("Download Tracks:"), VIK_LAYER_WIDGET_CHECKBUTTON, NULL, NULL},
-  { "gps_upload_tracks", VIK_LAYER_PARAM_BOOLEAN, GROUP_DATA_MODE, N_("Upload Tracks:"), VIK_LAYER_WIDGET_CHECKBUTTON, NULL, NULL},
-  { "gps_download_waypoints", VIK_LAYER_PARAM_BOOLEAN, GROUP_DATA_MODE, N_("Download Waypoints:"), VIK_LAYER_WIDGET_CHECKBUTTON, NULL, NULL},
-  { "gps_upload_waypoints", VIK_LAYER_PARAM_BOOLEAN, GROUP_DATA_MODE, N_("Upload Waypoints:"), VIK_LAYER_WIDGET_CHECKBUTTON, NULL, NULL},
+ //    NB gps_layer_inst_init() is performed after parameter registeration
+ //  thus to give the protocols some potential values use the old static list
+ // TODO: find another way to use gps_layer_inst_init()?
+  { VIK_LAYER_GPS, "gps_protocol", VIK_LAYER_PARAM_STRING, GROUP_DATA_MODE, N_("GPS Protocol:"), VIK_LAYER_WIDGET_COMBOBOX, protocols_args, NULL, NULL, gps_protocol_default, NULL, NULL }, // List reassigned at runtime
+  { VIK_LAYER_GPS, "gps_port", VIK_LAYER_PARAM_STRING, GROUP_DATA_MODE, N_("Serial Port:"), VIK_LAYER_WIDGET_COMBOBOX, params_ports, NULL, NULL, gps_port_default, NULL, NULL },
+  { VIK_LAYER_GPS, "gps_download_tracks", VIK_LAYER_PARAM_BOOLEAN, GROUP_DATA_MODE, N_("Download Tracks:"), VIK_LAYER_WIDGET_CHECKBUTTON, NULL, NULL, NULL, vik_lpd_true_default, NULL, NULL },
+  { VIK_LAYER_GPS, "gps_upload_tracks", VIK_LAYER_PARAM_BOOLEAN, GROUP_DATA_MODE, N_("Upload Tracks:"), VIK_LAYER_WIDGET_CHECKBUTTON, NULL, NULL, NULL, vik_lpd_true_default, NULL, NULL },
+  { VIK_LAYER_GPS, "gps_download_routes", VIK_LAYER_PARAM_BOOLEAN, GROUP_DATA_MODE, N_("Download Routes:"), VIK_LAYER_WIDGET_CHECKBUTTON, NULL, NULL, NULL, vik_lpd_true_default, NULL, NULL },
+  { VIK_LAYER_GPS, "gps_upload_routes", VIK_LAYER_PARAM_BOOLEAN, GROUP_DATA_MODE, N_("Upload Routes:"), VIK_LAYER_WIDGET_CHECKBUTTON, NULL, NULL, NULL, vik_lpd_true_default, NULL, NULL },
+  { VIK_LAYER_GPS, "gps_download_waypoints", VIK_LAYER_PARAM_BOOLEAN, GROUP_DATA_MODE, N_("Download Waypoints:"), VIK_LAYER_WIDGET_CHECKBUTTON, NULL, NULL, NULL, vik_lpd_true_default, NULL, NULL },
+  { VIK_LAYER_GPS, "gps_upload_waypoints", VIK_LAYER_PARAM_BOOLEAN, GROUP_DATA_MODE, N_("Upload Waypoints:"), VIK_LAYER_WIDGET_CHECKBUTTON, NULL, NULL, NULL, vik_lpd_true_default, NULL, NULL },
 #if defined (VIK_CONFIG_REALTIME_GPS_TRACKING) && defined (GPSD_API_MAJOR_VERSION)
 #if defined (VIK_CONFIG_REALTIME_GPS_TRACKING) && defined (GPSD_API_MAJOR_VERSION)
-  { "record_tracking", VIK_LAYER_PARAM_BOOLEAN, GROUP_REALTIME_MODE, N_("Recording tracks"), VIK_LAYER_WIDGET_CHECKBUTTON},
-  { "center_start_tracking", VIK_LAYER_PARAM_BOOLEAN, GROUP_REALTIME_MODE, N_("Jump to current position on start"), VIK_LAYER_WIDGET_CHECKBUTTON},
-  { "moving_map_method", VIK_LAYER_PARAM_UINT, GROUP_REALTIME_MODE, N_("Moving Map Method:"), VIK_LAYER_WIDGET_RADIOGROUP_STATIC, params_vehicle_position, NULL},
-  { "gpsd_host", VIK_LAYER_PARAM_STRING, GROUP_REALTIME_MODE, N_("Gpsd Host:"), VIK_LAYER_WIDGET_ENTRY},
-  { "gpsd_port", VIK_LAYER_PARAM_STRING, GROUP_REALTIME_MODE, N_("Gpsd Port:"), VIK_LAYER_WIDGET_ENTRY},
-  { "gpsd_retry_interval", VIK_LAYER_PARAM_STRING, GROUP_REALTIME_MODE, N_("Gpsd Retry Interval (seconds):"), VIK_LAYER_WIDGET_ENTRY},
+  { VIK_LAYER_GPS, "record_tracking", VIK_LAYER_PARAM_BOOLEAN, GROUP_REALTIME_MODE, N_("Recording tracks"), VIK_LAYER_WIDGET_CHECKBUTTON, NULL, NULL, NULL, vik_lpd_true_default, NULL, NULL },
+  { VIK_LAYER_GPS, "center_start_tracking", VIK_LAYER_PARAM_BOOLEAN, GROUP_REALTIME_MODE, N_("Jump to current position on start"), VIK_LAYER_WIDGET_CHECKBUTTON, NULL, NULL, NULL, vik_lpd_false_default, NULL, NULL },
+  { VIK_LAYER_GPS, "moving_map_method", VIK_LAYER_PARAM_UINT, GROUP_REALTIME_MODE, N_("Moving Map Method:"), VIK_LAYER_WIDGET_RADIOGROUP_STATIC, params_vehicle_position, NULL, NULL, moving_map_method_default, NULL, NULL },
+  { VIK_LAYER_GPS, "realtime_update_statusbar", VIK_LAYER_PARAM_BOOLEAN, GROUP_REALTIME_MODE, N_("Update Statusbar:"), VIK_LAYER_WIDGET_CHECKBUTTON, NULL, NULL, N_("Display information in the statusbar on GPS updates"), vik_lpd_true_default, NULL, NULL },
+  { VIK_LAYER_GPS, "gpsd_host", VIK_LAYER_PARAM_STRING, GROUP_REALTIME_MODE, N_("Gpsd Host:"), VIK_LAYER_WIDGET_ENTRY, NULL, NULL, NULL, gpsd_host_default, NULL, NULL },
+  { VIK_LAYER_GPS, "gpsd_port", VIK_LAYER_PARAM_STRING, GROUP_REALTIME_MODE, N_("Gpsd Port:"), VIK_LAYER_WIDGET_ENTRY, NULL, NULL, NULL, gpsd_port_default, NULL, NULL },
+  { VIK_LAYER_GPS, "gpsd_retry_interval", VIK_LAYER_PARAM_STRING, GROUP_REALTIME_MODE, N_("Gpsd Retry Interval (seconds):"), VIK_LAYER_WIDGET_ENTRY, NULL, NULL, NULL, gpsd_retry_interval_default, NULL, NULL },
 #endif /* VIK_CONFIG_REALTIME_GPS_TRACKING */
 };
 enum {
   PARAM_PROTOCOL=0, PARAM_PORT,
   PARAM_DOWNLOAD_TRACKS, PARAM_UPLOAD_TRACKS,
 #endif /* VIK_CONFIG_REALTIME_GPS_TRACKING */
 };
 enum {
   PARAM_PROTOCOL=0, PARAM_PORT,
   PARAM_DOWNLOAD_TRACKS, PARAM_UPLOAD_TRACKS,
+  PARAM_DOWNLOAD_ROUTES, PARAM_UPLOAD_ROUTES,
   PARAM_DOWNLOAD_WAYPOINTS, PARAM_UPLOAD_WAYPOINTS,
 #if defined (VIK_CONFIG_REALTIME_GPS_TRACKING) && defined (GPSD_API_MAJOR_VERSION)
   PARAM_DOWNLOAD_WAYPOINTS, PARAM_UPLOAD_WAYPOINTS,
 #if defined (VIK_CONFIG_REALTIME_GPS_TRACKING) && defined (GPSD_API_MAJOR_VERSION)
-  PARAM_REALTIME_REC, PARAM_REALTIME_CENTER_START, PARAM_VEHICLE_POSITION, PARAM_GPSD_HOST, PARAM_GPSD_PORT, PARAM_GPSD_RETRY_INTERVAL,
+  PARAM_REALTIME_REC,
+  PARAM_REALTIME_CENTER_START,
+  PARAM_VEHICLE_POSITION,
+  PARAM_REALTIME_UPDATE_STATUSBAR,
+  PARAM_GPSD_HOST,
+  PARAM_GPSD_PORT,
+  PARAM_GPSD_RETRY_INTERVAL,
 #endif /* VIK_CONFIG_REALTIME_GPS_TRACKING */
   NUM_PARAMS};
 
 VikLayerInterface vik_gps_layer_interface = {
 #endif /* VIK_CONFIG_REALTIME_GPS_TRACKING */
   NUM_PARAMS};
 
 VikLayerInterface vik_gps_layer_interface = {
+  "GPS",
   N_("GPS"),
   NULL,
   &vikgpslayer_pixbuf,
   N_("GPS"),
   NULL,
   &vikgpslayer_pixbuf,
@@ -216,6 +278,7 @@ VikLayerInterface vik_gps_layer_interface = {
 
   (VikLayerFuncSetParam)                gps_layer_set_param,
   (VikLayerFuncGetParam)                gps_layer_get_param,
 
   (VikLayerFuncSetParam)                gps_layer_set_param,
   (VikLayerFuncGetParam)                gps_layer_get_param,
+  (VikLayerFuncChangeParam)             NULL,
 
   (VikLayerFuncReadFileData)            NULL,
   (VikLayerFuncWriteFileData)           NULL,
 
   (VikLayerFuncReadFileData)            NULL,
   (VikLayerFuncWriteFileData)           NULL,
@@ -225,7 +288,7 @@ VikLayerInterface vik_gps_layer_interface = {
   (VikLayerFuncCopyItem)                NULL,
   (VikLayerFuncPasteItem)               NULL,
   (VikLayerFuncFreeCopiedItem)          NULL,
   (VikLayerFuncCopyItem)                NULL,
   (VikLayerFuncPasteItem)               NULL,
   (VikLayerFuncFreeCopiedItem)          NULL,
-  (VikLayerFuncDragDropRequest)                gps_layer_drag_drop_request,
+  (VikLayerFuncDragDropRequest)         NULL,
 
   (VikLayerFuncSelectClick)             NULL,
   (VikLayerFuncSelectMove)              NULL,
 
   (VikLayerFuncSelectClick)             NULL,
   (VikLayerFuncSelectMove)              NULL,
@@ -288,12 +351,17 @@ struct _VikGpsLayer {
   gboolean realtime_record;
   gboolean realtime_jump_to_start;
   guint vehicle_position;
   gboolean realtime_record;
   gboolean realtime_jump_to_start;
   guint vehicle_position;
+  gboolean realtime_update_statusbar;
+  VikTrackpoint *trkpt;
+  VikTrackpoint *trkpt_prev;
 #endif /* VIK_CONFIG_REALTIME_GPS_TRACKING */
   gchar *protocol;
   gchar *serial_port;
   gboolean download_tracks;
 #endif /* VIK_CONFIG_REALTIME_GPS_TRACKING */
   gchar *protocol;
   gchar *serial_port;
   gboolean download_tracks;
+  gboolean download_routes;
   gboolean download_waypoints;
   gboolean upload_tracks;
   gboolean download_waypoints;
   gboolean upload_tracks;
+  gboolean upload_routes;
   gboolean upload_waypoints;
 };
 
   gboolean upload_waypoints;
 };
 
@@ -315,8 +383,7 @@ static void gps_layer_inst_init ( VikGpsLayer *self )
   }
   new_protocols[new_proto] = NULL;
 
   }
   new_protocols[new_proto] = NULL;
 
-  vik_gps_layer_interface.params[0].widget_data = new_protocols;
-  // assigned to [0] because this^ is the GPS protocol in the params list
+  vik_gps_layer_interface.params[PARAM_PROTOCOL].widget_data = new_protocols;
 }
 
 GType vik_gps_layer_get_type ()
 }
 
 GType vik_gps_layer_get_type ()
@@ -351,7 +418,7 @@ static VikGpsLayer *vik_gps_layer_create (VikViewport *vp)
   vik_layer_rename ( VIK_LAYER(rv), vik_gps_layer_interface.name );
 
   for (i = 0; i < NUM_TRW; i++) {
   vik_layer_rename ( VIK_LAYER(rv), vik_gps_layer_interface.name );
 
   for (i = 0; i < NUM_TRW; i++) {
-    rv->trw_children[i] = VIK_TRW_LAYER(vik_layer_create ( VIK_LAYER_TRW, vp, NULL, FALSE ));
+    rv->trw_children[i] = VIK_TRW_LAYER(vik_layer_create ( VIK_LAYER_TRW, vp, FALSE ));
     vik_layer_set_menu_items_selection(VIK_LAYER(rv->trw_children[i]), VIK_MENU_ITEM_ALL & ~(VIK_MENU_ITEM_CUT|VIK_MENU_ITEM_DELETE));
   }
   return rv;
     vik_layer_set_menu_items_selection(VIK_LAYER(rv->trw_children[i]), VIK_MENU_ITEM_ALL & ~(VIK_MENU_ITEM_CUT|VIK_MENU_ITEM_DELETE));
   }
   return rv;
@@ -415,7 +482,8 @@ static VikGpsLayer *gps_layer_unmarshall( guint8 *data, gint len, VikViewport *v
     child_layer = vik_layer_unmarshall ( data + sizeof(gint), alm_size, vvp );
     if (child_layer) {
       rv->trw_children[i++] = (VikTrwLayer *)child_layer;
     child_layer = vik_layer_unmarshall ( data + sizeof(gint), alm_size, vvp );
     if (child_layer) {
       rv->trw_children[i++] = (VikTrwLayer *)child_layer;
-      g_signal_connect_swapped ( G_OBJECT(child_layer), "update", G_CALLBACK(vik_layer_emit_update_secondary), rv );
+      // NB no need to attach signal update handler here
+      //  as this will always be performed later on in vik_gps_layer_realize()
     }
     alm_next;
   }
     }
     alm_next;
   }
@@ -472,6 +540,12 @@ static gboolean gps_layer_set_param ( VikGpsLayer *vgl, guint16 id, VikLayerPara
     case PARAM_UPLOAD_TRACKS:
       vgl->upload_tracks = data.b;
       break;
     case PARAM_UPLOAD_TRACKS:
       vgl->upload_tracks = data.b;
       break;
+    case PARAM_DOWNLOAD_ROUTES:
+      vgl->download_routes = data.b;
+      break;
+    case PARAM_UPLOAD_ROUTES:
+      vgl->upload_routes = data.b;
+      break;
     case PARAM_DOWNLOAD_WAYPOINTS:
       vgl->download_waypoints = data.b;
       break;
     case PARAM_DOWNLOAD_WAYPOINTS:
       vgl->download_waypoints = data.b;
       break;
@@ -480,14 +554,18 @@ static gboolean gps_layer_set_param ( VikGpsLayer *vgl, guint16 id, VikLayerPara
       break;
 #if defined (VIK_CONFIG_REALTIME_GPS_TRACKING) && defined (GPSD_API_MAJOR_VERSION)
     case PARAM_GPSD_HOST:
       break;
 #if defined (VIK_CONFIG_REALTIME_GPS_TRACKING) && defined (GPSD_API_MAJOR_VERSION)
     case PARAM_GPSD_HOST:
-      if (vgl->gpsd_host)
-        g_free(vgl->gpsd_host);
-      vgl->gpsd_host = g_strdup(data.s);
+      if (data.s) {
+        if (vgl->gpsd_host)
+          g_free(vgl->gpsd_host);
+        vgl->gpsd_host = g_strdup(data.s);
+      }
       break;
     case PARAM_GPSD_PORT:
       break;
     case PARAM_GPSD_PORT:
-      if (vgl->gpsd_port)
-        g_free(vgl->gpsd_port);
-      vgl->gpsd_port = g_strdup(data.s); /* TODO: check for number */
+      if (data.s) {
+        if (vgl->gpsd_port)
+          g_free(vgl->gpsd_port);
+        vgl->gpsd_port = g_strdup(data.s);
+      }
       break;
     case PARAM_GPSD_RETRY_INTERVAL:
       vgl->gpsd_retry_interval = strtol(data.s, NULL, 10);
       break;
     case PARAM_GPSD_RETRY_INTERVAL:
       vgl->gpsd_retry_interval = strtol(data.s, NULL, 10);
@@ -501,6 +579,9 @@ static gboolean gps_layer_set_param ( VikGpsLayer *vgl, guint16 id, VikLayerPara
     case PARAM_VEHICLE_POSITION:
       vgl->vehicle_position = data.u;
       break;
     case PARAM_VEHICLE_POSITION:
       vgl->vehicle_position = data.u;
       break;
+    case PARAM_REALTIME_UPDATE_STATUSBAR:
+      vgl->realtime_update_statusbar = data.b;
+      break;
 #endif /* VIK_CONFIG_REALTIME_GPS_TRACKING */
     default:
       g_warning("gps_layer_set_param(): unknown parameter");
 #endif /* VIK_CONFIG_REALTIME_GPS_TRACKING */
     default:
       g_warning("gps_layer_set_param(): unknown parameter");
@@ -528,6 +609,12 @@ static VikLayerParamData gps_layer_get_param ( VikGpsLayer *vgl, guint16 id, gbo
     case PARAM_UPLOAD_TRACKS:
       rv.b = vgl->upload_tracks;
       break;
     case PARAM_UPLOAD_TRACKS:
       rv.b = vgl->upload_tracks;
       break;
+    case PARAM_DOWNLOAD_ROUTES:
+      rv.b = vgl->download_routes;
+      break;
+    case PARAM_UPLOAD_ROUTES:
+      rv.b = vgl->upload_routes;
+      break;
     case PARAM_DOWNLOAD_WAYPOINTS:
       rv.b = vgl->download_waypoints;
       break;
     case PARAM_DOWNLOAD_WAYPOINTS:
       rv.b = vgl->download_waypoints;
       break;
@@ -553,6 +640,9 @@ static VikLayerParamData gps_layer_get_param ( VikGpsLayer *vgl, guint16 id, gbo
     case PARAM_VEHICLE_POSITION:
       rv.u = vgl->vehicle_position;
       break;
     case PARAM_VEHICLE_POSITION:
       rv.u = vgl->vehicle_position;
       break;
+    case PARAM_REALTIME_UPDATE_STATUSBAR:
+      rv.u = vgl->realtime_update_statusbar;
+      break;
 #endif /* VIK_CONFIG_REALTIME_GPS_TRACKING */
     default:
       g_warning(_("%s: unknown parameter"), __FUNCTION__);
 #endif /* VIK_CONFIG_REALTIME_GPS_TRACKING */
     default:
       g_warning(_("%s: unknown parameter"), __FUNCTION__);
@@ -565,7 +655,7 @@ VikGpsLayer *vik_gps_layer_new (VikViewport *vp)
 {
   gint i;
   VikGpsLayer *vgl = VIK_GPS_LAYER ( g_object_new ( VIK_GPS_LAYER_TYPE, NULL ) );
 {
   gint i;
   VikGpsLayer *vgl = VIK_GPS_LAYER ( g_object_new ( VIK_GPS_LAYER_TYPE, NULL ) );
-  vik_layer_init ( VIK_LAYER(vgl), VIK_LAYER_GPS );
+  vik_layer_set_type ( VIK_LAYER(vgl), VIK_LAYER_GPS );
   for (i = 0; i < NUM_TRW; i++) {
     vgl->trw_children[i] = NULL;
   }
   for (i = 0; i < NUM_TRW; i++) {
     vgl->trw_children[i] = NULL;
   }
@@ -573,83 +663,59 @@ VikGpsLayer *vik_gps_layer_new (VikViewport *vp)
   vgl->cur_read_child = 0;
 
 #if defined (VIK_CONFIG_REALTIME_GPS_TRACKING) && defined (GPSD_API_MAJOR_VERSION)
   vgl->cur_read_child = 0;
 
 #if defined (VIK_CONFIG_REALTIME_GPS_TRACKING) && defined (GPSD_API_MAJOR_VERSION)
-  vgl->realtime_tracking = FALSE;
   vgl->first_realtime_trackpoint = FALSE;
   vgl->first_realtime_trackpoint = FALSE;
+  vgl->trkpt = NULL;
+  vgl->trkpt_prev = NULL;
   vgl->vgpsd = NULL;
   vgl->realtime_io_channel = NULL;
   vgl->realtime_io_watch_id = 0;
   vgl->realtime_retry_timer = 0;
   vgl->vgpsd = NULL;
   vgl->realtime_io_channel = NULL;
   vgl->realtime_io_watch_id = 0;
   vgl->realtime_retry_timer = 0;
-  vgl->realtime_track_gc = vik_viewport_new_gc ( vp, "#203070", 2 );
-  vgl->realtime_track_bg_gc = vik_viewport_new_gc ( vp, "grey", 2 );
-  vgl->realtime_track_pt1_gc = vik_viewport_new_gc ( vp, "red", 2 );
-  vgl->realtime_track_pt2_gc = vik_viewport_new_gc ( vp, "green", 2 );
-  vgl->realtime_track_pt_gc = vgl->realtime_track_pt1_gc;
+  if ( vp ) {
+    vgl->realtime_track_gc = vik_viewport_new_gc ( vp, "#203070", 2 );
+    vgl->realtime_track_bg_gc = vik_viewport_new_gc ( vp, "grey", 2 );
+    vgl->realtime_track_pt1_gc = vik_viewport_new_gc ( vp, "red", 2 );
+    vgl->realtime_track_pt2_gc = vik_viewport_new_gc ( vp, "green", 2 );
+    vgl->realtime_track_pt_gc = vgl->realtime_track_pt1_gc;
+  }
   vgl->realtime_track = NULL;
   vgl->realtime_track = NULL;
+#endif // VIK_CONFIG_REALTIME_GPS_TRACKING
 
 
-  /* Setting params here */
-  vgl->gpsd_host = g_strdup("localhost");
-  vgl->gpsd_port = g_strdup(DEFAULT_GPSD_PORT);
-  vgl->realtime_record = TRUE;
-  vgl->realtime_jump_to_start = TRUE;
-  vgl->vehicle_position = VEHICLE_POSITION_ON_SCREEN;
-  vgl->gpsd_retry_interval = 10;
-#endif /* VIK_CONFIG_REALTIME_GPS_TRACKING */
-  vgl->protocol = g_strdup("garmin");
-  vgl->serial_port = NULL;
-  vgl->download_tracks = TRUE;
-  vgl->download_waypoints = TRUE;
-  vgl->upload_tracks = TRUE;
-  vgl->upload_waypoints = TRUE;
-
-#ifndef WINDOWS
-  /* Attempt to auto set default USB serial port entry */
-  /* Ordered to make lowest device favourite if available */
-  if (g_access ("/dev/ttyUSB1", R_OK) == 0) {
-    if (vgl->serial_port != NULL)
-      g_free (vgl->serial_port);
-    vgl->serial_port = g_strdup ("/dev/ttyUSB1");
-  }
-  if (g_access ("/dev/ttyUSB0", R_OK) == 0) {
-    if (vgl->serial_port != NULL)
-      g_free (vgl->serial_port);
-    vgl->serial_port = g_strdup ("/dev/ttyUSB0");
-  }
-#endif
+  vik_layer_set_defaults ( VIK_LAYER(vgl), vp );
 
   return vgl;
 }
 
 
   return vgl;
 }
 
-static void vik_gps_layer_draw ( VikGpsLayer *vgl, gpointer data )
+static void vik_gps_layer_draw ( VikGpsLayer *vgl, VikViewport *vp )
 {
   gint i;
   VikLayer *vl;
 {
   gint i;
   VikLayer *vl;
-  VikLayer *trigger = VIK_LAYER(vik_viewport_get_trigger( VIK_VIEWPORT(data) ));
+  VikLayer *trigger = VIK_LAYER(vik_viewport_get_trigger( vp ));
 
   for (i = 0; i < NUM_TRW; i++) {
     vl = VIK_LAYER(vgl->trw_children[i]);
     if (vl == trigger) {
 
   for (i = 0; i < NUM_TRW; i++) {
     vl = VIK_LAYER(vgl->trw_children[i]);
     if (vl == trigger) {
-      if ( vik_viewport_get_half_drawn ( VIK_VIEWPORT(data) ) ) {
-        vik_viewport_set_half_drawn ( VIK_VIEWPORT(data), FALSE );
-        vik_viewport_snapshot_load( VIK_VIEWPORT(data) );
+      if ( vik_viewport_get_half_drawn ( vp ) ) {
+        vik_viewport_set_half_drawn ( vp, FALSE );
+        vik_viewport_snapshot_load( vp );
       } else {
       } else {
-        vik_viewport_snapshot_save( VIK_VIEWPORT(data) );
+        vik_viewport_snapshot_save( vp );
       }
     }
       }
     }
-    if (!vik_viewport_get_half_drawn( VIK_VIEWPORT(data)))
-      vik_layer_draw ( vl, data );
+    if (!vik_viewport_get_half_drawn(vp))
+      vik_layer_draw ( vl, vp );
   }
 #if defined (VIK_CONFIG_REALTIME_GPS_TRACKING) && defined (GPSD_API_MAJOR_VERSION)
   if (vgl->realtime_tracking) {
     if (VIK_LAYER(vgl) == trigger) {
   }
 #if defined (VIK_CONFIG_REALTIME_GPS_TRACKING) && defined (GPSD_API_MAJOR_VERSION)
   if (vgl->realtime_tracking) {
     if (VIK_LAYER(vgl) == trigger) {
-      if ( vik_viewport_get_half_drawn ( VIK_VIEWPORT(data) ) ) {
-        vik_viewport_set_half_drawn ( VIK_VIEWPORT(data), FALSE );
-        vik_viewport_snapshot_load( VIK_VIEWPORT(data) );
+      if ( vik_viewport_get_half_drawn ( vp ) ) {
+        vik_viewport_set_half_drawn ( vp, FALSE );
+        vik_viewport_snapshot_load( vp );
       } else {
       } else {
-        vik_viewport_snapshot_save( VIK_VIEWPORT(data) );
+        vik_viewport_snapshot_save( vp );
       }
     }
       }
     }
-    if (!vik_viewport_get_half_drawn( VIK_VIEWPORT(data)))
-      realtime_tracking_draw(vgl, VIK_VIEWPORT(data));
+    if (!vik_viewport_get_half_drawn(vp))
+      realtime_tracking_draw(vgl, vp);
   }
 #endif /* VIK_CONFIG_REALTIME_GPS_TRACKING */
 }
   }
 #endif /* VIK_CONFIG_REALTIME_GPS_TRACKING */
 }
@@ -730,14 +796,9 @@ static void gps_layer_add_menu_items( VikGpsLayer *vgl, GtkMenu *menu, gpointer
 
 static void disconnect_layer_signal ( VikLayer *vl, VikGpsLayer *vgl )
 {
 
 static void disconnect_layer_signal ( VikLayer *vl, VikGpsLayer *vgl )
 {
-  guint number_handlers = DISCONNECT_UPDATE_SIGNAL(vl,vgl);
+  guint number_handlers = g_signal_handlers_disconnect_matched(vl, G_SIGNAL_MATCH_DATA, 0, 0, 0, 0, vgl);
   if ( number_handlers != 1 ) {
   if ( number_handlers != 1 ) {
-    /*
-      NB It's not fatal if this gives 2 for example! Hence removal of the g_assert
-      This happens when copied GPS layer is deleted (not sure why the number_handlers would be 2)
-      I don't think there's any side effects and certainly better than the program just aborting
-    */
-    g_warning(_("Unexpected number of disconnected handlers: %d"), number_handlers);
+    g_critical(_("Unexpected number of disconnected handlers: %d"), number_handlers);
   }
 }
 
   }
 }
 
@@ -762,23 +823,6 @@ static void vik_gps_layer_free ( VikGpsLayer *vgl )
 #endif /* VIK_CONFIG_REALTIME_GPS_TRACKING */
 }
 
 #endif /* VIK_CONFIG_REALTIME_GPS_TRACKING */
 }
 
-gboolean vik_gps_layer_delete ( VikGpsLayer *vgl, GtkTreeIter *iter )
-{
-  gint i;
-  VikLayer *l = VIK_LAYER( vik_treeview_item_get_pointer ( VIK_LAYER(vgl)->vt, iter ) );
-  gboolean was_visible = l->visible;
-
-  vik_treeview_item_delete ( VIK_LAYER(vgl)->vt, iter );
-  for (i = 0; i < NUM_TRW; i++) {
-    if (VIK_LAYER(vgl->trw_children[i]) == l)
-      vgl->trw_children[i] = NULL;
-  }
-  g_assert(DISCONNECT_UPDATE_SIGNAL(l,vgl)==1);
-  g_object_unref ( l );
-
-  return was_visible;
-}
-
 static void vik_gps_layer_realize ( VikGpsLayer *vgl, VikTreeview *vt, GtkTreeIter *layer_iter )
 {
   GtkTreeIter iter;
 static void vik_gps_layer_realize ( VikGpsLayer *vgl, VikTreeview *vt, GtkTreeIter *layer_iter )
 {
   GtkTreeIter iter;
@@ -792,7 +836,7 @@ static void vik_gps_layer_realize ( VikGpsLayer *vgl, VikTreeview *vt, GtkTreeIt
   for (ix = 0; ix < NUM_TRW; ix++) {
     VikLayer * trw = VIK_LAYER(vgl->trw_children[ix]);
     vik_treeview_add_layer ( VIK_LAYER(vgl)->vt, layer_iter, &iter,
   for (ix = 0; ix < NUM_TRW; ix++) {
     VikLayer * trw = VIK_LAYER(vgl->trw_children[ix]);
     vik_treeview_add_layer ( VIK_LAYER(vgl)->vt, layer_iter, &iter,
-        _(trw_names[ix]), vgl, 
+        _(trw_names[ix]), vgl, TRUE,
         trw, trw->type, trw->type );
     if ( ! trw->visible )
       vik_treeview_item_set_visible ( VIK_LAYER(vgl)->vt, &iter, FALSE );
         trw, trw->type, trw->type );
     if ( ! trw->visible )
       vik_treeview_item_set_visible ( VIK_LAYER(vgl)->vt, &iter, FALSE );
@@ -829,22 +873,6 @@ gboolean vik_gps_layer_is_empty ( VikGpsLayer *vgl )
   return TRUE;
 }
 
   return TRUE;
 }
 
-static void gps_layer_drag_drop_request ( VikGpsLayer *val_src, VikGpsLayer *val_dest, GtkTreeIter *src_item_iter, GtkTreePath *dest_path )
-{
-  VikTreeview *vt = VIK_LAYER(val_src)->vt;
-  VikLayer *vl = vik_treeview_item_get_pointer(vt, src_item_iter);
-  gchar *dp;
-
-  dp = gtk_tree_path_to_string(dest_path);
-
-  /* vik_gps_layer_delete unrefs, but we don't want that here.
-   * we're still using the layer. */
-  g_object_ref ( vl );
-  vik_gps_layer_delete(val_src, src_item_iter);
-
-  g_free(dp);
-}
-
 static void gps_session_delete(GpsSession *sess)
 {
   /* TODO */
 static void gps_session_delete(GpsSession *sess)
 {
   /* TODO */
@@ -864,17 +892,25 @@ static void set_total_count(gint cnt, GpsSession *sess)
     const gchar *tmp_str;
     if (sess->direction == GPS_DOWN)
     {
     const gchar *tmp_str;
     if (sess->direction == GPS_DOWN)
     {
-      if (sess->progress_label == sess->wp_label)
-        tmp_str = ngettext("Downloading %d waypoint...", "Downloading %d waypoints...", cnt);
-      else
-        tmp_str = ngettext("Downloading %d trackpoint...", "Downloading %d trackpoints...", cnt);
+      switch (sess->progress_type) {
+      case WPT: tmp_str = ngettext("Downloading %d waypoint...", "Downloading %d waypoints...", cnt); sess->total_count = cnt; break;
+      case TRK: tmp_str = ngettext("Downloading %d trackpoint...", "Downloading %d trackpoints...", cnt); sess->total_count = cnt; break;
+      default:
+        {
+          // Maybe a gpsbabel bug/feature (upto at least v1.4.3 or maybe my Garmin device) but the count always seems x2 too many for routepoints
+          gint mycnt = (cnt / 2) + 1;
+          tmp_str = ngettext("Downloading %d routepoint...", "Downloading %d routepoints...", mycnt); break;
+          sess->total_count = mycnt;
+        }
+      }
     }
     }
-    else 
+    else
     {
     {
-      if (sess->progress_label == sess->wp_label)
-        tmp_str = ngettext("Uploading %d waypoint...", "Uploading %d waypoints...", cnt);
-      else
-        tmp_str = ngettext("Uploading %d trackpoint...", "Uploading %d trackpoints...", cnt);
+      switch (sess->progress_type) {
+      case WPT: tmp_str = ngettext("Uploading %d waypoint...", "Uploading %d waypoints...", cnt); break;
+      case TRK: tmp_str = ngettext("Uploading %d trackpoint...", "Uploading %d trackpoints...", cnt); break;
+      default: tmp_str = ngettext("Uploading %d routepoint...", "Uploading %d routepoints...", cnt); break;
+      }
     }
 
     g_snprintf(s, 128, tmp_str, cnt);
     }
 
     g_snprintf(s, 128, tmp_str, cnt);
@@ -897,31 +933,35 @@ static void set_current_count(gint cnt, GpsSession *sess)
     if (cnt < sess->total_count) {
       if (sess->direction == GPS_DOWN)
       {
     if (cnt < sess->total_count) {
       if (sess->direction == GPS_DOWN)
       {
-        if (sess->progress_label == sess->wp_label)
-          tmp_str = ngettext("Downloaded %d out of %d waypoint...", "Downloaded %d out of %d waypoints...", sess->total_count);
-        else
-          tmp_str = ngettext("Downloaded %d out of %d trackpoint...", "Downloaded %d out of %d trackpoints...", sess->total_count);
+        switch (sess->progress_type) {
+        case WPT: tmp_str = ngettext("Downloaded %d out of %d waypoint...", "Downloaded %d out of %d waypoints...", sess->total_count); break;
+        case TRK: tmp_str = ngettext("Downloaded %d out of %d trackpoint...", "Downloaded %d out of %d trackpoints...", sess->total_count); break;
+        default: tmp_str = ngettext("Downloaded %d out of %d routepoint...", "Downloaded %d out of %d routepoints...", sess->total_count); break;
+        }
       }
       else {
       }
       else {
-        if (sess->progress_label == sess->wp_label)
-          tmp_str = ngettext("Uploaded %d out of %d waypoint...", "Uploaded %d out of %d waypoints...", sess->total_count);
-        else
-          tmp_str = ngettext("Uploaded %d out of %d trackpoint...", "Uploaded %d out of %d trackpoints...", sess->total_count);
+        switch (sess->progress_type) {
+        case WPT: tmp_str = ngettext("Uploaded %d out of %d waypoint...", "Uploaded %d out of %d waypoints...", sess->total_count); break;
+        case TRK: tmp_str = ngettext("Uploaded %d out of %d trackpoint...", "Uploaded %d out of %d trackpoints...", sess->total_count); break;
+        default: tmp_str = ngettext("Uploaded %d out of %d routepoint...", "Uploaded %d out of %d routepoints...", sess->total_count); break;
+       }
       }
       g_snprintf(s, 128, tmp_str, cnt, sess->total_count);
     } else {
       if (sess->direction == GPS_DOWN)
       {
       }
       g_snprintf(s, 128, tmp_str, cnt, sess->total_count);
     } else {
       if (sess->direction == GPS_DOWN)
       {
-        if (sess->progress_label == sess->wp_label)
-          tmp_str = ngettext("Downloaded %d waypoint", "Downloaded %d waypoints", cnt);
-        else
-          tmp_str = ngettext("Downloaded %d trackpoint", "Downloaded %d trackpoints", cnt);
+        switch (sess->progress_type) {
+        case WPT: tmp_str = ngettext("Downloaded %d waypoint", "Downloaded %d waypoints", cnt); break;
+        case TRK: tmp_str = ngettext("Downloaded %d trackpoint", "Downloaded %d trackpoints", cnt); break;
+        default: tmp_str = ngettext("Downloaded %d routepoint", "Downloaded %d routepoints", cnt); break;
+       }
       }
       else {
       }
       else {
-        if (sess->progress_label == sess->wp_label)
-          tmp_str = ngettext("Uploaded %d waypoint", "Uploaded %d waypoints", cnt);
-        else
-          tmp_str = ngettext("Uploaded %d trackpoint", "Uploaded %d trackpoints", cnt);
+        switch (sess->progress_type) {
+        case WPT: tmp_str = ngettext("Uploaded %d waypoint", "Uploaded %d waypoints", cnt); break;
+        case TRK: tmp_str = ngettext("Uploaded %d trackpoint", "Uploaded %d trackpoints", cnt); break;
+        default: tmp_str = ngettext("Uploaded %d routepoint", "Uploaded %d routepoints", cnt); break;
+       }
       }
       g_snprintf(s, 128, tmp_str, cnt);
     }    
       }
       g_snprintf(s, 128, tmp_str, cnt);
     }    
@@ -944,6 +984,51 @@ static void set_gps_info(const gchar *info, GpsSession *sess)
   gdk_threads_leave();
 }
 
   gdk_threads_leave();
 }
 
+/*
+ * Common processing for GPS Device information
+ * It doesn't matter whether we're uploading or downloading
+ */
+static void process_line_for_gps_info ( const gchar *line, GpsSession *sess )
+{
+  if (strstr(line, "PRDDAT")) {
+    gchar **tokens = g_strsplit(line, " ", 0);
+    gchar info[128];
+    int ilen = 0;
+    int i;
+    int n_tokens = 0;
+
+    while (tokens[n_tokens])
+      n_tokens++;
+
+    // I'm not entirely clear what information this is trying to get...
+    //  Obviously trying to decipher some kind of text/naming scheme
+    //  Anyway this will be superceded if there is 'Unit:' information
+    if (n_tokens > 8) {
+      for (i=8; tokens[i] && ilen < sizeof(info)-2 && strcmp(tokens[i], "00"); i++) {
+        guint ch;
+        sscanf(tokens[i], "%x", &ch);
+        info[ilen++] = ch;
+      }
+      info[ilen++] = 0;
+      set_gps_info(info, sess);
+    }
+    g_strfreev(tokens);
+  }
+
+  /* eg: "Unit:\teTrex Legend HCx Software Version 2.90\n" */
+  if (strstr(line, "Unit:")) {
+    gchar **tokens = g_strsplit(line, "\t", 0);
+    int n_tokens = 0;
+    while (tokens[n_tokens])
+      n_tokens++;
+
+    if (n_tokens > 1) {
+      set_gps_info(tokens[1], sess);
+    }
+    g_strfreev(tokens);
+  }
+}
+
 static void gps_download_progress_func(BabelProgressCode c, gpointer data, GpsSession * sess )
 {
   gchar *line;
 static void gps_download_progress_func(BabelProgressCode c, gpointer data, GpsSession * sess )
 {
   gchar *line;
@@ -971,47 +1056,23 @@ static void gps_download_progress_func(BabelProgressCode c, gpointer data, GpsSe
     g_mutex_unlock(sess->mutex);
     gdk_threads_leave();
 
     g_mutex_unlock(sess->mutex);
     gdk_threads_leave();
 
-    /* tells us how many items there will be */
-    if (strstr(line, "Xfer Wpt")) { 
+    /* tells us the type of items that will follow */
+    if (strstr(line, "Xfer Wpt")) {
       sess->progress_label = sess->wp_label;
       sess->progress_label = sess->wp_label;
+      sess->progress_type = WPT;
     }
     }
-    if (strstr(line, "Xfer Trk")) { 
+    if (strstr(line, "Xfer Trk")) {
       sess->progress_label = sess->trk_label;
       sess->progress_label = sess->trk_label;
+      sess->progress_type = TRK;
     }
     }
-    if (strstr(line, "PRDDAT")) {
-      gchar **tokens = g_strsplit(line, " ", 0);
-      gchar info[128];
-      int ilen = 0;
-      int i;
-      int n_tokens = 0;
-
-      while (tokens[n_tokens])
-        n_tokens++;
-
-      if (n_tokens > 8) {
-        for (i=8; tokens[i] && ilen < sizeof(info)-2 && strcmp(tokens[i], "00"); i++) {
-         guint ch;
-         sscanf(tokens[i], "%x", &ch);
-         info[ilen++] = ch;
-        }
-        info[ilen++] = 0;
-        set_gps_info(info, sess);
-      }
-      g_strfreev(tokens);
-    }
-    /* eg: "Unit:\teTrex Legend HCx Software Version 2.90\n" */
-    if (strstr(line, "Unit:")) {
-      gchar **tokens = g_strsplit(line, "\t", 0);
-      int n_tokens = 0;
-      while (tokens[n_tokens])
-        n_tokens++;
-
-      if (n_tokens > 1) {
-        set_gps_info(tokens[1], sess);
-      }
-      g_strfreev(tokens);
+    if (strstr(line, "Xfer Rte")) {
+      sess->progress_label = sess->rte_label;
+      sess->progress_type = RTE;
     }
     }
-    if (strstr(line, "RECORD")) { 
+
+    process_line_for_gps_info ( line, sess );
+
+    if (strstr(line, "RECORD")) {
       int lsb, msb, cnt;
 
       if (strlen(line) > 20) {
       int lsb, msb, cnt;
 
       if (strlen(line) > 20) {
@@ -1022,7 +1083,7 @@ static void gps_download_progress_func(BabelProgressCode c, gpointer data, GpsSe
         sess->count = 0;
       }
     }
         sess->count = 0;
       }
     }
-    if ( strstr(line, "WPTDAT") || strstr(line, "TRKHDR") || strstr(line, "TRKDAT") ) {
+    if ( strstr(line, "WPTDAT") || strstr(line, "TRKHDR") || strstr(line, "TRKDAT") || strstr(line, "RTEHDR") || strstr(line, "RTEWPT") ) {
       sess->count++;
       set_current_count(sess->count, sess);
     }
       sess->count++;
       set_current_count(sess->count, sess);
     }
@@ -1063,27 +1124,8 @@ static void gps_upload_progress_func(BabelProgressCode c, gpointer data, GpsSess
     g_mutex_unlock(sess->mutex);
     gdk_threads_leave();
 
     g_mutex_unlock(sess->mutex);
     gdk_threads_leave();
 
-    if (strstr(line, "PRDDAT")) {
-      gchar **tokens = g_strsplit(line, " ", 0);
-      gchar info[128];
-      int ilen = 0;
-      int i;
-      int n_tokens = 0;
-
-      while (tokens[n_tokens])
-        n_tokens++;
-
-      if (n_tokens > 8) {
-        for (i=8; tokens[i] && ilen < sizeof(info)-2 && strcmp(tokens[i], "00"); i++) {
-         guint ch;
-         sscanf(tokens[i], "%x", &ch);
-         info[ilen++] = ch;
-        }
-        info[ilen++] = 0;
-        set_gps_info(info, sess);
-      }
-      g_strfreev(tokens);
-    }
+    process_line_for_gps_info ( line, sess );
+
     if (strstr(line, "RECORD")) { 
       int lsb, msb;
 
     if (strstr(line, "RECORD")) { 
       int lsb, msb;
 
@@ -1098,15 +1140,28 @@ static void gps_upload_progress_func(BabelProgressCode c, gpointer data, GpsSess
     if ( strstr(line, "WPTDAT")) {
       if (sess->count == 0) {
         sess->progress_label = sess->wp_label;
     if ( strstr(line, "WPTDAT")) {
       if (sess->count == 0) {
         sess->progress_label = sess->wp_label;
+        sess->progress_type = WPT;
         set_total_count(cnt, sess);
       }
       sess->count++;
       set_current_count(sess->count, sess);
         set_total_count(cnt, sess);
       }
       sess->count++;
       set_current_count(sess->count, sess);
-
+    }
+    if ( strstr(line, "RTEHDR") || strstr(line, "RTEWPT") ) {
+       if (sess->count == 0) {
+         sess->progress_label = sess->rte_label;
+         sess->progress_type = RTE;
+         // Maybe a gpsbabel bug/feature (upto at least v1.4.3 or maybe my Garmin device) but the count always seems x2 too many for routepoints
+         // Anyway since we're uploading - we should know how many points we're going to put!
+         cnt = (cnt / 2) + 1;
+         set_total_count(cnt, sess);
+       }
+       sess->count++;
+       set_current_count(sess->count, sess);
     }
     if ( strstr(line, "TRKHDR") || strstr(line, "TRKDAT") ) {
       if (sess->count == 0) {
         sess->progress_label = sess->trk_label;
     }
     if ( strstr(line, "TRKHDR") || strstr(line, "TRKDAT") ) {
       if (sess->count == 0) {
         sess->progress_label = sess->trk_label;
+       sess->progress_type = TRK;
         set_total_count(cnt, sess);
       }
       sess->count++;
         set_total_count(cnt, sess);
       }
       sess->count++;
@@ -1127,7 +1182,7 @@ static void gps_comm_thread(GpsSession *sess)
 
   if (sess->direction == GPS_DOWN)
     result = a_babel_convert_from (sess->vtl, sess->cmd_args, sess->port,
 
   if (sess->direction == GPS_DOWN)
     result = a_babel_convert_from (sess->vtl, sess->cmd_args, sess->port,
-        (BabelStatusFunc) gps_download_progress_func, sess);
+        (BabelStatusFunc) gps_download_progress_func, sess, NULL);
   else {
     result = a_babel_convert_to (sess->vtl, sess->track, sess->cmd_args, sess->port,
         (BabelStatusFunc) gps_upload_progress_func, sess);
   else {
     result = a_babel_convert_to (sess->vtl, sess->track, sess->cmd_args, sess->port,
         (BabelStatusFunc) gps_upload_progress_func, sess);
@@ -1151,7 +1206,7 @@ static void gps_comm_thread(GpsSession *sess)
        if ( sess->vvp && sess->direction == GPS_DOWN ) {
          /* View the data available */
          vik_trw_layer_auto_set_view ( sess->vtl, sess->vvp) ;
        if ( sess->vvp && sess->direction == GPS_DOWN ) {
          /* View the data available */
          vik_trw_layer_auto_set_view ( sess->vtl, sess->vvp) ;
-         vik_layer_emit_update ( VIK_LAYER(sess->vtl), TRUE ); // Yes update from background thread
+         vik_layer_emit_update ( VIK_LAYER(sess->vtl) ); // NB update from background thread
        }
       }
     } else {
        }
       }
     } else {
@@ -1197,11 +1252,13 @@ gint vik_gps_comm ( VikTrwLayer *vtl,
                     VikViewport *vvp,
                     VikLayersPanel *vlp,
                     gboolean do_tracks,
                     VikViewport *vvp,
                     VikLayersPanel *vlp,
                     gboolean do_tracks,
+                    gboolean do_routes,
                     gboolean do_waypoints,
                    gboolean turn_off )
 {
   GpsSession *sess = g_malloc(sizeof(GpsSession));
   char *tracks = NULL;
                     gboolean do_waypoints,
                    gboolean turn_off )
 {
   GpsSession *sess = g_malloc(sizeof(GpsSession));
   char *tracks = NULL;
+  char *routes = NULL;
   char *waypoints = NULL;
 
   sess->mutex = g_mutex_new();
   char *waypoints = NULL;
 
   sess->mutex = g_mutex_new();
@@ -1232,25 +1289,29 @@ gint vik_gps_comm ( VikTrwLayer *vtl,
     tracks = "-t";
   else
     tracks = "";
     tracks = "-t";
   else
     tracks = "";
+  if (do_routes)
+    routes = "-r";
+  else
+    routes = "";
   if (do_waypoints)
     waypoints = "-w";
   else
     waypoints = "";
 
   if (do_waypoints)
     waypoints = "-w";
   else
     waypoints = "";
 
-  sess->cmd_args = g_strdup_printf("-D 9 %s %s -%c %s",
-                                  tracks, waypoints, (dir == GPS_DOWN) ? 'i' : 'o', protocol);
+  sess->cmd_args = g_strdup_printf("-D 9 %s %s %s -%c %s",
+                                  tracks, routes, waypoints, (dir == GPS_DOWN) ? 'i' : 'o', protocol);
   tracks = NULL;
   waypoints = NULL;
 
   // Only create dialog if we're going to do some transferring
   tracks = NULL;
   waypoints = NULL;
 
   // Only create dialog if we're going to do some transferring
-  if ( do_tracks || do_waypoints ) {
+  if ( do_tracks || do_waypoints || do_routes ) {
     sess->dialog = gtk_dialog_new_with_buttons ( "", VIK_GTK_WINDOW_FROM_LAYER(vtl), 0, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, NULL );
     gtk_dialog_set_response_sensitive ( GTK_DIALOG(sess->dialog),
                                         GTK_RESPONSE_ACCEPT, FALSE );
     gtk_window_set_title ( GTK_WINDOW(sess->dialog), sess->window_title );
 
     sess->status_label = gtk_label_new (_("Status: detecting gpsbabel"));
     sess->dialog = gtk_dialog_new_with_buttons ( "", VIK_GTK_WINDOW_FROM_LAYER(vtl), 0, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, NULL );
     gtk_dialog_set_response_sensitive ( GTK_DIALOG(sess->dialog),
                                         GTK_RESPONSE_ACCEPT, FALSE );
     gtk_window_set_title ( GTK_WINDOW(sess->dialog), sess->window_title );
 
     sess->status_label = gtk_label_new (_("Status: detecting gpsbabel"));
-    gtk_box_pack_start ( GTK_BOX(GTK_DIALOG(sess->dialog)->vbox), sess->status_label, FALSE, FALSE, 5 );
+    gtk_box_pack_start ( GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(sess->dialog))), sess->status_label, FALSE, FALSE, 5 );
     gtk_widget_show_all(sess->status_label);
 
     sess->gps_label = gtk_label_new (_("GPS device: N/A"));
     gtk_widget_show_all(sess->status_label);
 
     sess->gps_label = gtk_label_new (_("GPS device: N/A"));
@@ -1258,10 +1319,12 @@ gint vik_gps_comm ( VikTrwLayer *vtl,
     sess->id_label = gtk_label_new ("");
     sess->wp_label = gtk_label_new ("");
     sess->trk_label = gtk_label_new ("");
     sess->id_label = gtk_label_new ("");
     sess->wp_label = gtk_label_new ("");
     sess->trk_label = gtk_label_new ("");
+    sess->rte_label = gtk_label_new ("");
 
 
-    gtk_box_pack_start ( GTK_BOX(GTK_DIALOG(sess->dialog)->vbox), sess->gps_label, FALSE, FALSE, 5 );
-    gtk_box_pack_start ( GTK_BOX(GTK_DIALOG(sess->dialog)->vbox), sess->wp_label, FALSE, FALSE, 5 );
-    gtk_box_pack_start ( GTK_BOX(GTK_DIALOG(sess->dialog)->vbox), sess->trk_label, FALSE, FALSE, 5 );
+    gtk_box_pack_start ( GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(sess->dialog))), sess->gps_label, FALSE, FALSE, 5 );
+    gtk_box_pack_start ( GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(sess->dialog))), sess->wp_label, FALSE, FALSE, 5 );
+    gtk_box_pack_start ( GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(sess->dialog))), sess->trk_label, FALSE, FALSE, 5 );
+    gtk_box_pack_start ( GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(sess->dialog))), sess->rte_label, FALSE, FALSE, 5 );
 
     gtk_widget_show_all(sess->dialog);
 
 
     gtk_widget_show_all(sess->dialog);
 
@@ -1269,7 +1332,11 @@ gint vik_gps_comm ( VikTrwLayer *vtl,
     sess->total_count = -1;
 
     // Starting gps read/write thread
     sess->total_count = -1;
 
     // Starting gps read/write thread
-    g_thread_create((GThreadFunc)gps_comm_thread, sess, FALSE, NULL );
+#if GLIB_CHECK_VERSION (2, 32, 0)
+    g_thread_try_new ( "gps_comm_thread", (GThreadFunc)gps_comm_thread, sess, NULL );
+#else
+    g_thread_create ( (GThreadFunc)gps_comm_thread, sess, FALSE, NULL );
+#endif
 
     gtk_dialog_set_default_response ( GTK_DIALOG(sess->dialog), GTK_RESPONSE_ACCEPT );
     gtk_dialog_run(GTK_DIALOG(sess->dialog));
 
     gtk_dialog_set_default_response ( GTK_DIALOG(sess->dialog), GTK_RESPONSE_ACCEPT );
     gtk_dialog_run(GTK_DIALOG(sess->dialog));
@@ -1291,7 +1358,7 @@ gint vik_gps_comm ( VikTrwLayer *vtl,
     if ( turn_off ) {
       // No need for thread for powering off device (should be quick operation...) - so use babel command directly:
       gchar *device_off = g_strdup_printf("-i %s,%s", protocol, "power_off");
     if ( turn_off ) {
       // No need for thread for powering off device (should be quick operation...) - so use babel command directly:
       gchar *device_off = g_strdup_printf("-i %s,%s", protocol, "power_off");
-      gboolean result = a_babel_convert_from (NULL, (const char*)device_off, (const char*)port, NULL, NULL);
+      gboolean result = a_babel_convert_from (NULL, (const char*)device_off, (const char*)port, NULL, NULL, NULL);
       if ( !result )
         a_dialog_error_msg ( VIK_GTK_WINDOW_FROM_LAYER(vtl), _("Could not turn off device.") );
       g_free ( device_off );
       if ( !result )
         a_dialog_error_msg ( VIK_GTK_WINDOW_FROM_LAYER(vtl), _("Could not turn off device.") );
       g_free ( device_off );
@@ -1310,7 +1377,7 @@ static void gps_upload_cb( gpointer layer_and_vlp[2] )
   VikTrwLayer *vtl = vgl->trw_children[TRW_UPLOAD];
   VikWindow *vw = VIK_WINDOW(VIK_GTK_WINDOW_FROM_LAYER(vgl));
   VikViewport *vvp = vik_window_viewport(vw);
   VikTrwLayer *vtl = vgl->trw_children[TRW_UPLOAD];
   VikWindow *vw = VIK_WINDOW(VIK_GTK_WINDOW_FROM_LAYER(vgl));
   VikViewport *vvp = vik_window_viewport(vw);
-  vik_gps_comm(vtl, NULL, GPS_UP, vgl->protocol, vgl->serial_port, FALSE, vvp, vlp, vgl->upload_tracks, vgl->upload_waypoints, FALSE);
+  vik_gps_comm(vtl, NULL, GPS_UP, vgl->protocol, vgl->serial_port, FALSE, vvp, vlp, vgl->upload_tracks, vgl->upload_routes, vgl->upload_waypoints, FALSE);
 }
 
 static void gps_download_cb( gpointer layer_and_vlp[2] )
 }
 
 static void gps_download_cb( gpointer layer_and_vlp[2] )
@@ -1320,9 +1387,9 @@ static void gps_download_cb( gpointer layer_and_vlp[2] )
   VikWindow *vw = VIK_WINDOW(VIK_GTK_WINDOW_FROM_LAYER(vgl));
   VikViewport *vvp = vik_window_viewport(vw);
 #if defined (VIK_CONFIG_REALTIME_GPS_TRACKING) && defined (GPSD_API_MAJOR_VERSION)
   VikWindow *vw = VIK_WINDOW(VIK_GTK_WINDOW_FROM_LAYER(vgl));
   VikViewport *vvp = vik_window_viewport(vw);
 #if defined (VIK_CONFIG_REALTIME_GPS_TRACKING) && defined (GPSD_API_MAJOR_VERSION)
-  vik_gps_comm(vtl, NULL, GPS_DOWN, vgl->protocol, vgl->serial_port, vgl->realtime_tracking, vvp, NULL, vgl->download_tracks, vgl->download_waypoints, FALSE);
+  vik_gps_comm(vtl, NULL, GPS_DOWN, vgl->protocol, vgl->serial_port, vgl->realtime_tracking, vvp, NULL, vgl->download_tracks, vgl->download_routes, vgl->download_waypoints, FALSE);
 #else
 #else
-  vik_gps_comm(vtl, NULL, GPS_DOWN, vgl->protocol, vgl->serial_port, FALSE, vvp, NULL, vgl->download_tracks, vgl->download_waypoints, FALSE);
+  vik_gps_comm(vtl, NULL, GPS_DOWN, vgl->protocol, vgl->serial_port, FALSE, vvp, NULL, vgl->download_tracks, vgl->download_routes, vgl->download_waypoints, FALSE);
 #endif
 }
 
 #endif
 }
 
@@ -1336,6 +1403,7 @@ static void gps_empty_upload_cb( gpointer layer_and_vlp[2] )
     return;
   vik_trw_layer_delete_all_waypoints ( vgl-> trw_children[TRW_UPLOAD]);
   vik_trw_layer_delete_all_tracks ( vgl-> trw_children[TRW_UPLOAD]);
     return;
   vik_trw_layer_delete_all_waypoints ( vgl-> trw_children[TRW_UPLOAD]);
   vik_trw_layer_delete_all_tracks ( vgl-> trw_children[TRW_UPLOAD]);
+  vik_trw_layer_delete_all_routes ( vgl-> trw_children[TRW_UPLOAD]);
 }
 
 static void gps_empty_download_cb( gpointer layer_and_vlp[2] )
 }
 
 static void gps_empty_download_cb( gpointer layer_and_vlp[2] )
@@ -1348,6 +1416,7 @@ static void gps_empty_download_cb( gpointer layer_and_vlp[2] )
     return;
   vik_trw_layer_delete_all_waypoints ( vgl-> trw_children[TRW_DOWNLOAD]);
   vik_trw_layer_delete_all_tracks ( vgl-> trw_children[TRW_DOWNLOAD]);
     return;
   vik_trw_layer_delete_all_waypoints ( vgl-> trw_children[TRW_DOWNLOAD]);
   vik_trw_layer_delete_all_tracks ( vgl-> trw_children[TRW_DOWNLOAD]);
+  vik_trw_layer_delete_all_routes ( vgl-> trw_children[TRW_DOWNLOAD]);
 }
 
 #if defined (VIK_CONFIG_REALTIME_GPS_TRACKING) && defined (GPSD_API_MAJOR_VERSION)
 }
 
 #if defined (VIK_CONFIG_REALTIME_GPS_TRACKING) && defined (GPSD_API_MAJOR_VERSION)
@@ -1374,8 +1443,10 @@ static void gps_empty_all_cb( gpointer layer_and_vlp[2] )
     return;
   vik_trw_layer_delete_all_waypoints ( vgl-> trw_children[TRW_UPLOAD]);
   vik_trw_layer_delete_all_tracks ( vgl-> trw_children[TRW_UPLOAD]);
     return;
   vik_trw_layer_delete_all_waypoints ( vgl-> trw_children[TRW_UPLOAD]);
   vik_trw_layer_delete_all_tracks ( vgl-> trw_children[TRW_UPLOAD]);
+  vik_trw_layer_delete_all_routes ( vgl-> trw_children[TRW_UPLOAD]);
   vik_trw_layer_delete_all_waypoints ( vgl-> trw_children[TRW_DOWNLOAD]);
   vik_trw_layer_delete_all_tracks ( vgl-> trw_children[TRW_DOWNLOAD]);
   vik_trw_layer_delete_all_waypoints ( vgl-> trw_children[TRW_DOWNLOAD]);
   vik_trw_layer_delete_all_tracks ( vgl-> trw_children[TRW_DOWNLOAD]);
+  vik_trw_layer_delete_all_routes ( vgl-> trw_children[TRW_DOWNLOAD]);
 #if defined (VIK_CONFIG_REALTIME_GPS_TRACKING) && defined (GPSD_API_MAJOR_VERSION)
   vik_trw_layer_delete_all_waypoints ( vgl-> trw_children[TRW_REALTIME]);
   vik_trw_layer_delete_all_tracks ( vgl-> trw_children[TRW_REALTIME]);
 #if defined (VIK_CONFIG_REALTIME_GPS_TRACKING) && defined (GPSD_API_MAJOR_VERSION)
   vik_trw_layer_delete_all_waypoints ( vgl-> trw_children[TRW_REALTIME]);
   vik_trw_layer_delete_all_tracks ( vgl-> trw_children[TRW_REALTIME]);
@@ -1395,7 +1466,8 @@ static void realtime_tracking_draw(VikGpsLayer *vgl, VikViewport *vp)
   if ( vgl->realtime_fix.fix.latitude > lse.lat &&
        vgl->realtime_fix.fix.latitude < lnw.lat &&
        vgl->realtime_fix.fix.longitude > lnw.lon &&
   if ( vgl->realtime_fix.fix.latitude > lse.lat &&
        vgl->realtime_fix.fix.latitude < lnw.lat &&
        vgl->realtime_fix.fix.longitude > lnw.lon &&
-       vgl->realtime_fix.fix.longitude < lse.lon ) {
+       vgl->realtime_fix.fix.longitude < lse.lon &&
+       !isnan (vgl->realtime_fix.fix.track) ) {
     VikCoord gps;
     gint x, y;
     gint half_back_x, half_back_y;
     VikCoord gps;
     gint x, y;
     gint half_back_x, half_back_y;
@@ -1410,8 +1482,8 @@ static void realtime_tracking_draw(VikGpsLayer *vgl, VikViewport *vp)
     vik_coord_load_from_latlon ( &gps, vik_viewport_get_coord_mode(vp), &ll);
     vik_viewport_coord_to_screen ( vp, &gps, &x, &y );
 
     vik_coord_load_from_latlon ( &gps, vik_viewport_get_coord_mode(vp), &ll);
     vik_viewport_coord_to_screen ( vp, &gps, &x, &y );
 
-    gdouble heading_cos = cos(M_PI/180*vgl->realtime_fix.fix.track);
-    gdouble heading_sin = sin(M_PI/180*vgl->realtime_fix.fix.track);
+    gdouble heading_cos = cos(DEG2RAD(vgl->realtime_fix.fix.track));
+    gdouble heading_sin = sin(DEG2RAD(vgl->realtime_fix.fix.track));
 
     half_back_y = y+8*heading_cos;
     half_back_x = x-8*heading_sin;
 
     half_back_y = y+8*heading_cos;
     half_back_x = x-8*heading_sin;
@@ -1445,7 +1517,7 @@ static void realtime_tracking_draw(VikGpsLayer *vgl, VikViewport *vp)
   }
 }
 
   }
 }
 
-static void create_realtime_trackpoint(VikGpsLayer *vgl, gboolean forced)
+static VikTrackpoint* create_realtime_trackpoint(VikGpsLayer *vgl, gboolean forced)
 {
     struct LatLon ll;
     GList *last_tp;
 {
     struct LatLon ll;
     GList *last_tp;
@@ -1456,13 +1528,13 @@ static void create_realtime_trackpoint(VikGpsLayer *vgl, gboolean forced)
     time_t last_timestamp = vgl->last_fix.fix.time;
 
     if (cur_timestamp < last_timestamp) {
     time_t last_timestamp = vgl->last_fix.fix.time;
 
     if (cur_timestamp < last_timestamp) {
-      return;
+      return NULL;
     }
 
     if (vgl->realtime_record && vgl->realtime_fix.dirty) {
       gboolean replace = FALSE;
     }
 
     if (vgl->realtime_record && vgl->realtime_fix.dirty) {
       gboolean replace = FALSE;
-      int heading = (int)floor(vgl->realtime_fix.fix.track);
-      int last_heading = (int)floor(vgl->last_fix.fix.track);
+      int heading = isnan(vgl->realtime_fix.fix.track) ? 0 : (int)floor(vgl->realtime_fix.fix.track);
+      int last_heading = isnan(vgl->last_fix.fix.track) ? 0 : (int)floor(vgl->last_fix.fix.track);
       int alt = isnan(vgl->realtime_fix.fix.altitude) ? VIK_DEFAULT_ALTITUDE : floor(vgl->realtime_fix.fix.altitude);
       int last_alt = isnan(vgl->last_fix.fix.altitude) ? VIK_DEFAULT_ALTITUDE : floor(vgl->last_fix.fix.altitude);
       if (((last_tp = g_list_last(vgl->realtime_track->trackpoints)) != NULL) &&
       int alt = isnan(vgl->realtime_fix.fix.altitude) ? VIK_DEFAULT_ALTITUDE : floor(vgl->realtime_fix.fix.altitude);
       int last_alt = isnan(vgl->last_fix.fix.altitude) ? VIK_DEFAULT_ALTITUDE : floor(vgl->last_fix.fix.altitude);
       if (((last_tp = g_list_last(vgl->realtime_track->trackpoints)) != NULL) &&
@@ -1496,12 +1568,34 @@ static void create_realtime_trackpoint(VikGpsLayer *vgl, gboolean forced)
         vik_coord_load_from_latlon(&tp->coord,
              vik_trw_layer_get_coord_mode(vgl->trw_children[TRW_REALTIME]), &ll);
 
         vik_coord_load_from_latlon(&tp->coord,
              vik_trw_layer_get_coord_mode(vgl->trw_children[TRW_REALTIME]), &ll);
 
-        vgl->realtime_track->trackpoints = g_list_append(vgl->realtime_track->trackpoints, tp);
+        vik_track_add_trackpoint ( vgl->realtime_track, tp, TRUE ); // Ensure bounds is recalculated
         vgl->realtime_fix.dirty = FALSE;
         vgl->realtime_fix.satellites_used = 0;
         vgl->last_fix = vgl->realtime_fix;
         vgl->realtime_fix.dirty = FALSE;
         vgl->realtime_fix.satellites_used = 0;
         vgl->last_fix = vgl->realtime_fix;
+        return tp;
       }
     }
       }
     }
+    return NULL;
+}
+
+#define VIK_SETTINGS_GPS_STATUSBAR_FORMAT "gps_statusbar_format"
+
+static void update_statusbar ( VikGpsLayer *vgl, VikWindow *vw )
+{
+  gchar *statusbar_format_code = NULL;
+  gboolean need2free = FALSE;
+  if ( !a_settings_get_string ( VIK_SETTINGS_GPS_STATUSBAR_FORMAT, &statusbar_format_code ) ) {
+    // Otherwise use default
+    statusbar_format_code = g_strdup ( "GSA" );
+    need2free = TRUE;
+  }
+
+  gchar *msg = vu_trackpoint_formatted_message ( statusbar_format_code, vgl->trkpt, vgl->trkpt_prev, vgl->realtime_track );
+  vik_statusbar_set_message ( vik_window_get_statusbar (vw), VIK_STATUSBAR_INFO, msg );
+  g_free ( msg );
+
+  if ( need2free )
+    g_free ( statusbar_format_code );
 
 }
 
 
 }
 
@@ -1517,8 +1611,7 @@ static void gpsd_raw_hook(VglGpsd *vgpsd, gchar *data)
 
   if ((vgpsd->gpsd.fix.mode >= MODE_2D) &&
       !isnan(vgpsd->gpsd.fix.latitude) &&
 
   if ((vgpsd->gpsd.fix.mode >= MODE_2D) &&
       !isnan(vgpsd->gpsd.fix.latitude) &&
-      !isnan(vgpsd->gpsd.fix.longitude) &&
-      !isnan(vgpsd->gpsd.fix.track)) {
+      !isnan(vgpsd->gpsd.fix.longitude)) {
 
     VikWindow *vw = VIK_WINDOW(VIK_GTK_WINDOW_FROM_LAYER(vgl));
     VikViewport *vvp = vik_window_viewport(vw);
 
     VikWindow *vw = VIK_WINDOW(VIK_GTK_WINDOW_FROM_LAYER(vgl));
     VikViewport *vvp = vik_window_viewport(vw);
@@ -1536,7 +1629,7 @@ static void gpsd_raw_hook(VglGpsd *vgpsd, gchar *data)
 
     if ((vgl->vehicle_position == VEHICLE_POSITION_CENTERED) ||
         (vgl->realtime_jump_to_start && vgl->first_realtime_trackpoint)) {
 
     if ((vgl->vehicle_position == VEHICLE_POSITION_CENTERED) ||
         (vgl->realtime_jump_to_start && vgl->first_realtime_trackpoint)) {
-      vik_viewport_set_center_coord(vvp, &vehicle_coord);
+      vik_viewport_set_center_coord(vvp, &vehicle_coord, FALSE);
       update_all = TRUE;
     }
     else if (vgl->vehicle_position == VEHICLE_POSITION_ON_SCREEN) {
       update_all = TRUE;
     }
     else if (vgl->vehicle_position == VEHICLE_POSITION_ON_SCREEN) {
@@ -1562,9 +1655,16 @@ static void gpsd_raw_hook(VglGpsd *vgpsd, gchar *data)
     }
 
     vgl->first_realtime_trackpoint = FALSE;
     }
 
     vgl->first_realtime_trackpoint = FALSE;
-    create_realtime_trackpoint(vgl, FALSE);
 
 
-    vik_layer_emit_update ( update_all ? VIK_LAYER(vgl) : VIK_LAYER(vgl->trw_children[TRW_REALTIME]), TRUE); // Yes update from background thread
+    vgl->trkpt = create_realtime_trackpoint ( vgl, FALSE );
+
+    if ( vgl->trkpt ) {
+      if ( vgl->realtime_update_statusbar )
+       update_statusbar ( vgl, vw );
+      vgl->trkpt_prev = vgl->trkpt;
+    }
+
+    vik_layer_emit_update ( update_all ? VIK_LAYER(vgl) : VIK_LAYER(vgl->trw_children[TRW_REALTIME]) ); // NB update from background thread
   }
 }
 
   }
 }
 
@@ -1746,10 +1846,12 @@ static void gps_start_stop_tracking_cb( gpointer layer_and_vlp[2])
     if (!rt_gpsd_connect(vgl, TRUE)) {
       vgl->first_realtime_trackpoint = FALSE;
       vgl->realtime_tracking = FALSE;
     if (!rt_gpsd_connect(vgl, TRUE)) {
       vgl->first_realtime_trackpoint = FALSE;
       vgl->realtime_tracking = FALSE;
+      vgl->trkpt = NULL;
     }
   }
   else {  /* stop realtime tracking */
     vgl->first_realtime_trackpoint = FALSE;
     }
   }
   else {  /* stop realtime tracking */
     vgl->first_realtime_trackpoint = FALSE;
+    vgl->trkpt = NULL;
     rt_gpsd_disconnect(vgl);
   }
 }
     rt_gpsd_disconnect(vgl);
   }
 }
Viking GPS editor