]> git.street.me.uk Git - andy/viking.git/blobdiff - src/vikgpslayer.c
When manually creating a track, automatically give it a default name.
[andy/viking.git] / src / vikgpslayer.c
index 9d78b3728f405f8a626f95a5a5e4b3c06762cc26..d3e877ba50923fdd9c047a6233d043d10d7e9ee8 100644 (file)
 #endif
 
 #include <stdlib.h>
 #endif
 
 #include <stdlib.h>
+#ifdef HAVE_MATH_H
 #include <math.h>
 #include <math.h>
+#endif
 #include "viking.h"
 #include "viking.h"
-#include "vikgpslayer_pixmap.h"
+#include "icons/icons.h"
 #include "babel.h"
 
 #include "babel.h"
 
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+#ifdef HAVE_STRING_H
 #include <string.h>
 #include <string.h>
-#include <glib.h>
+#endif
+#include <glib/gstdio.h>
 #include <glib/gprintf.h>
 #include <glib/gi18n.h>
 #ifdef VIK_CONFIG_REALTIME_GPS_TRACKING
 #include <gps.h>
 #endif
 
 #include <glib/gprintf.h>
 #include <glib/gi18n.h>
 #ifdef VIK_CONFIG_REALTIME_GPS_TRACKING
 #include <gps.h>
 #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 void vik_gps_layer_draw ( VikGpsLayer *val, gpointer data );
 #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 void vik_gps_layer_draw ( VikGpsLayer *val, gpointer data );
-VikGpsLayer *vik_gps_layer_new ();
+static VikGpsLayer *vik_gps_layer_new ( VikViewport *vp );
 
 static void gps_layer_marshall( VikGpsLayer *val, guint8 **data, gint *len );
 static VikGpsLayer *gps_layer_unmarshall( guint8 *data, gint len, VikViewport *vvp );
 
 static void gps_layer_marshall( VikGpsLayer *val, guint8 **data, gint *len );
 static VikGpsLayer *gps_layer_unmarshall( guint8 *data, gint len, VikViewport *vvp );
@@ -67,8 +80,20 @@ typedef enum {GARMIN_P = 0, MAGELLAN_P, NUM_PROTOCOLS} vik_gps_proto;
 static gchar * params_protocols[] = {"Garmin", "Magellan", NULL};
 static gchar * protocols_args[]   = {"garmin", "magellan"};
 /*#define NUM_PROTOCOLS (sizeof(params_protocols)/sizeof(params_protocols[0]) - 1) */
 static gchar * params_protocols[] = {"Garmin", "Magellan", NULL};
 static gchar * protocols_args[]   = {"garmin", "magellan"};
 /*#define NUM_PROTOCOLS (sizeof(params_protocols)/sizeof(params_protocols[0]) - 1) */
+#ifdef WINDOWS
+static gchar * params_ports[] = {"com1", "usb:", NULL};
+#else
 static gchar * params_ports[] = {"/dev/ttyS0", "/dev/ttyS1", "/dev/ttyUSB0", "/dev/ttyUSB1", "usb:", NULL};
 static gchar * params_ports[] = {"/dev/ttyS0", "/dev/ttyS1", "/dev/ttyUSB0", "/dev/ttyUSB1", "usb:", NULL};
-#define NUM_PORTS (sizeof(params_ports)/sizeof(params_ports[0]) - 1)
+#endif
+/* NUM_PORTS not actually used */
+/* #define NUM_PORTS (sizeof(params_ports)/sizeof(params_ports[0]) - 1) */
+/* Compatibility with previous versions */
+#ifdef WINDOWS
+static gchar * old_params_ports[] = {"com1", "usb:", NULL};
+#else
+static gchar * old_params_ports[] = {"/dev/ttyS0", "/dev/ttyS1", "/dev/ttyUSB0", "/dev/ttyUSB1", "usb:", NULL};
+#endif
+#define OLD_NUM_PORTS (sizeof(old_params_ports)/sizeof(old_params_ports[0]) - 1)
 typedef enum {GPS_DOWN=0, GPS_UP} gps_dir;
 
 typedef struct {
 typedef enum {GPS_DOWN=0, GPS_UP} gps_dir;
 
 typedef struct {
@@ -101,28 +126,43 @@ static gchar *params_groups[] = {
 
 enum {GROUP_DATA_MODE, GROUP_REALTIME_MODE};
 
 
 enum {GROUP_DATA_MODE, GROUP_REALTIME_MODE};
 
+#ifdef VIK_CONFIG_REALTIME_GPS_TRACKING
+static gchar *params_vehicle_position[] = {
+  "Keep vehicle at center",
+  "Keep vehicle on screen",
+  "Disable",
+  NULL
+};
+enum {
+  VEHICLE_POSITION_CENTERED = 0,
+  VEHICLE_POSITION_ON_SCREEN,
+  VEHICLE_POSITION_NONE,
+};
+#endif
+
 static VikLayerParam gps_layer_params[] = {
   { "gps_protocol", VIK_LAYER_PARAM_UINT, GROUP_DATA_MODE, N_("GPS Protocol:"), VIK_LAYER_WIDGET_COMBOBOX, params_protocols, NULL},
 static VikLayerParam gps_layer_params[] = {
   { "gps_protocol", VIK_LAYER_PARAM_UINT, GROUP_DATA_MODE, N_("GPS Protocol:"), VIK_LAYER_WIDGET_COMBOBOX, params_protocols, NULL},
-  { "gps_port", VIK_LAYER_PARAM_UINT, GROUP_DATA_MODE, N_("Serial Port:"), VIK_LAYER_WIDGET_COMBOBOX, params_ports, NULL},
+  { "gps_port", VIK_LAYER_PARAM_STRING, GROUP_DATA_MODE, N_("Serial Port:"), VIK_LAYER_WIDGET_COMBOBOX, params_ports, NULL},
 
 #ifdef VIK_CONFIG_REALTIME_GPS_TRACKING
   { "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},
 
 #ifdef VIK_CONFIG_REALTIME_GPS_TRACKING
   { "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},
-  { "centered_tracking", VIK_LAYER_PARAM_BOOLEAN, GROUP_REALTIME_MODE, N_("Keep current position at center"), 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_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},
 #endif /* VIK_CONFIG_REALTIME_GPS_TRACKING */
 };
 enum {
   PARAM_PROTOCOL=0, PARAM_PORT,
 #ifdef VIK_CONFIG_REALTIME_GPS_TRACKING
 #endif /* VIK_CONFIG_REALTIME_GPS_TRACKING */
 };
 enum {
   PARAM_PROTOCOL=0, PARAM_PORT,
 #ifdef VIK_CONFIG_REALTIME_GPS_TRACKING
-  PARAM_REALTIME_REC, PARAM_REALTIME_CENTER_START, PARAM_REALTIME_CENTERED, PARAM_GPSD_HOST, PARAM_GPSD_PORT,
+  PARAM_REALTIME_REC, PARAM_REALTIME_CENTER_START, PARAM_VEHICLE_POSITION, PARAM_GPSD_HOST, PARAM_GPSD_PORT, PARAM_GPSD_RETRY_INTERVAL,
 #endif /* VIK_CONFIG_REALTIME_GPS_TRACKING */
   NUM_PARAMS};
 
 VikLayerInterface vik_gps_layer_interface = {
   "GPS",
 #endif /* VIK_CONFIG_REALTIME_GPS_TRACKING */
   NUM_PARAMS};
 
 VikLayerInterface vik_gps_layer_interface = {
   "GPS",
-  &gpslayer_pixbuf,
+  &vikgpslayer_pixbuf,
 
   NULL,
   0,
 
   NULL,
   0,
@@ -132,7 +172,7 @@ VikLayerInterface vik_gps_layer_interface = {
   params_groups,
   sizeof(params_groups)/sizeof(params_groups[0]),
 
   params_groups,
   sizeof(params_groups)/sizeof(params_groups[0]),
 
-  VIK_MENU_ITEM_ALL & ~(VIK_MENU_ITEM_CUT|VIK_MENU_ITEM_COPY),
+  VIK_MENU_ITEM_ALL,
 
   (VikLayerFuncCreate)                  vik_gps_layer_create,
   (VikLayerFuncRealize)                 vik_gps_layer_realize,
 
   (VikLayerFuncCreate)                  vik_gps_layer_create,
   (VikLayerFuncRealize)                 vik_gps_layer_realize,
@@ -200,18 +240,17 @@ struct _VikGpsLayer {
   int cur_read_child;   /* used only for reading file */
 #ifdef VIK_CONFIG_REALTIME_GPS_TRACKING
   VglGpsd *vgpsd;
   int cur_read_child;   /* used only for reading file */
 #ifdef VIK_CONFIG_REALTIME_GPS_TRACKING
   VglGpsd *vgpsd;
-  gboolean realtime_tracking;
-  GMutex *realtime_tracking_mutex;
+  gboolean realtime_tracking;  /* set/reset only by the callback */
+  gboolean first_realtime_trackpoint;
   GpsFix realtime_fix;
   GpsFix last_fix;
 
   GpsFix realtime_fix;
   GpsFix last_fix;
 
-  enum unit realtime_gpsd_unit;
-
   VikTrack *realtime_track;
   gchar *realtime_track_name;
 
   GIOChannel *realtime_io_channel;
   guint realtime_io_watch_id;
   VikTrack *realtime_track;
   gchar *realtime_track_name;
 
   GIOChannel *realtime_io_channel;
   guint realtime_io_watch_id;
+  guint realtime_retry_timer;
   GdkGC *realtime_track_gc;
   GdkGC *realtime_track_bg_gc;
   GdkGC *realtime_track_pt_gc;
   GdkGC *realtime_track_gc;
   GdkGC *realtime_track_bg_gc;
   GdkGC *realtime_track_pt_gc;
@@ -221,12 +260,13 @@ struct _VikGpsLayer {
   /* params */
   gchar *gpsd_host;
   gchar *gpsd_port;
   /* params */
   gchar *gpsd_host;
   gchar *gpsd_port;
+  gint gpsd_retry_interval;
   gboolean realtime_record;
   gboolean realtime_jump_to_start;
   gboolean realtime_record;
   gboolean realtime_jump_to_start;
-  gboolean realtime_keep_at_center;
+  guint vehicle_position;
 #endif /* VIK_CONFIG_REALTIME_GPS_TRACKING */
   guint protocol_id;
 #endif /* VIK_CONFIG_REALTIME_GPS_TRACKING */
   guint protocol_id;
-  guint serial_port_id;
+  gchar *serial_port;
 };
 
 GType vik_gps_layer_get_type ()
 };
 
 GType vik_gps_layer_get_type ()
@@ -308,7 +348,7 @@ static VikGpsLayer *gps_layer_unmarshall( guint8 *data, gint len, VikViewport *v
   len -= sizeof(gint) + alm_size; \
   data += sizeof(gint) + alm_size;
   
   len -= sizeof(gint) + alm_size; \
   data += sizeof(gint) + alm_size;
   
-  VikGpsLayer *rv = vik_gps_layer_new();
+  VikGpsLayer *rv = vik_gps_layer_new(vvp);
   VikLayer *child_layer;
   gint i;
 
   VikLayer *child_layer;
   gint i;
 
@@ -335,7 +375,6 @@ static gboolean gps_layer_set_param ( VikGpsLayer *vgl, guint16 id, VikLayerPara
 {
   switch ( id )
   {
 {
   switch ( id )
   {
-    /* TODO: gpsd_host, gpsd_port */
     case PARAM_PROTOCOL:
       if (data.u < NUM_PROTOCOLS)
         vgl->protocol_id = data.u;
     case PARAM_PROTOCOL:
       if (data.u < NUM_PROTOCOLS)
         vgl->protocol_id = data.u;
@@ -343,8 +382,21 @@ static gboolean gps_layer_set_param ( VikGpsLayer *vgl, guint16 id, VikLayerPara
         g_warning(_("Unknown GPS Protocol"));
       break;
     case PARAM_PORT:
         g_warning(_("Unknown GPS Protocol"));
       break;
     case PARAM_PORT:
-      if (data.u < NUM_PORTS)
-        vgl->serial_port_id = data.u;
+      if (data.s)
+{
+        g_free(vgl->serial_port);
+        /* Compat: previous version stored serial_port as an array index */
+        int index = data.s[0] - '0';
+        if (data.s[0] != '\0' &&
+            g_ascii_isdigit (data.s[0]) &&
+            data.s[1] == '\0' &&
+            index < OLD_NUM_PORTS)
+          /* It is a single digit: activate compatibility */
+          vgl->serial_port = g_strdup(old_params_ports[index]);
+        else
+          vgl->serial_port = g_strdup(data.s);
+      g_debug("%s: %s", __FUNCTION__, vgl->serial_port);
+}
       else
         g_warning(_("Unknown serial port device"));
       break;
       else
         g_warning(_("Unknown serial port device"));
       break;
@@ -359,14 +411,17 @@ static gboolean gps_layer_set_param ( VikGpsLayer *vgl, guint16 id, VikLayerPara
         g_free(vgl->gpsd_port);
       vgl->gpsd_port = g_strdup(data.s); /* TODO: check for number */
       break;
         g_free(vgl->gpsd_port);
       vgl->gpsd_port = g_strdup(data.s); /* TODO: check for number */
       break;
+    case PARAM_GPSD_RETRY_INTERVAL:
+      vgl->gpsd_retry_interval = strtol(data.s, NULL, 10);
+      break;
     case PARAM_REALTIME_REC:
       vgl->realtime_record = data.b;
       break;
     case PARAM_REALTIME_CENTER_START:
       vgl->realtime_jump_to_start = data.b;
       break;
     case PARAM_REALTIME_REC:
       vgl->realtime_record = data.b;
       break;
     case PARAM_REALTIME_CENTER_START:
       vgl->realtime_jump_to_start = data.b;
       break;
-    case PARAM_REALTIME_CENTERED:
-      vgl->realtime_keep_at_center = data.b;
+    case PARAM_VEHICLE_POSITION:
+      vgl->vehicle_position = data.u;
       break;
 #endif /* VIK_CONFIG_REALTIME_GPS_TRACKING */
     default:
       break;
 #endif /* VIK_CONFIG_REALTIME_GPS_TRACKING */
     default:
@@ -381,12 +436,12 @@ static VikLayerParamData gps_layer_get_param ( VikGpsLayer *vgl, guint16 id )
   VikLayerParamData rv;
   switch ( id )
   {
   VikLayerParamData rv;
   switch ( id )
   {
-    /* TODO: gpsd_host, gpsd_port */
     case PARAM_PROTOCOL:
       rv.u = vgl->protocol_id;
       break;
     case PARAM_PORT:
     case PARAM_PROTOCOL:
       rv.u = vgl->protocol_id;
       break;
     case PARAM_PORT:
-      rv.u = vgl->serial_port_id;
+      rv.s = vgl->serial_port;
+      g_debug("%s: %s", __FUNCTION__, rv.s);
       break;
 #ifdef VIK_CONFIG_REALTIME_GPS_TRACKING
     case PARAM_GPSD_HOST:
       break;
 #ifdef VIK_CONFIG_REALTIME_GPS_TRACKING
     case PARAM_GPSD_HOST:
@@ -395,14 +450,17 @@ static VikLayerParamData gps_layer_get_param ( VikGpsLayer *vgl, guint16 id )
     case PARAM_GPSD_PORT:
       rv.s = vgl->gpsd_port ? vgl->gpsd_port : g_strdup(DEFAULT_GPSD_PORT);
       break;
     case PARAM_GPSD_PORT:
       rv.s = vgl->gpsd_port ? vgl->gpsd_port : g_strdup(DEFAULT_GPSD_PORT);
       break;
+    case PARAM_GPSD_RETRY_INTERVAL:
+      rv.s = g_strdup_printf("%d", vgl->gpsd_retry_interval);
+      break;
     case PARAM_REALTIME_REC:
       rv.b = vgl->realtime_record;
       break;
     case PARAM_REALTIME_CENTER_START:
       rv.b = vgl->realtime_jump_to_start;
       break;
     case PARAM_REALTIME_REC:
       rv.b = vgl->realtime_record;
       break;
     case PARAM_REALTIME_CENTER_START:
       rv.b = vgl->realtime_jump_to_start;
       break;
-    case PARAM_REALTIME_CENTERED:
-      rv.b = vgl->realtime_keep_at_center;
+    case PARAM_VEHICLE_POSITION:
+      rv.u = vgl->vehicle_position;
       break;
 #endif /* VIK_CONFIG_REALTIME_GPS_TRACKING */
     default:
       break;
 #endif /* VIK_CONFIG_REALTIME_GPS_TRACKING */
     default:
@@ -424,16 +482,17 @@ VikGpsLayer *vik_gps_layer_new (VikViewport *vp)
   vgl->cur_read_child = 0;
 
 #ifdef VIK_CONFIG_REALTIME_GPS_TRACKING
   vgl->cur_read_child = 0;
 
 #ifdef VIK_CONFIG_REALTIME_GPS_TRACKING
-  vgl->realtime_tracking_mutex = g_mutex_new();
   vgl->realtime_tracking = FALSE;
   vgl->realtime_tracking = FALSE;
+  vgl->first_realtime_trackpoint = FALSE;
   vgl->vgpsd = NULL;
   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;
   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_gpsd_unit = gpsd_units();
-  // fprintf(stderr, "DEBUG: gpsd_unit = %d\n", vgl->realtime_gpsd_unit);
   vgl->realtime_track = NULL;
 
   /* Setting params here */
   vgl->realtime_track = NULL;
 
   /* Setting params here */
@@ -441,10 +500,26 @@ VikGpsLayer *vik_gps_layer_new (VikViewport *vp)
   vgl->gpsd_port = g_strdup(DEFAULT_GPSD_PORT);
   vgl->realtime_record = TRUE;
   vgl->realtime_jump_to_start = TRUE;
   vgl->gpsd_port = g_strdup(DEFAULT_GPSD_PORT);
   vgl->realtime_record = TRUE;
   vgl->realtime_jump_to_start = TRUE;
-  vgl->realtime_keep_at_center = FALSE;
+  vgl->vehicle_position = VEHICLE_POSITION_ON_SCREEN;
+  vgl->gpsd_retry_interval = 10;
 #endif /* VIK_CONFIG_REALTIME_GPS_TRACKING */
   vgl->protocol_id = 0;
 #endif /* VIK_CONFIG_REALTIME_GPS_TRACKING */
   vgl->protocol_id = 0;
-  vgl->serial_port_id = 0;
+  vgl->serial_port = NULL;
+
+#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
 
   return vgl;
 }
 
   return vgl;
 }
@@ -545,7 +620,15 @@ 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 )
 {
-  g_assert(DISCONNECT_UPDATE_SIGNAL(vl,vgl)==1);
+  guint number_handlers = DISCONNECT_UPDATE_SIGNAL(vl,vgl);
+  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);
+  }
 }
 
 static void vik_gps_layer_free ( VikGpsLayer *vgl )
 }
 
 static void vik_gps_layer_free ( VikGpsLayer *vgl )
@@ -565,8 +648,6 @@ static void vik_gps_layer_free ( VikGpsLayer *vgl )
     g_object_unref(vgl->realtime_track_pt1_gc);
   if (vgl->realtime_track_pt2_gc != NULL)
     g_object_unref(vgl->realtime_track_pt2_gc);
     g_object_unref(vgl->realtime_track_pt1_gc);
   if (vgl->realtime_track_pt2_gc != NULL)
     g_object_unref(vgl->realtime_track_pt2_gc);
-  if (vgl->realtime_tracking_mutex != NULL)
-   g_mutex_free(vgl->realtime_tracking_mutex);
 #endif /* VIK_CONFIG_REALTIME_GPS_TRACKING */
 }
 
 #endif /* VIK_CONFIG_REALTIME_GPS_TRACKING */
 }
 
@@ -671,16 +752,16 @@ static void set_total_count(gint cnt, GpsSession *sess)
     if (sess->direction == GPS_DOWN)
     {
       if (sess->progress_label == sess->wp_label)
     if (sess->direction == GPS_DOWN)
     {
       if (sess->progress_label == sess->wp_label)
-        tmp_str = ngettext("Downloading %d waypoint", "Downloading %d waypoints", cnt);
+        tmp_str = ngettext("Downloading %d waypoint...", "Downloading %d waypoints...", cnt);
       else
       else
-        tmp_str = ngettext("Downloading %d trackpoint", "Downloading %d trackpoints", cnt);
+        tmp_str = ngettext("Downloading %d trackpoint...", "Downloading %d trackpoints...", cnt);
     }
     else 
     {
       if (sess->progress_label == sess->wp_label)
     }
     else 
     {
       if (sess->progress_label == sess->wp_label)
-        tmp_str = ngettext("Uploading %d waypoint", "Uploading %d waypoints", cnt);
+        tmp_str = ngettext("Uploading %d waypoint...", "Uploading %d waypoints...", cnt);
       else
       else
-        tmp_str = ngettext("Uploading %d trackpoint", "Uploading %d trackpoints", cnt);
+        tmp_str = ngettext("Uploading %d trackpoint...", "Uploading %d trackpoints...", cnt);
     }
 
     g_snprintf(s, 128, tmp_str, cnt);
     }
 
     g_snprintf(s, 128, tmp_str, cnt);
@@ -719,15 +800,15 @@ static void set_current_count(gint cnt, GpsSession *sess)
       if (sess->direction == GPS_DOWN)
       {
         if (sess->progress_label == sess->wp_label)
       if (sess->direction == GPS_DOWN)
       {
         if (sess->progress_label == sess->wp_label)
-          tmp_str = ngettext("Downloaded %d waypoint.", "Downloaded %d waypoints...", cnt);
+          tmp_str = ngettext("Downloaded %d waypoint", "Downloaded %d waypoints", cnt);
         else
         else
-          tmp_str = ngettext("Downloaded %d trackpoint.", "Downloaded %d trackpoints...", cnt);
+          tmp_str = ngettext("Downloaded %d trackpoint", "Downloaded %d trackpoints", cnt);
       }
       else {
         if (sess->progress_label == sess->wp_label)
       }
       else {
         if (sess->progress_label == sess->wp_label)
-          tmp_str = ngettext("Uploaded %d waypoint.", "Uploaded %d waypoints...", cnt);
+          tmp_str = ngettext("Uploaded %d waypoint", "Uploaded %d waypoints", cnt);
         else
         else
-          tmp_str = ngettext("Uploaded %d trackpoint.", "Uploaded %d trackpoints...", cnt);
+          tmp_str = ngettext("Uploaded %d trackpoint", "Uploaded %d trackpoints", cnt);
       }
       g_snprintf(s, 128, tmp_str, cnt);
     }    
       }
       g_snprintf(s, 128, tmp_str, cnt);
     }    
@@ -797,6 +878,18 @@ static void gps_download_progress_func(BabelProgressCode c, gpointer data, GpsSe
       }
       g_strfreev(tokens);
     }
       }
       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, "RECORD")) { 
       int lsb, msb, cnt;
 
     if (strstr(line, "RECORD")) { 
       int lsb, msb, cnt;
 
@@ -1000,14 +1093,14 @@ static void gps_upload_cb( gpointer layer_and_vlp[2] )
 {
   VikGpsLayer *vgl = (VikGpsLayer *)layer_and_vlp[0];
   VikTrwLayer *vtl = vgl->trw_children[TRW_UPLOAD];
 {
   VikGpsLayer *vgl = (VikGpsLayer *)layer_and_vlp[0];
   VikTrwLayer *vtl = vgl->trw_children[TRW_UPLOAD];
-  gps_comm(vtl, GPS_UP, vgl->protocol_id, params_ports[vgl->serial_port_id]);
+  gps_comm(vtl, GPS_UP, vgl->protocol_id, vgl->serial_port);
 }
 
 static void gps_download_cb( gpointer layer_and_vlp[2] )
 {
   VikGpsLayer *vgl = (VikGpsLayer *)layer_and_vlp[0];
   VikTrwLayer *vtl = vgl->trw_children[TRW_DOWNLOAD];
 }
 
 static void gps_download_cb( gpointer layer_and_vlp[2] )
 {
   VikGpsLayer *vgl = (VikGpsLayer *)layer_and_vlp[0];
   VikTrwLayer *vtl = vgl->trw_children[TRW_DOWNLOAD];
-  gps_comm(vtl, GPS_DOWN, vgl->protocol_id, params_ports[vgl->serial_port_id]);
+  gps_comm(vtl, GPS_DOWN, vgl->protocol_id, vgl->serial_port);
 }
 
 static void gps_empty_upload_cb( gpointer layer_and_vlp[2] )
 }
 
 static void gps_empty_upload_cb( gpointer layer_and_vlp[2] )
@@ -1034,6 +1127,9 @@ static void gps_empty_all_cb( gpointer layer_and_vlp[2] )
 }
 
 #ifdef VIK_CONFIG_REALTIME_GPS_TRACKING
 }
 
 #ifdef VIK_CONFIG_REALTIME_GPS_TRACKING
+static void rt_gpsd_disconnect(VikGpsLayer *vgl);
+static gboolean rt_gpsd_connect(VikGpsLayer *vgl, gboolean ask_if_failed);
+
 static void realtime_tracking_draw(VikGpsLayer *vgl, VikViewport *vp)
 {
   struct LatLon ll;
 static void realtime_tracking_draw(VikGpsLayer *vgl, VikViewport *vp)
 {
   struct LatLon ll;
@@ -1096,7 +1192,6 @@ static void realtime_tracking_draw(VikGpsLayer *vgl, VikViewport *vp)
   }
 }
 
   }
 }
 
-/* lock/unlock realtime_tracking_mutex when call this */
 static void create_realtime_trackpoint(VikGpsLayer *vgl, gboolean forced)
 {
     struct LatLon ll;
 static void create_realtime_trackpoint(VikGpsLayer *vgl, gboolean forced)
 {
     struct LatLon ll;
@@ -1142,7 +1237,6 @@ static void create_realtime_trackpoint(VikGpsLayer *vgl, gboolean forced)
         tp->course = vgl->realtime_fix.fix.track;
         tp->nsats = vgl->realtime_fix.satellites_used;
         tp->fix_mode = vgl->realtime_fix.fix.mode;
         tp->course = vgl->realtime_fix.fix.track;
         tp->nsats = vgl->realtime_fix.satellites_used;
         tp->fix_mode = vgl->realtime_fix.fix.mode;
-        tp->extended = TRUE;
 
         ll.lat = vgl->realtime_fix.fix.latitude;
         ll.lon = vgl->realtime_fix.fix.longitude;
 
         ll.lat = vgl->realtime_fix.fix.latitude;
         ll.lon = vgl->realtime_fix.fix.longitude;
@@ -1158,7 +1252,7 @@ static void create_realtime_trackpoint(VikGpsLayer *vgl, gboolean forced)
 
 }
 
 
 }
 
-void gpsd_raw_hook(VglGpsd *vgpsd, gchar *data)
+static void gpsd_raw_hook(VglGpsd *vgpsd, gchar *data)
 {
   gboolean update_all = FALSE;
   VikGpsLayer *vgl = vgpsd->vgl;
 {
   gboolean update_all = FALSE;
   VikGpsLayer *vgl = vgpsd->vgl;
@@ -1172,28 +1266,50 @@ void gpsd_raw_hook(VglGpsd *vgpsd, gchar *data)
       !isnan(vgpsd->gpsd.fix.latitude) &&
       !isnan(vgpsd->gpsd.fix.longitude) &&
       !isnan(vgpsd->gpsd.fix.track)) {
       !isnan(vgpsd->gpsd.fix.latitude) &&
       !isnan(vgpsd->gpsd.fix.longitude) &&
       !isnan(vgpsd->gpsd.fix.track)) {
-    g_mutex_lock(vgl->realtime_tracking_mutex);
+
+    VikWindow *vw = VIK_WINDOW(VIK_GTK_WINDOW_FROM_LAYER(vgl));
+    VikViewport *vvp = vik_window_viewport(vw);
     vgl->realtime_fix.fix = vgpsd->gpsd.fix;
     vgl->realtime_fix.satellites_used = vgpsd->gpsd.satellites_used;
     vgl->realtime_fix.dirty = TRUE;
 
     vgl->realtime_fix.fix = vgpsd->gpsd.fix;
     vgl->realtime_fix.satellites_used = vgpsd->gpsd.satellites_used;
     vgl->realtime_fix.dirty = TRUE;
 
-    if (vgl->realtime_keep_at_center ||
-        (vgl->realtime_jump_to_start && !vgl->realtime_track->trackpoints)) {
-      struct LatLon ll;
-      VikCoord center;
+    struct LatLon ll;
+    VikCoord vehicle_coord;
+
+    ll.lat = vgl->realtime_fix.fix.latitude;
+    ll.lon = vgl->realtime_fix.fix.longitude;
+    vik_coord_load_from_latlon(&vehicle_coord,
+           vik_trw_layer_get_coord_mode(vgl->trw_children[TRW_REALTIME]), &ll);
 
 
-      ll.lat = vgl->realtime_fix.fix.latitude;
-      ll.lon = vgl->realtime_fix.fix.longitude;
-      vik_coord_load_from_latlon(&center,
-             vik_trw_layer_get_coord_mode(vgl->trw_children[TRW_REALTIME]), &ll);
-      VikWindow *vw = VIK_WINDOW(VIK_GTK_WINDOW_FROM_LAYER(vgl));
-      VikViewport *vvp = vik_window_viewport(vw);
-      vik_viewport_set_center_coord(vvp, &center);
+    if ((vgl->vehicle_position == VEHICLE_POSITION_CENTERED) ||
+        (vgl->realtime_jump_to_start && vgl->first_realtime_trackpoint)) {
+      vik_viewport_set_center_coord(vvp, &vehicle_coord);
       update_all = TRUE;
     }
       update_all = TRUE;
     }
+    else if (vgl->vehicle_position == VEHICLE_POSITION_ON_SCREEN) {
+      const int hdiv = 6;
+      const int vdiv = 6;
+      const int px = 20; /* adjust ment in pixels to make sure vehicle is inside the box */
+      gint width = vik_viewport_get_width(vvp);
+      gint height = vik_viewport_get_height(vvp);
+      gint vx, vy;
+
+      vik_viewport_coord_to_screen(vvp, &vehicle_coord, &vx, &vy);
+      update_all = TRUE;
+      if (vx < (width/hdiv))
+        vik_viewport_set_center_screen(vvp, vx - width/2 + width/hdiv + px, vy);
+      else if (vx > (width - width/hdiv))
+        vik_viewport_set_center_screen(vvp, vx + width/2 - width/hdiv - px, vy);
+      else if (vy < (height/vdiv))
+        vik_viewport_set_center_screen(vvp, vx, vy - height/2 + height/vdiv + px);
+      else if (vy > (height - height/vdiv))
+        vik_viewport_set_center_screen(vvp, vx, vy + height/2 - height/vdiv - px);
+      else
+        update_all = FALSE;
+    }
 
 
+    vgl->first_realtime_trackpoint = FALSE;
     create_realtime_trackpoint(vgl, FALSE);
     create_realtime_trackpoint(vgl, FALSE);
-    g_mutex_unlock(vgl->realtime_tracking_mutex);
 
     vik_layer_emit_update ( update_all ? VIK_LAYER(vgl) : VIK_LAYER(vgl->trw_children[TRW_REALTIME]));
   }
 
     vik_layer_emit_update ( update_all ? VIK_LAYER(vgl) : VIK_LAYER(vgl->trw_children[TRW_REALTIME]));
   }
@@ -1202,8 +1318,16 @@ void gpsd_raw_hook(VglGpsd *vgpsd, gchar *data)
 static gboolean gpsd_data_available(GIOChannel *source, GIOCondition condition, gpointer data)
 {
   VikGpsLayer *vgl = data;
 static gboolean gpsd_data_available(GIOChannel *source, GIOCondition condition, gpointer data)
 {
   VikGpsLayer *vgl = data;
-  gps_poll(&vgl->vgpsd->gpsd);
-  return TRUE;
+  if (condition == G_IO_IN) {
+    if (!gps_poll(&vgl->vgpsd->gpsd))
+      return TRUE;
+    else {
+      g_warning("Disconnected from gpsd. Trying to reconnect");
+      rt_gpsd_disconnect(vgl);
+      rt_gpsd_connect(vgl, FALSE);
+    }
+  }
+  return FALSE; /* no further calling */
 }
 
 static gchar *make_track_name(VikTrwLayer *vtl)
 }
 
 static gchar *make_track_name(VikTrwLayer *vtl)
@@ -1222,6 +1346,119 @@ static gchar *make_track_name(VikTrwLayer *vtl)
 
 }
 
 
 }
 
+static gboolean rt_gpsd_try_connect(gpointer *data)
+{
+  VikGpsLayer *vgl = (VikGpsLayer *)data;
+#ifndef HAVE_GPS_OPEN_R
+  struct gps_data_t *gpsd = gps_open(vgl->gpsd_host, vgl->gpsd_port);
+
+  if (gpsd == NULL) {
+#else
+  vgl->vgpsd = g_malloc(sizeof(VglGpsd));
+
+  if (gps_open_r(vgl->gpsd_host, vgl->gpsd_port, /*(struct gps_data_t *)*/vgl->vgpsd) != 0) {
+#endif
+    g_warning("Failed to connect to gpsd at %s (port %s). Will retry in %d seconds",
+                     vgl->gpsd_host, vgl->gpsd_port, vgl->gpsd_retry_interval);
+    return TRUE;   /* keep timer running */
+  }
+
+#ifndef HAVE_GPS_OPEN_R
+  vgl->vgpsd = realloc(gpsd, sizeof(VglGpsd));
+#endif
+  vgl->vgpsd->vgl = vgl;
+
+  vgl->realtime_fix.dirty = vgl->last_fix.dirty = FALSE;
+  /* track alt/time graph uses VIK_DEFAULT_ALTITUDE (0.0) as invalid */
+  vgl->realtime_fix.fix.altitude = vgl->last_fix.fix.altitude = VIK_DEFAULT_ALTITUDE;
+  vgl->realtime_fix.fix.speed = vgl->last_fix.fix.speed = NAN;
+
+  if (vgl->realtime_record) {
+    VikTrwLayer *vtl = vgl->trw_children[TRW_REALTIME];
+    vgl->realtime_track = vik_track_new();
+    vgl->realtime_track->visible = TRUE;
+    vgl->realtime_track_name = make_track_name(vtl);
+    vik_trw_layer_add_track(vtl, vgl->realtime_track_name, vgl->realtime_track);
+  }
+
+  gps_set_raw_hook(&vgl->vgpsd->gpsd, gpsd_raw_hook);
+  vgl->realtime_io_channel = g_io_channel_unix_new(vgl->vgpsd->gpsd.gps_fd);
+  vgl->realtime_io_watch_id = g_io_add_watch( vgl->realtime_io_channel,
+                    G_IO_IN | G_IO_ERR | G_IO_HUP, gpsd_data_available, vgl);
+#if HAVE_GPS_STREAM
+  gps_stream(&vgl->vgpsd->gpsd, WATCH_ENABLE, NULL);
+#else
+  gps_query(&vgl->vgpsd->gpsd, "w+x");
+#endif
+  return FALSE;  /* no longer called by timeout */
+}
+
+static gboolean rt_ask_retry(VikGpsLayer *vgl)
+{
+  GtkWidget *dialog = gtk_message_dialog_new (VIK_GTK_WINDOW_FROM_LAYER(vgl),
+                          GTK_DIALOG_DESTROY_WITH_PARENT,
+                          GTK_MESSAGE_QUESTION,
+                          GTK_BUTTONS_YES_NO,
+                          "Failed to connect to gpsd at %s (port %s)\n"
+                          "Should Viking keep trying (every %d seconds)?",
+                          vgl->gpsd_host, vgl->gpsd_port,
+                          vgl->gpsd_retry_interval);
+
+  gint res = gtk_dialog_run(GTK_DIALOG(dialog));
+  gtk_widget_destroy(dialog);
+  return (res == GTK_RESPONSE_YES);
+}
+
+static gboolean rt_gpsd_connect(VikGpsLayer *vgl, gboolean ask_if_failed)
+{
+  vgl->realtime_retry_timer = 0;
+  if (rt_gpsd_try_connect((gpointer *)vgl)) {
+    if (vgl->gpsd_retry_interval <= 0) {
+      g_warning("Failed to connect to gpsd but will not retry because retry intervel was set to %d (which is 0 or negative)", vgl->gpsd_retry_interval);
+      return FALSE;
+    }
+    else if (ask_if_failed && !rt_ask_retry(vgl))
+      return FALSE;
+    else
+      vgl->realtime_retry_timer = g_timeout_add_seconds(vgl->gpsd_retry_interval,
+        (GSourceFunc)rt_gpsd_try_connect, (gpointer *)vgl);
+  }
+  return TRUE;
+}
+
+static void rt_gpsd_disconnect(VikGpsLayer *vgl)
+{
+  if (vgl->realtime_io_watch_id) {
+    g_source_remove(vgl->realtime_io_watch_id);
+    vgl->realtime_io_watch_id = 0;
+  }
+  if (vgl->realtime_retry_timer) {
+    g_source_remove(vgl->realtime_retry_timer);
+    vgl->realtime_retry_timer = 0;
+  }
+  if (vgl->realtime_io_channel) {
+    GError *error = NULL;
+    g_io_channel_shutdown (vgl->realtime_io_channel, FALSE, &error);
+    vgl->realtime_io_channel = NULL;
+  }
+  if (vgl->vgpsd) {
+    gps_close(&vgl->vgpsd->gpsd);
+#ifdef HAVE_GPS_OPEN_R
+    g_free(vgl->vgpsd);
+#else
+    free(vgl->vgpsd);
+#endif
+    vgl->vgpsd = NULL;
+  }
+
+  if (vgl->realtime_record && vgl->realtime_track) {
+    create_realtime_trackpoint(vgl, TRUE);
+    if ((vgl->realtime_track->trackpoints == NULL) || (vgl->realtime_track->trackpoints->next == NULL))
+      vik_trw_layer_delete_track(vgl->trw_children[TRW_REALTIME], vgl->realtime_track_name);
+    vgl->realtime_track = NULL;
+  }
+}
+
 static void gps_start_stop_tracking_cb( gpointer layer_and_vlp[2])
 {
   VikGpsLayer *vgl = (VikGpsLayer *)layer_and_vlp[0];
 static void gps_start_stop_tracking_cb( gpointer layer_and_vlp[2])
 {
   VikGpsLayer *vgl = (VikGpsLayer *)layer_and_vlp[0];
@@ -1231,59 +1468,15 @@ static void gps_start_stop_tracking_cb( gpointer layer_and_vlp[2])
   g_assert((VIK_GPS_MODE_2D == MODE_2D) && (VIK_GPS_MODE_3D == MODE_3D));
 
   if (vgl->realtime_tracking) {
   g_assert((VIK_GPS_MODE_2D == MODE_2D) && (VIK_GPS_MODE_3D == MODE_3D));
 
   if (vgl->realtime_tracking) {
-    struct gps_data_t *gpsd = gps_open(vgl->gpsd_host, vgl->gpsd_port);
-    if (gpsd == NULL) {
-      GtkWidget *dialog = gtk_message_dialog_new (VIK_GTK_WINDOW_FROM_LAYER(vgl),
-                                  GTK_DIALOG_DESTROY_WITH_PARENT,
-                                  GTK_MESSAGE_ERROR,
-                                  GTK_BUTTONS_CLOSE,
-                                  "Failed to connect to gpsd at %s (port %s)",
-                                  vgl->gpsd_host, vgl->gpsd_port);
-      gtk_dialog_run (GTK_DIALOG (dialog));
-      gtk_widget_destroy (dialog);
-
+    vgl->first_realtime_trackpoint = TRUE;
+    if (!rt_gpsd_connect(vgl, TRUE)) {
+      vgl->first_realtime_trackpoint = FALSE;
       vgl->realtime_tracking = FALSE;
       vgl->realtime_tracking = FALSE;
-      return;
-    }
-    vgl->vgpsd = g_realloc(gpsd, sizeof(VglGpsd));
-    vgl->vgpsd->vgl = vgl;
-
-    vgl->realtime_fix.dirty = vgl->last_fix.dirty = FALSE;
-    /* track alt/time graph uses VIK_DEFAULT_ALTITUDE (0.0) as invalid */
-    vgl->realtime_fix.fix.altitude = vgl->last_fix.fix.altitude = VIK_DEFAULT_ALTITUDE;
-    vgl->realtime_fix.fix.speed = vgl->last_fix.fix.speed = NAN;
-
-    if (vgl->realtime_record) {
-      VikTrwLayer *vtl = vgl->trw_children[TRW_REALTIME];
-      vgl->realtime_track = vik_track_new();
-      vgl->realtime_track->visible = TRUE;
-      vgl->realtime_track_name = make_track_name(vtl);
-      vik_trw_layer_add_track(vtl, vgl->realtime_track_name, vgl->realtime_track);
     }
     }
-
-    gps_set_raw_hook(&vgl->vgpsd->gpsd, gpsd_raw_hook);
-    vgl->realtime_io_channel = g_io_channel_unix_new(vgl->vgpsd->gpsd.gps_fd);
-    vgl->realtime_io_watch_id = g_io_add_watch( vgl->realtime_io_channel,
-                                           G_IO_IN, gpsd_data_available, vgl);
-
-    gps_query(&vgl->vgpsd->gpsd, "w+x");
-
   }
   else {  /* stop realtime tracking */
   }
   else {  /* stop realtime tracking */
-    /* TODO: handle race condition here , make sure vgpsd is NULL */
-    g_mutex_lock(vgl->realtime_tracking_mutex);
-    gps_close(&vgl->vgpsd->gpsd);
-    vgl->vgpsd = NULL;
-    // g_source_remove(vgl->realtime_timeout);
-    g_source_remove(vgl->realtime_io_watch_id);
-    g_io_channel_unref (vgl->realtime_io_channel);
-
-    if (vgl->realtime_record) {
-      create_realtime_trackpoint(vgl, TRUE);
-      if ((vgl->realtime_track->trackpoints == NULL) || (vgl->realtime_track->trackpoints->next == NULL))
-        vik_trw_layer_delete_track(vgl->trw_children[TRW_REALTIME], vgl->realtime_track_name);
-    }
-    g_mutex_unlock(vgl->realtime_tracking_mutex);
+    vgl->first_realtime_trackpoint = FALSE;
+    rt_gpsd_disconnect(vgl);
   }
 }
 #endif /* VIK_CONFIG_REALTIME_GPS_TRACKING */
   }
 }
 #endif /* VIK_CONFIG_REALTIME_GPS_TRACKING */