src/vikgpslayer.c

   1 /*
   2  * viking -- GPS Data and Topo Analyzer, Explorer, and Manager
   3  *
   4  * Copyright (C) 2003-2005, Evan Battaglia <gtoevan@gmx.net>
   5  * Copyright (C) 2006-2008, Quy Tonthat <qtonthat@gmail.com>
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20  *
  21  */
  22
  23 #ifdef HAVE_CONFIG_H
  24 #include "config.h"
  25 #endif
  26
  27 #include <stdlib.h>
  28 #ifdef HAVE_MATH_H
  29 #include <math.h>
  30 #endif
  31 #include "viking.h"
  32 #include "icons/icons.h"
  33 #include "babel.h"
  34
  35 #ifdef HAVE_UNISTD_H
  36 #include <unistd.h>
  37 #endif
  38 #ifdef HAVE_STRING_H
  39 #include <string.h>
  40 #endif
  41 #include <glib/gstdio.h>
  42 #include <glib/gprintf.h>
  43 #include <glib/gi18n.h>
  44 #ifdef VIK_CONFIG_REALTIME_GPS_TRACKING
  45 #include <gps.h>
  46 #endif
  47
  48 #define DISCONNECT_UPDATE_SIGNAL(vl, val) g_signal_handlers_disconnect_matched(vl, G_SIGNAL_MATCH_DATA, 0, 0, 0, 0, val)
  49 static VikGpsLayer *vik_gps_layer_create (VikViewport *vp);
  50 static void vik_gps_layer_realize ( VikGpsLayer *val, VikTreeview *vt, GtkTreeIter *layer_iter );
  51 static void vik_gps_layer_free ( VikGpsLayer *val );
  52 static void vik_gps_layer_draw ( VikGpsLayer *val, VikViewport *vp );
  53 static VikGpsLayer *vik_gps_layer_new ( VikViewport *vp );
  54
  55 static void gps_layer_marshall( VikGpsLayer *val, guint8 **data, gint *len );
  56 static VikGpsLayer *gps_layer_unmarshall( guint8 *data, gint len, VikViewport *vvp );
  57 static gboolean gps_layer_set_param ( VikGpsLayer *vgl, guint16 id, VikLayerParamData data, VikViewport *vp, gboolean is_file_operation );
  58 static VikLayerParamData gps_layer_get_param ( VikGpsLayer *vgl, guint16 id, gboolean is_file_operation );
  59
  60 static const gchar* gps_layer_tooltip ( VikGpsLayer *vgl );
  61
  62 static void gps_layer_change_coord_mode ( VikGpsLayer *val, VikCoordMode mode );
  63 static void gps_layer_add_menu_items( VikGpsLayer *vtl, GtkMenu *menu, gpointer vlp );
  64 static void gps_layer_drag_drop_request ( VikGpsLayer *val_src, VikGpsLayer *val_dest, GtkTreeIter *src_item_iter, GtkTreePath *dest_path );
  65
  66 static void gps_upload_cb( gpointer layer_and_vlp[2] );
  67 static void gps_download_cb( gpointer layer_and_vlp[2] );
  68 static void gps_empty_upload_cb( gpointer layer_and_vlp[2] );
  69 static void gps_empty_download_cb( gpointer layer_and_vlp[2] );
  70 static void gps_empty_all_cb( gpointer layer_and_vlp[2] );
  71 #if defined (VIK_CONFIG_REALTIME_GPS_TRACKING) && defined (GPSD_API_MAJOR_VERSION)
  72 static void gps_empty_realtime_cb( gpointer layer_and_vlp[2] );
  73 static void gps_start_stop_tracking_cb( gpointer layer_and_vlp[2] );
  74 static void realtime_tracking_draw(VikGpsLayer *vgl, VikViewport *vp);
  75 static void rt_gpsd_disconnect(VikGpsLayer *vgl);
  76 static gboolean rt_gpsd_connect(VikGpsLayer *vgl, gboolean ask_if_failed);
  77 #endif
  78
  79 // Shouldn't need to use these much any more as the protocol is now saved as a string.
  80 // They are kept for compatibility loading old .vik files
  81 typedef enum {GARMIN_P = 0, MAGELLAN_P, DELORME_P, NAVILINK_P, OLD_NUM_PROTOCOLS} vik_gps_proto;
  82 static gchar * protocols_args[]   = {"garmin", "magellan", "delbin", "navilink", NULL};
  83 #ifdef WINDOWS
  84 static gchar * params_ports[] = {"com1", "usb:", NULL};
  85 #else
  86 static gchar * params_ports[] = {"/dev/ttyS0", "/dev/ttyS1", "/dev/ttyUSB0", "/dev/ttyUSB1", "usb:", NULL};
  87 #endif
  88 /* NUM_PORTS not actually used */
  89 /* #define NUM_PORTS (sizeof(params_ports)/sizeof(params_ports[0]) - 1) */
  90 /* Compatibility with previous versions */
  91 #ifdef WINDOWS
  92 static gchar * old_params_ports[] = {"com1", "usb:", NULL};
  93 #else
  94 static gchar * old_params_ports[] = {"/dev/ttyS0", "/dev/ttyS1", "/dev/ttyUSB0", "/dev/ttyUSB1", "usb:", NULL};
  95 #endif
  96 #define OLD_NUM_PORTS (sizeof(old_params_ports)/sizeof(old_params_ports[0]) - 1)
  97
  98 typedef struct {
  99   GMutex *mutex;
 100   vik_gps_dir direction;
 101   gchar *port;
 102   gboolean ok;
 103   gint total_count;
 104   gint count;
 105   VikTrwLayer *vtl;
 106   VikTrack *track;
 107   gchar *cmd_args;
 108   gchar *window_title;
 109   GtkWidget *dialog;
 110   GtkWidget *status_label;
 111   GtkWidget *gps_label;
 112   GtkWidget *ver_label;
 113   GtkWidget *id_label;
 114   GtkWidget *wp_label;
 115   GtkWidget *trk_label;
 116   GtkWidget *rte_label;
 117   GtkWidget *progress_label;
 118   vik_gps_xfer_type progress_type;
 119   VikViewport *vvp;
 120 #if defined (VIK_CONFIG_REALTIME_GPS_TRACKING) && defined (GPSD_API_MAJOR_VERSION)
 121   gboolean realtime_tracking;
 122 #endif
 123 } GpsSession;
 124 static void gps_session_delete(GpsSession *sess);
 125
 126 static gchar *params_groups[] = {
 127   N_("Data Mode"),
 128 #if defined (VIK_CONFIG_REALTIME_GPS_TRACKING) && defined (GPSD_API_MAJOR_VERSION)
 129   N_("Realtime Tracking Mode"),
 130 #endif
 131 };
 132
 133 enum {GROUP_DATA_MODE, GROUP_REALTIME_MODE};
 134
 135
 136 static VikLayerParamData gps_protocol_default ( void )
 137 {
 138   VikLayerParamData data;
 139   data.s = g_strdup ( "garmin" );
 140   return data;
 141 }
 142
 143 static VikLayerParamData gps_port_default ( void )
 144 {
 145   VikLayerParamData data;
 146   data.s = g_strdup ( "usb:" );
 147 #ifndef WINDOWS
 148   /* Attempt to auto set default USB serial port entry */
 149   /* Ordered to make lowest device favourite if available */
 150   if (g_access ("/dev/ttyUSB1", R_OK) == 0) {
 151         if ( data.s )
 152           g_free ( (gchar *)data.s );
 153     data.s = g_strdup ("/dev/ttyUSB1");
 154   }
 155   if (g_access ("/dev/ttyUSB0", R_OK) == 0) {
 156         if ( data.s )
 157           g_free ( (gchar *)data.s );
 158     data.s = g_strdup ("/dev/ttyUSB0");
 159   }
 160 #endif
 161   return data;
 162 }
 163
 164 #if defined (VIK_CONFIG_REALTIME_GPS_TRACKING) && defined (GPSD_API_MAJOR_VERSION)
 165 static gchar *params_vehicle_position[] = {
 166   N_("Keep vehicle at center"),
 167   N_("Keep vehicle on screen"),
 168   N_("Disable"),
 169   NULL
 170 };
 171 enum {
 172   VEHICLE_POSITION_CENTERED = 0,
 173   VEHICLE_POSITION_ON_SCREEN,
 174   VEHICLE_POSITION_NONE,
 175 };
 176
 177 static VikLayerParamData moving_map_method_default ( void ) { return VIK_LPD_UINT ( VEHICLE_POSITION_ON_SCREEN ); }
 178
 179 static VikLayerParamData gpsd_host_default ( void )
 180 {
 181   VikLayerParamData data;
 182   data.s = g_strdup ( "localhost" );
 183   return data;
 184 }
 185
 186 static VikLayerParamData gpsd_port_default ( void )
 187 {
 188   VikLayerParamData data;
 189   data.s = g_strdup ( DEFAULT_GPSD_PORT );
 190   return data;
 191 }
 192
 193 static VikLayerParamData gpsd_retry_interval_default ( void )
 194 {
 195   VikLayerParamData data;
 196   data.s = g_strdup ( "10" );
 197   return data;
 198 }
 199
 200 #endif
 201
 202 static VikLayerParam gps_layer_params[] = {
 203  //     NB gps_layer_inst_init() is performed after parameter registeration
 204  //  thus to give the protocols some potential values use the old static list
 205  // TODO: find another way to use gps_layer_inst_init()?
 206   { 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 }, // List reassigned at runtime
 207   { 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 },
 208   { 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 },
 209   { 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 },
 210   { 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 },
 211   { 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 },
 212   { 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 },
 213   { 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 },
 214 #if defined (VIK_CONFIG_REALTIME_GPS_TRACKING) && defined (GPSD_API_MAJOR_VERSION)
 215   { 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 },
 216   { 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 },
 217   { 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 },
 218   { 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 },
 219   { 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 },
 220   { 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 },
 221 #endif /* VIK_CONFIG_REALTIME_GPS_TRACKING */
 222 };
 223 enum {
 224   PARAM_PROTOCOL=0, PARAM_PORT,
 225   PARAM_DOWNLOAD_TRACKS, PARAM_UPLOAD_TRACKS,
 226   PARAM_DOWNLOAD_ROUTES, PARAM_UPLOAD_ROUTES,
 227   PARAM_DOWNLOAD_WAYPOINTS, PARAM_UPLOAD_WAYPOINTS,
 228 #if defined (VIK_CONFIG_REALTIME_GPS_TRACKING) && defined (GPSD_API_MAJOR_VERSION)
 229   PARAM_REALTIME_REC, PARAM_REALTIME_CENTER_START, PARAM_VEHICLE_POSITION, PARAM_GPSD_HOST, PARAM_GPSD_PORT, PARAM_GPSD_RETRY_INTERVAL,
 230 #endif /* VIK_CONFIG_REALTIME_GPS_TRACKING */
 231   NUM_PARAMS};
 232
 233 VikLayerInterface vik_gps_layer_interface = {
 234   "GPS",
 235   N_("GPS"),
 236   NULL,
 237   &vikgpslayer_pixbuf,
 238
 239   NULL,
 240   0,
 241
 242   gps_layer_params,
 243   NUM_PARAMS,
 244   params_groups,
 245   sizeof(params_groups)/sizeof(params_groups[0]),
 246
 247   VIK_MENU_ITEM_ALL,
 248
 249   (VikLayerFuncCreate)                  vik_gps_layer_create,
 250   (VikLayerFuncRealize)                 vik_gps_layer_realize,
 251   (VikLayerFuncPostRead)                NULL,
 252   (VikLayerFuncFree)                    vik_gps_layer_free,
 253
 254   (VikLayerFuncProperties)              NULL,
 255   (VikLayerFuncDraw)                    vik_gps_layer_draw,
 256   (VikLayerFuncChangeCoordMode)         gps_layer_change_coord_mode,
 257
 258   (VikLayerFuncSetMenuItemsSelection)   NULL,
 259   (VikLayerFuncGetMenuItemsSelection)   NULL,
 260
 261   (VikLayerFuncAddMenuItems)            gps_layer_add_menu_items,
 262   (VikLayerFuncSublayerAddMenuItems)    NULL,
 263
 264   (VikLayerFuncSublayerRenameRequest)   NULL,
 265   (VikLayerFuncSublayerToggleVisible)   NULL,
 266   (VikLayerFuncSublayerTooltip)         NULL,
 267   (VikLayerFuncLayerTooltip)            gps_layer_tooltip,
 268   (VikLayerFuncLayerSelected)           NULL,
 269
 270   (VikLayerFuncMarshall)                gps_layer_marshall,
 271   (VikLayerFuncUnmarshall)              gps_layer_unmarshall,
 272
 273   (VikLayerFuncSetParam)                gps_layer_set_param,
 274   (VikLayerFuncGetParam)                gps_layer_get_param,
 275
 276   (VikLayerFuncReadFileData)            NULL,
 277   (VikLayerFuncWriteFileData)           NULL,
 278
 279   (VikLayerFuncDeleteItem)              NULL,
 280   (VikLayerFuncCutItem)                 NULL,
 281   (VikLayerFuncCopyItem)                NULL,
 282   (VikLayerFuncPasteItem)               NULL,
 283   (VikLayerFuncFreeCopiedItem)          NULL,
 284   (VikLayerFuncDragDropRequest)         gps_layer_drag_drop_request,
 285
 286   (VikLayerFuncSelectClick)             NULL,
 287   (VikLayerFuncSelectMove)              NULL,
 288   (VikLayerFuncSelectRelease)           NULL,
 289   (VikLayerFuncSelectedViewportMenu)    NULL,
 290 };
 291
 292 enum {TRW_DOWNLOAD=0, TRW_UPLOAD,
 293 #if defined (VIK_CONFIG_REALTIME_GPS_TRACKING) && defined (GPSD_API_MAJOR_VERSION)
 294   TRW_REALTIME,
 295 #endif
 296   NUM_TRW};
 297 static gchar * trw_names[] = {
 298   N_("GPS Download"), N_("GPS Upload"),
 299 #if defined (VIK_CONFIG_REALTIME_GPS_TRACKING) && defined (GPSD_API_MAJOR_VERSION)
 300   N_("GPS Realtime Tracking"),
 301 #endif
 302 };
 303
 304 #if defined (VIK_CONFIG_REALTIME_GPS_TRACKING) && defined (GPSD_API_MAJOR_VERSION)
 305 typedef struct {
 306   struct gps_data_t gpsd;
 307   VikGpsLayer *vgl;
 308 } VglGpsd;
 309
 310 typedef struct {
 311   struct gps_fix_t fix;
 312   gint satellites_used;
 313   gboolean dirty;   /* needs to be saved */
 314 } GpsFix;
 315 #endif /* VIK_CONFIG_REALTIME_GPS_TRACKING */
 316
 317 struct _VikGpsLayer {
 318   VikLayer vl;
 319   VikTrwLayer * trw_children[NUM_TRW];
 320   GList * children;     /* used only for writing file */
 321   int cur_read_child;   /* used only for reading file */
 322 #if defined (VIK_CONFIG_REALTIME_GPS_TRACKING) && defined (GPSD_API_MAJOR_VERSION)
 323   VglGpsd *vgpsd;
 324   gboolean realtime_tracking;  /* set/reset only by the callback */
 325   gboolean first_realtime_trackpoint;
 326   GpsFix realtime_fix;
 327   GpsFix last_fix;
 328
 329   VikTrack *realtime_track;
 330
 331   GIOChannel *realtime_io_channel;
 332   guint realtime_io_watch_id;
 333   guint realtime_retry_timer;
 334   GdkGC *realtime_track_gc;
 335   GdkGC *realtime_track_bg_gc;
 336   GdkGC *realtime_track_pt_gc;
 337   GdkGC *realtime_track_pt1_gc;
 338   GdkGC *realtime_track_pt2_gc;
 339
 340   /* params */
 341   gchar *gpsd_host;
 342   gchar *gpsd_port;
 343   gint gpsd_retry_interval;
 344   gboolean realtime_record;
 345   gboolean realtime_jump_to_start;
 346   guint vehicle_position;
 347 #endif /* VIK_CONFIG_REALTIME_GPS_TRACKING */
 348   gchar *protocol;
 349   gchar *serial_port;
 350   gboolean download_tracks;
 351   gboolean download_routes;
 352   gboolean download_waypoints;
 353   gboolean upload_tracks;
 354   gboolean upload_routes;
 355   gboolean upload_waypoints;
 356 };
 357
 358 /**
 359  * Overwrite the static setup with dynamically generated GPS Babel device list
 360  */
 361 static void gps_layer_inst_init ( VikGpsLayer *self )
 362 {
 363   gint new_proto = 0;
 364   // +1 for luck (i.e the NULL terminator)
 365   gchar **new_protocols = g_malloc(1 + g_list_length(a_babel_device_list)*sizeof(gpointer));
 366
 367   GList *gl = g_list_first ( a_babel_device_list );
 368   while ( gl ) {
 369     // should be using label property but use name for now
 370     //  thus don't need to mess around converting label to name later on
 371     new_protocols[new_proto++] = ((BabelDevice*)gl->data)->name;
 372     gl = g_list_next ( gl );
 373   }
 374   new_protocols[new_proto] = NULL;
 375
 376   vik_gps_layer_interface.params[PARAM_PROTOCOL].widget_data = new_protocols;
 377 }
 378
 379 GType vik_gps_layer_get_type ()
 380 {
 381   static GType val_type = 0;
 382
 383   if (!val_type)
 384   {
 385     static const GTypeInfo val_info =
 386     {
 387       sizeof (VikGpsLayerClass),
 388       NULL, /* base_init */
 389       NULL, /* base_finalize */
 390       NULL, /* class init */
 391       NULL, /* class_finalize */
 392       NULL, /* class_data */
 393       sizeof (VikGpsLayer),
 394       0,
 395       (GInstanceInitFunc) gps_layer_inst_init,
 396     };
 397     val_type = g_type_register_static ( VIK_LAYER_TYPE, "VikGpsLayer", &val_info, 0 );
 398   }
 399
 400   return val_type;
 401 }
 402
 403 static VikGpsLayer *vik_gps_layer_create (VikViewport *vp)
 404 {
 405   int i;
 406
 407   VikGpsLayer *rv = vik_gps_layer_new (vp);
 408   vik_layer_rename ( VIK_LAYER(rv), vik_gps_layer_interface.name );
 409
 410   for (i = 0; i < NUM_TRW; i++) {
 411     rv->trw_children[i] = VIK_TRW_LAYER(vik_layer_create ( VIK_LAYER_TRW, vp, NULL, FALSE ));
 412     vik_layer_set_menu_items_selection(VIK_LAYER(rv->trw_children[i]), VIK_MENU_ITEM_ALL & ~(VIK_MENU_ITEM_CUT|VIK_MENU_ITEM_DELETE));
 413   }
 414   return rv;
 415 }
 416
 417 static const gchar* gps_layer_tooltip ( VikGpsLayer *vgl )
 418 {
 419   return vgl->protocol;
 420 }
 421
 422 /* "Copy" */
 423 static void gps_layer_marshall( VikGpsLayer *vgl, guint8 **data, gint *datalen )
 424 {
 425   VikLayer *child_layer;
 426   guint8 *ld;
 427   gint ll;
 428   GByteArray* b = g_byte_array_new ();
 429   gint len;
 430   gint i;
 431
 432 #define alm_append(obj, sz)     \
 433   len = (sz);                   \
 434   g_byte_array_append ( b, (guint8 *)&len, sizeof(len) );       \
 435   g_byte_array_append ( b, (guint8 *)(obj), len );
 436
 437   vik_layer_marshall_params(VIK_LAYER(vgl), &ld, &ll);
 438   alm_append(ld, ll);
 439   g_free(ld);
 440
 441   for (i = 0; i < NUM_TRW; i++) {
 442     child_layer = VIK_LAYER(vgl->trw_children[i]);
 443     vik_layer_marshall(child_layer, &ld, &ll);
 444     if (ld) {
 445       alm_append(ld, ll);
 446       g_free(ld);
 447     }
 448   }
 449   *data = b->data;
 450   *datalen = b->len;
 451   g_byte_array_free(b, FALSE);
 452 #undef alm_append
 453 }
 454
 455 /* "Paste" */
 456 static VikGpsLayer *gps_layer_unmarshall( guint8 *data, gint len, VikViewport *vvp )
 457 {
 458 #define alm_size (*(gint *)data)
 459 #define alm_next \
 460   len -= sizeof(gint) + alm_size; \
 461   data += sizeof(gint) + alm_size;
 462
 463   VikGpsLayer *rv = vik_gps_layer_new(vvp);
 464   VikLayer *child_layer;
 465   gint i;
 466
 467   vik_layer_unmarshall_params ( VIK_LAYER(rv), data+sizeof(gint), alm_size, vvp );
 468   alm_next;
 469
 470   i = 0;
 471   while (len>0 && i < NUM_TRW) {
 472     child_layer = vik_layer_unmarshall ( data + sizeof(gint), alm_size, vvp );
 473     if (child_layer) {
 474       rv->trw_children[i++] = (VikTrwLayer *)child_layer;
 475       g_signal_connect_swapped ( G_OBJECT(child_layer), "update", G_CALLBACK(vik_layer_emit_update_secondary), rv );
 476     }
 477     alm_next;
 478   }
 479   //  g_print("gps_layer_unmarshall ended with len=%d\n", len);
 480   g_assert(len == 0);
 481   return rv;
 482 #undef alm_size
 483 #undef alm_next
 484 }
 485
 486 static gboolean gps_layer_set_param ( VikGpsLayer *vgl, guint16 id, VikLayerParamData data, VikViewport *vp, gboolean is_file_operation )
 487 {
 488   switch ( id )
 489   {
 490     case PARAM_PROTOCOL:
 491       if (data.s) {
 492         g_free(vgl->protocol);
 493         // Backwards Compatibility: previous versions <v1.4 stored protocol as an array index
 494         int index = data.s[0] - '0';
 495         if (data.s[0] != '\0' &&
 496             g_ascii_isdigit (data.s[0]) &&
 497             data.s[1] == '\0' &&
 498             index < OLD_NUM_PROTOCOLS)
 499           // It is a single digit: activate compatibility
 500           vgl->protocol = g_strdup(protocols_args[index]);
 501         else
 502           vgl->protocol = g_strdup(data.s);
 503         g_debug("%s: %s", __FUNCTION__, vgl->protocol);
 504       }
 505       else
 506         g_warning(_("Unknown GPS Protocol"));
 507       break;
 508     case PARAM_PORT:
 509       if (data.s) {
 510         g_free(vgl->serial_port);
 511         // Backwards Compatibility: previous versions <v0.9.91 stored serial_port as an array index
 512         int index = data.s[0] - '0';
 513         if (data.s[0] != '\0' &&
 514             g_ascii_isdigit (data.s[0]) &&
 515             data.s[1] == '\0' &&
 516             index < OLD_NUM_PORTS)
 517           /* It is a single digit: activate compatibility */
 518           vgl->serial_port = g_strdup(old_params_ports[index]);
 519         else
 520           vgl->serial_port = g_strdup(data.s);
 521         g_debug("%s: %s", __FUNCTION__, vgl->serial_port);
 522       }
 523       else
 524         g_warning(_("Unknown serial port device"));
 525       break;
 526     case PARAM_DOWNLOAD_TRACKS:
 527       vgl->download_tracks = data.b;
 528       break;
 529     case PARAM_UPLOAD_TRACKS:
 530       vgl->upload_tracks = data.b;
 531       break;
 532     case PARAM_DOWNLOAD_ROUTES:
 533       vgl->download_routes = data.b;
 534       break;
 535     case PARAM_UPLOAD_ROUTES:
 536       vgl->upload_routes = data.b;
 537       break;
 538     case PARAM_DOWNLOAD_WAYPOINTS:
 539       vgl->download_waypoints = data.b;
 540       break;
 541     case PARAM_UPLOAD_WAYPOINTS:
 542       vgl->upload_waypoints = data.b;
 543       break;
 544 #if defined (VIK_CONFIG_REALTIME_GPS_TRACKING) && defined (GPSD_API_MAJOR_VERSION)
 545     case PARAM_GPSD_HOST:
 546       if (data.s) {
 547         if (vgl->gpsd_host)
 548           g_free(vgl->gpsd_host);
 549         vgl->gpsd_host = g_strdup(data.s);
 550       }
 551       break;
 552     case PARAM_GPSD_PORT:
 553       if (data.s) {
 554         if (vgl->gpsd_port);
 555         g_free(vgl->gpsd_port);
 556         vgl->gpsd_port = g_strdup(data.s);
 557       }
 558       break;
 559     case PARAM_GPSD_RETRY_INTERVAL:
 560       vgl->gpsd_retry_interval = strtol(data.s, NULL, 10);
 561       break;
 562     case PARAM_REALTIME_REC:
 563       vgl->realtime_record = data.b;
 564       break;
 565     case PARAM_REALTIME_CENTER_START:
 566       vgl->realtime_jump_to_start = data.b;
 567       break;
 568     case PARAM_VEHICLE_POSITION:
 569       vgl->vehicle_position = data.u;
 570       break;
 571 #endif /* VIK_CONFIG_REALTIME_GPS_TRACKING */
 572     default:
 573       g_warning("gps_layer_set_param(): unknown parameter");
 574   }
 575
 576   return TRUE;
 577 }
 578
 579 static VikLayerParamData gps_layer_get_param ( VikGpsLayer *vgl, guint16 id, gboolean is_file_operation )
 580 {
 581   VikLayerParamData rv;
 582   switch ( id )
 583   {
 584     case PARAM_PROTOCOL:
 585       rv.s = vgl->protocol;
 586       g_debug("%s: %s", __FUNCTION__, rv.s);
 587       break;
 588     case PARAM_PORT:
 589       rv.s = vgl->serial_port;
 590       g_debug("%s: %s", __FUNCTION__, rv.s);
 591       break;
 592     case PARAM_DOWNLOAD_TRACKS:
 593       rv.b = vgl->download_tracks;
 594       break;
 595     case PARAM_UPLOAD_TRACKS:
 596       rv.b = vgl->upload_tracks;
 597       break;
 598     case PARAM_DOWNLOAD_ROUTES:
 599       rv.b = vgl->download_routes;
 600       break;
 601     case PARAM_UPLOAD_ROUTES:
 602       rv.b = vgl->upload_routes;
 603       break;
 604     case PARAM_DOWNLOAD_WAYPOINTS:
 605       rv.b = vgl->download_waypoints;
 606       break;
 607     case PARAM_UPLOAD_WAYPOINTS:
 608       rv.b = vgl->upload_waypoints;
 609       break;
 610 #if defined (VIK_CONFIG_REALTIME_GPS_TRACKING) && defined (GPSD_API_MAJOR_VERSION)
 611     case PARAM_GPSD_HOST:
 612       rv.s = vgl->gpsd_host ? vgl->gpsd_host : "";
 613       break;
 614     case PARAM_GPSD_PORT:
 615       rv.s = vgl->gpsd_port ? vgl->gpsd_port : g_strdup(DEFAULT_GPSD_PORT);
 616       break;
 617     case PARAM_GPSD_RETRY_INTERVAL:
 618       rv.s = g_strdup_printf("%d", vgl->gpsd_retry_interval);
 619       break;
 620     case PARAM_REALTIME_REC:
 621       rv.b = vgl->realtime_record;
 622       break;
 623     case PARAM_REALTIME_CENTER_START:
 624       rv.b = vgl->realtime_jump_to_start;
 625       break;
 626     case PARAM_VEHICLE_POSITION:
 627       rv.u = vgl->vehicle_position;
 628       break;
 629 #endif /* VIK_CONFIG_REALTIME_GPS_TRACKING */
 630     default:
 631       g_warning(_("%s: unknown parameter"), __FUNCTION__);
 632   }
 633
 634   return rv;
 635 }
 636
 637 VikGpsLayer *vik_gps_layer_new (VikViewport *vp)
 638 {
 639   gint i;
 640   VikGpsLayer *vgl = VIK_GPS_LAYER ( g_object_new ( VIK_GPS_LAYER_TYPE, NULL ) );
 641   vik_layer_set_type ( VIK_LAYER(vgl), VIK_LAYER_GPS );
 642   for (i = 0; i < NUM_TRW; i++) {
 643     vgl->trw_children[i] = NULL;
 644   }
 645   vgl->children = NULL;
 646   vgl->cur_read_child = 0;
 647
 648 #if defined (VIK_CONFIG_REALTIME_GPS_TRACKING) && defined (GPSD_API_MAJOR_VERSION)
 649   vgl->first_realtime_trackpoint = FALSE;
 650   vgl->vgpsd = NULL;
 651   vgl->realtime_io_channel = NULL;
 652   vgl->realtime_io_watch_id = 0;
 653   vgl->realtime_retry_timer = 0;
 654   if ( vp ) {
 655     vgl->realtime_track_gc = vik_viewport_new_gc ( vp, "#203070", 2 );
 656     vgl->realtime_track_bg_gc = vik_viewport_new_gc ( vp, "grey", 2 );
 657     vgl->realtime_track_pt1_gc = vik_viewport_new_gc ( vp, "red", 2 );
 658     vgl->realtime_track_pt2_gc = vik_viewport_new_gc ( vp, "green", 2 );
 659     vgl->realtime_track_pt_gc = vgl->realtime_track_pt1_gc;
 660   }
 661   vgl->realtime_track = NULL;
 662 #endif // VIK_CONFIG_REALTIME_GPS_TRACKING
 663
 664   vik_layer_set_defaults ( VIK_LAYER(vgl), vp );
 665
 666   return vgl;
 667 }
 668
 669 static void vik_gps_layer_draw ( VikGpsLayer *vgl, VikViewport *vp )
 670 {
 671   gint i;
 672   VikLayer *vl;
 673   VikLayer *trigger = VIK_LAYER(vik_viewport_get_trigger( vp ));
 674
 675   for (i = 0; i < NUM_TRW; i++) {
 676     vl = VIK_LAYER(vgl->trw_children[i]);
 677     if (vl == trigger) {
 678       if ( vik_viewport_get_half_drawn ( vp ) ) {
 679         vik_viewport_set_half_drawn ( vp, FALSE );
 680         vik_viewport_snapshot_load( vp );
 681       } else {
 682         vik_viewport_snapshot_save( vp );
 683       }
 684     }
 685     if (!vik_viewport_get_half_drawn(vp))
 686       vik_layer_draw ( vl, vp );
 687   }
 688 #if defined (VIK_CONFIG_REALTIME_GPS_TRACKING) && defined (GPSD_API_MAJOR_VERSION)
 689   if (vgl->realtime_tracking) {
 690     if (VIK_LAYER(vgl) == trigger) {
 691       if ( vik_viewport_get_half_drawn ( vp ) ) {
 692         vik_viewport_set_half_drawn ( vp, FALSE );
 693         vik_viewport_snapshot_load( vp );
 694       } else {
 695         vik_viewport_snapshot_save( vp );
 696       }
 697     }
 698     if (!vik_viewport_get_half_drawn(vp))
 699       realtime_tracking_draw(vgl, vp);
 700   }
 701 #endif /* VIK_CONFIG_REALTIME_GPS_TRACKING */
 702 }
 703
 704 static void gps_layer_change_coord_mode ( VikGpsLayer *vgl, VikCoordMode mode )
 705 {
 706   gint i;
 707   for (i = 0; i < NUM_TRW; i++) {
 708     vik_layer_change_coord_mode(VIK_LAYER(vgl->trw_children[i]), mode);
 709   }
 710 }
 711
 712 static void gps_layer_add_menu_items( VikGpsLayer *vgl, GtkMenu *menu, gpointer vlp )
 713 {
 714   static gpointer pass_along[2];
 715   GtkWidget *item;
 716   pass_along[0] = vgl;
 717   pass_along[1] = vlp;
 718
 719   item = gtk_menu_item_new();
 720   gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
 721   gtk_widget_show ( item );
 722
 723   /* Now with icons */
 724   item = gtk_image_menu_item_new_with_mnemonic ( _("_Upload to GPS") );
 725   gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_GO_UP, GTK_ICON_SIZE_MENU) );
 726   g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(gps_upload_cb), pass_along );
 727   gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
 728   gtk_widget_show ( item );
 729
 730   item = gtk_image_menu_item_new_with_mnemonic ( _("Download from _GPS") );
 731   gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_GO_DOWN, GTK_ICON_SIZE_MENU) );
 732   g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(gps_download_cb), pass_along );
 733   gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
 734   gtk_widget_show ( item );
 735
 736 #if defined (VIK_CONFIG_REALTIME_GPS_TRACKING) && defined (GPSD_API_MAJOR_VERSION)
 737   item = gtk_image_menu_item_new_with_mnemonic ( vgl->realtime_tracking  ?
 738                                                  "_Stop Realtime Tracking" :
 739                                                  "_Start Realtime Tracking" );
 740   gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, vgl->realtime_tracking ?
 741                                   gtk_image_new_from_stock (GTK_STOCK_MEDIA_STOP, GTK_ICON_SIZE_MENU) :
 742                                   gtk_image_new_from_stock (GTK_STOCK_MEDIA_PLAY, GTK_ICON_SIZE_MENU) );
 743   g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(gps_start_stop_tracking_cb), pass_along );
 744   gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
 745   gtk_widget_show ( item );
 746
 747   item = gtk_menu_item_new();
 748   gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
 749   gtk_widget_show ( item );
 750
 751   item = gtk_image_menu_item_new_with_mnemonic ( _("Empty _Realtime") );
 752   gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_REMOVE, GTK_ICON_SIZE_MENU) );
 753   g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(gps_empty_realtime_cb), pass_along );
 754   gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
 755   gtk_widget_show ( item );
 756 #endif /* VIK_CONFIG_REALTIME_GPS_TRACKING */
 757
 758   item = gtk_image_menu_item_new_with_mnemonic ( _("E_mpty Upload") );
 759   gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_REMOVE, GTK_ICON_SIZE_MENU) );
 760   g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(gps_empty_upload_cb), pass_along );
 761   gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
 762   gtk_widget_show ( item );
 763
 764   item = gtk_image_menu_item_new_with_mnemonic ( _("_Empty Download") );
 765   gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_REMOVE, GTK_ICON_SIZE_MENU) );
 766   g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(gps_empty_download_cb), pass_along );
 767   gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
 768   gtk_widget_show ( item );
 769
 770   item = gtk_image_menu_item_new_with_mnemonic ( _("Empty _All") );
 771   gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_REMOVE, GTK_ICON_SIZE_MENU) );
 772   g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(gps_empty_all_cb), pass_along );
 773   gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
 774   gtk_widget_show ( item );
 775
 776 }
 777
 778 static void disconnect_layer_signal ( VikLayer *vl, VikGpsLayer *vgl )
 779 {
 780   guint number_handlers = DISCONNECT_UPDATE_SIGNAL(vl,vgl);
 781   if ( number_handlers != 1 ) {
 782     /*
 783       NB It's not fatal if this gives 2 for example! Hence removal of the g_assert
 784       This happens when copied GPS layer is deleted (not sure why the number_handlers would be 2)
 785       I don't think there's any side effects and certainly better than the program just aborting
 786     */
 787     g_warning(_("Unexpected number of disconnected handlers: %d"), number_handlers);
 788   }
 789 }
 790
 791 static void vik_gps_layer_free ( VikGpsLayer *vgl )
 792 {
 793   gint i;
 794   for (i = 0; i < NUM_TRW; i++) {
 795     if (vgl->vl.realized)
 796       disconnect_layer_signal(VIK_LAYER(vgl->trw_children[i]), vgl);
 797     g_object_unref(vgl->trw_children[i]);
 798   }
 799 #if defined (VIK_CONFIG_REALTIME_GPS_TRACKING) && defined (GPSD_API_MAJOR_VERSION)
 800   rt_gpsd_disconnect(vgl);
 801   if (vgl->realtime_track_gc != NULL)
 802     g_object_unref(vgl->realtime_track_gc);
 803   if (vgl->realtime_track_bg_gc != NULL)
 804     g_object_unref(vgl->realtime_track_bg_gc);
 805   if (vgl->realtime_track_pt1_gc != NULL)
 806     g_object_unref(vgl->realtime_track_pt1_gc);
 807   if (vgl->realtime_track_pt2_gc != NULL)
 808     g_object_unref(vgl->realtime_track_pt2_gc);
 809 #endif /* VIK_CONFIG_REALTIME_GPS_TRACKING */
 810 }
 811
 812 gboolean vik_gps_layer_delete ( VikGpsLayer *vgl, GtkTreeIter *iter )
 813 {
 814   gint i;
 815   VikLayer *l = VIK_LAYER( vik_treeview_item_get_pointer ( VIK_LAYER(vgl)->vt, iter ) );
 816   gboolean was_visible = l->visible;
 817
 818   vik_treeview_item_delete ( VIK_LAYER(vgl)->vt, iter );
 819   for (i = 0; i < NUM_TRW; i++) {
 820     if (VIK_LAYER(vgl->trw_children[i]) == l)
 821       vgl->trw_children[i] = NULL;
 822   }
 823   g_assert(DISCONNECT_UPDATE_SIGNAL(l,vgl)==1);
 824   g_object_unref ( l );
 825
 826   return was_visible;
 827 }
 828
 829 static void vik_gps_layer_realize ( VikGpsLayer *vgl, VikTreeview *vt, GtkTreeIter *layer_iter )
 830 {
 831   GtkTreeIter iter;
 832   int ix;
 833
 834   // TODO set to garmin by default
 835   //if (a_babel_device_list)
 836   // device = ((BabelDevice*)g_list_nth_data(a_babel_device_list, last_active))->name;
 837   // Need to access uibuild widgets somehow....
 838
 839   for (ix = 0; ix < NUM_TRW; ix++) {
 840     VikLayer * trw = VIK_LAYER(vgl->trw_children[ix]);
 841     vik_treeview_add_layer ( VIK_LAYER(vgl)->vt, layer_iter, &iter,
 842         _(trw_names[ix]), vgl, TRUE,
 843         trw, trw->type, trw->type );
 844     if ( ! trw->visible )
 845       vik_treeview_item_set_visible ( VIK_LAYER(vgl)->vt, &iter, FALSE );
 846     vik_layer_realize ( trw, VIK_LAYER(vgl)->vt, &iter );
 847     g_signal_connect_swapped ( G_OBJECT(trw), "update", G_CALLBACK(vik_layer_emit_update_secondary), vgl );
 848   }
 849 }
 850
 851 const GList *vik_gps_layer_get_children ( VikGpsLayer *vgl )
 852 {
 853   int i;
 854
 855   if (vgl->children == NULL) {
 856     for (i = NUM_TRW - 1; i >= 0; i--)
 857       vgl->children = g_list_prepend(vgl->children, vgl->trw_children[i]);
 858   }
 859   return vgl->children;
 860 }
 861
 862 VikTrwLayer * vik_gps_layer_get_a_child(VikGpsLayer *vgl)
 863 {
 864   g_assert ((vgl->cur_read_child >= 0) && (vgl->cur_read_child < NUM_TRW));
 865
 866   VikTrwLayer * vtl = vgl->trw_children[vgl->cur_read_child];
 867   if (++(vgl->cur_read_child) >= NUM_TRW)
 868     vgl->cur_read_child = 0;
 869   return(vtl);
 870 }
 871
 872 gboolean vik_gps_layer_is_empty ( VikGpsLayer *vgl )
 873 {
 874   if ( vgl->trw_children[0] )
 875     return FALSE;
 876   return TRUE;
 877 }
 878
 879 static void gps_layer_drag_drop_request ( VikGpsLayer *val_src, VikGpsLayer *val_dest, GtkTreeIter *src_item_iter, GtkTreePath *dest_path )
 880 {
 881   VikTreeview *vt = VIK_LAYER(val_src)->vt;
 882   VikLayer *vl = vik_treeview_item_get_pointer(vt, src_item_iter);
 883   gchar *dp;
 884
 885   dp = gtk_tree_path_to_string(dest_path);
 886
 887   /* vik_gps_layer_delete unrefs, but we don't want that here.
 888    * we're still using the layer. */
 889   g_object_ref ( vl );
 890   vik_gps_layer_delete(val_src, src_item_iter);
 891
 892   g_free(dp);
 893 }
 894
 895 static void gps_session_delete(GpsSession *sess)
 896 {
 897   /* TODO */
 898   g_mutex_free(sess->mutex);
 899   g_free(sess->cmd_args);
 900
 901   g_free(sess);
 902
 903 }
 904
 905 static void set_total_count(gint cnt, GpsSession *sess)
 906 {
 907   gchar s[128];
 908   gdk_threads_enter();
 909   g_mutex_lock(sess->mutex);
 910   if (sess->ok) {
 911     const gchar *tmp_str;
 912     if (sess->direction == GPS_DOWN)
 913     {
 914       switch (sess->progress_type) {
 915       case WPT: tmp_str = ngettext("Downloading %d waypoint...", "Downloading %d waypoints...", cnt); sess->total_count = cnt; break;
 916       case TRK: tmp_str = ngettext("Downloading %d trackpoint...", "Downloading %d trackpoints...", cnt); sess->total_count = cnt; break;
 917       default:
 918         {
 919           // 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
 920           gint mycnt = (cnt / 2) + 1;
 921           tmp_str = ngettext("Downloading %d routepoint...", "Downloading %d routepoints...", mycnt); break;
 922           sess->total_count = mycnt;
 923         }
 924       }
 925     }
 926     else
 927     {
 928       switch (sess->progress_type) {
 929       case WPT: tmp_str = ngettext("Uploading %d waypoint...", "Uploading %d waypoints...", cnt); break;
 930       case TRK: tmp_str = ngettext("Uploading %d trackpoint...", "Uploading %d trackpoints...", cnt); break;
 931       default: tmp_str = ngettext("Uploading %d routepoint...", "Uploading %d routepoints...", cnt); break;
 932       }
 933     }
 934
 935     g_snprintf(s, 128, tmp_str, cnt);
 936     gtk_label_set_text ( GTK_LABEL(sess->progress_label), s );
 937     gtk_widget_show ( sess->progress_label );
 938     sess->total_count = cnt;
 939   }
 940   g_mutex_unlock(sess->mutex);
 941   gdk_threads_leave();
 942 }
 943
 944 static void set_current_count(gint cnt, GpsSession *sess)
 945 {
 946   gchar s[128];
 947   const gchar *tmp_str;
 948
 949   gdk_threads_enter();
 950   g_mutex_lock(sess->mutex);
 951   if (sess->ok) {
 952     if (cnt < sess->total_count) {
 953       if (sess->direction == GPS_DOWN)
 954       {
 955         switch (sess->progress_type) {
 956         case WPT: tmp_str = ngettext("Downloaded %d out of %d waypoint...", "Downloaded %d out of %d waypoints...", sess->total_count); break;
 957         case TRK: tmp_str = ngettext("Downloaded %d out of %d trackpoint...", "Downloaded %d out of %d trackpoints...", sess->total_count); break;
 958         default: tmp_str = ngettext("Downloaded %d out of %d routepoint...", "Downloaded %d out of %d routepoints...", sess->total_count); break;
 959         }
 960       }
 961       else {
 962         switch (sess->progress_type) {
 963         case WPT: tmp_str = ngettext("Uploaded %d out of %d waypoint...", "Uploaded %d out of %d waypoints...", sess->total_count); break;
 964         case TRK: tmp_str = ngettext("Uploaded %d out of %d trackpoint...", "Uploaded %d out of %d trackpoints...", sess->total_count); break;
 965         default: tmp_str = ngettext("Uploaded %d out of %d routepoint...", "Uploaded %d out of %d routepoints...", sess->total_count); break;
 966         }
 967       }
 968       g_snprintf(s, 128, tmp_str, cnt, sess->total_count);
 969     } else {
 970       if (sess->direction == GPS_DOWN)
 971       {
 972         switch (sess->progress_type) {
 973         case WPT: tmp_str = ngettext("Downloaded %d waypoint", "Downloaded %d waypoints", cnt); break;
 974         case TRK: tmp_str = ngettext("Downloaded %d trackpoint", "Downloaded %d trackpoints", cnt); break;
 975         default: tmp_str = ngettext("Downloaded %d routepoint", "Downloaded %d routepoints", cnt); break;
 976         }
 977       }
 978       else {
 979         switch (sess->progress_type) {
 980         case WPT: tmp_str = ngettext("Uploaded %d waypoint", "Uploaded %d waypoints", cnt); break;
 981         case TRK: tmp_str = ngettext("Uploaded %d trackpoint", "Uploaded %d trackpoints", cnt); break;
 982         default: tmp_str = ngettext("Uploaded %d routepoint", "Uploaded %d routepoints", cnt); break;
 983         }
 984       }
 985       g_snprintf(s, 128, tmp_str, cnt);
 986     }
 987     gtk_label_set_text ( GTK_LABEL(sess->progress_label), s );
 988   }
 989   g_mutex_unlock(sess->mutex);
 990   gdk_threads_leave();
 991 }
 992
 993 static void set_gps_info(const gchar *info, GpsSession *sess)
 994 {
 995   gchar s[256];
 996   gdk_threads_enter();
 997   g_mutex_lock(sess->mutex);
 998   if (sess->ok) {
 999     g_snprintf(s, 256, _("GPS Device: %s"), info);
1000     gtk_label_set_text ( GTK_LABEL(sess->gps_label), s );
1001   }
1002   g_mutex_unlock(sess->mutex);
1003   gdk_threads_leave();
1004 }
1005
1006 /*
1007  * Common processing for GPS Device information
1008  * It doesn't matter whether we're uploading or downloading
1009  */
1010 static void process_line_for_gps_info ( const gchar *line, GpsSession *sess )
1011 {
1012   if (strstr(line, "PRDDAT")) {
1013     gchar **tokens = g_strsplit(line, " ", 0);
1014     gchar info[128];
1015     int ilen = 0;
1016     int i;
1017     int n_tokens = 0;
1018
1019     while (tokens[n_tokens])
1020       n_tokens++;
1021
1022     // I'm not entirely clear what information this is trying to get...
1023     //  Obviously trying to decipher some kind of text/naming scheme
1024     //  Anyway this will be superceded if there is 'Unit:' information
1025     if (n_tokens > 8) {
1026       for (i=8; tokens[i] && ilen < sizeof(info)-2 && strcmp(tokens[i], "00"); i++) {
1027         guint ch;
1028         sscanf(tokens[i], "%x", &ch);
1029         info[ilen++] = ch;
1030       }
1031       info[ilen++] = 0;
1032       set_gps_info(info, sess);
1033     }
1034     g_strfreev(tokens);
1035   }
1036
1037   /* eg: "Unit:\teTrex Legend HCx Software Version 2.90\n" */
1038   if (strstr(line, "Unit:")) {
1039     gchar **tokens = g_strsplit(line, "\t", 0);
1040     int n_tokens = 0;
1041     while (tokens[n_tokens])
1042       n_tokens++;
1043
1044     if (n_tokens > 1) {
1045       set_gps_info(tokens[1], sess);
1046     }
1047     g_strfreev(tokens);
1048   }
1049 }
1050
1051 static void gps_download_progress_func(BabelProgressCode c, gpointer data, GpsSession * sess )
1052 {
1053   gchar *line;
1054
1055   gdk_threads_enter ();
1056   g_mutex_lock(sess->mutex);
1057   if (!sess->ok) {
1058     g_mutex_unlock(sess->mutex);
1059     gps_session_delete(sess);
1060     gdk_threads_leave();
1061     g_thread_exit ( NULL );
1062   }
1063   g_mutex_unlock(sess->mutex);
1064   gdk_threads_leave ();
1065
1066   switch(c) {
1067   case BABEL_DIAG_OUTPUT:
1068     line = (gchar *)data;
1069
1070     gdk_threads_enter();
1071     g_mutex_lock(sess->mutex);
1072     if (sess->ok) {
1073       gtk_label_set_text ( GTK_LABEL(sess->status_label), _("Status: Working...") );
1074     }
1075     g_mutex_unlock(sess->mutex);
1076     gdk_threads_leave();
1077
1078     /* tells us the type of items that will follow */
1079     if (strstr(line, "Xfer Wpt")) {
1080       sess->progress_label = sess->wp_label;
1081       sess->progress_type = WPT;
1082     }
1083     if (strstr(line, "Xfer Trk")) {
1084       sess->progress_label = sess->trk_label;
1085       sess->progress_type = TRK;
1086     }
1087     if (strstr(line, "Xfer Rte")) {
1088       sess->progress_label = sess->rte_label;
1089       sess->progress_type = RTE;
1090     }
1091
1092     process_line_for_gps_info ( line, sess );
1093
1094     if (strstr(line, "RECORD")) {
1095       int lsb, msb, cnt;
1096
1097       if (strlen(line) > 20) {
1098         sscanf(line+17, "%x", &lsb);
1099         sscanf(line+20, "%x", &msb);
1100         cnt = lsb + msb * 256;
1101         set_total_count(cnt, sess);
1102         sess->count = 0;
1103       }
1104     }
1105     if ( strstr(line, "WPTDAT") || strstr(line, "TRKHDR") || strstr(line, "TRKDAT") || strstr(line, "RTEHDR") || strstr(line, "RTEWPT") ) {
1106       sess->count++;
1107       set_current_count(sess->count, sess);
1108     }
1109     break;
1110   case BABEL_DONE:
1111     break;
1112   default:
1113     break;
1114   }
1115
1116 }
1117
1118 static void gps_upload_progress_func(BabelProgressCode c, gpointer data, GpsSession * sess )
1119 {
1120   gchar *line;
1121   static int cnt = 0;
1122
1123   gdk_threads_enter ();
1124   g_mutex_lock(sess->mutex);
1125   if (!sess->ok) {
1126     g_mutex_unlock(sess->mutex);
1127     gps_session_delete(sess);
1128     gdk_threads_leave();
1129     g_thread_exit ( NULL );
1130   }
1131   g_mutex_unlock(sess->mutex);
1132   gdk_threads_leave ();
1133
1134   switch(c) {
1135   case BABEL_DIAG_OUTPUT:
1136     line = (gchar *)data;
1137
1138     gdk_threads_enter();
1139     g_mutex_lock(sess->mutex);
1140     if (sess->ok) {
1141       gtk_label_set_text ( GTK_LABEL(sess->status_label), _("Status: Working...") );
1142     }
1143     g_mutex_unlock(sess->mutex);
1144     gdk_threads_leave();
1145
1146     process_line_for_gps_info ( line, sess );
1147
1148     if (strstr(line, "RECORD")) {
1149       int lsb, msb;
1150
1151       if (strlen(line) > 20) {
1152         sscanf(line+17, "%x", &lsb);
1153         sscanf(line+20, "%x", &msb);
1154         cnt = lsb + msb * 256;
1155         /* set_total_count(cnt, sess); */
1156         sess->count = 0;
1157       }
1158     }
1159     if ( strstr(line, "WPTDAT")) {
1160       if (sess->count == 0) {
1161         sess->progress_label = sess->wp_label;
1162         sess->progress_type = WPT;
1163         set_total_count(cnt, sess);
1164       }
1165       sess->count++;
1166       set_current_count(sess->count, sess);
1167     }
1168     if ( strstr(line, "RTEHDR") || strstr(line, "RTEWPT") ) {
1169        if (sess->count == 0) {
1170          sess->progress_label = sess->rte_label;
1171          sess->progress_type = RTE;
1172          // 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
1173          // Anyway since we're uploading - we should know how many points we're going to put!
1174          cnt = (cnt / 2) + 1;
1175          set_total_count(cnt, sess);
1176        }
1177        sess->count++;
1178        set_current_count(sess->count, sess);
1179     }
1180     if ( strstr(line, "TRKHDR") || strstr(line, "TRKDAT") ) {
1181       if (sess->count == 0) {
1182         sess->progress_label = sess->trk_label;
1183         sess->progress_type = TRK;
1184         set_total_count(cnt, sess);
1185       }
1186       sess->count++;
1187       set_current_count(sess->count, sess);
1188     }
1189     break;
1190   case BABEL_DONE:
1191     break;
1192   default:
1193     break;
1194   }
1195
1196 }
1197
1198 static void gps_comm_thread(GpsSession *sess)
1199 {
1200   gboolean result;
1201
1202   if (sess->direction == GPS_DOWN)
1203     result = a_babel_convert_from (sess->vtl, sess->cmd_args, sess->port,
1204         (BabelStatusFunc) gps_download_progress_func, sess, NULL);
1205   else {
1206     result = a_babel_convert_to (sess->vtl, sess->track, sess->cmd_args, sess->port,
1207         (BabelStatusFunc) gps_upload_progress_func, sess);
1208   }
1209
1210   if (!result) {
1211     gtk_label_set_text ( GTK_LABEL(sess->status_label), _("Error: couldn't find gpsbabel.") );
1212   }
1213   else {
1214     g_mutex_lock(sess->mutex);
1215     if (sess->ok) {
1216       gtk_label_set_text ( GTK_LABEL(sess->status_label), _("Done.") );
1217       gtk_dialog_set_response_sensitive ( GTK_DIALOG(sess->dialog), GTK_RESPONSE_ACCEPT, TRUE );
1218       gtk_dialog_set_response_sensitive ( GTK_DIALOG(sess->dialog), GTK_RESPONSE_REJECT, FALSE );
1219
1220       /* Do not change the view if we are following the current GPS position */
1221 #if defined (VIK_CONFIG_REALTIME_GPS_TRACKING) && defined (GPSD_API_MAJOR_VERSION)
1222       if (!sess->realtime_tracking)
1223 #endif
1224       {
1225         if ( sess->vvp && sess->direction == GPS_DOWN ) {
1226           /* View the data available */
1227           vik_trw_layer_auto_set_view ( sess->vtl, sess->vvp) ;
1228           vik_layer_emit_update ( VIK_LAYER(sess->vtl) ); // NB update from background thread
1229         }
1230       }
1231     } else {
1232       /* canceled */
1233     }
1234     g_mutex_unlock(sess->mutex);
1235   }
1236
1237   g_mutex_lock(sess->mutex);
1238   if (sess->ok) {
1239     sess->ok = FALSE;
1240     g_mutex_unlock(sess->mutex);
1241   }
1242   else {
1243     g_mutex_unlock(sess->mutex);
1244     gps_session_delete(sess);
1245   }
1246   g_thread_exit(NULL);
1247 }
1248
1249 /**
1250  * vik_gps_comm:
1251  * @vtl: The TrackWaypoint layer to operate on
1252  * @track: Operate on a particular track when specified
1253  * @dir: The direction of the transfer
1254  * @protocol: The GPS device communication protocol
1255  * @port: The GPS serial port
1256  * @tracking: If tracking then viewport display update will be skipped
1257  * @vvp: A viewport is required as the display may get updated
1258  * @vlp: A layers panel is needed for uploading as the items maybe modified
1259  * @do_tracks: Whether tracks shoud be processed
1260  * @do_waypoints: Whether waypoints shoud be processed
1261  * @turn_off: Whether we should attempt to turn off the GPS device after the transfer (only some devices support this)
1262  *
1263  * Talk to a GPS Device using a thread which updates a dialog with the progress
1264  */
1265 gint vik_gps_comm ( VikTrwLayer *vtl,
1266                     VikTrack *track,
1267                     vik_gps_dir dir,
1268                     gchar *protocol,
1269                     gchar *port,
1270                     gboolean tracking,
1271                     VikViewport *vvp,
1272                     VikLayersPanel *vlp,
1273                     gboolean do_tracks,
1274                     gboolean do_routes,
1275                     gboolean do_waypoints,
1276                     gboolean turn_off )
1277 {
1278   GpsSession *sess = g_malloc(sizeof(GpsSession));
1279   char *tracks = NULL;
1280   char *routes = NULL;
1281   char *waypoints = NULL;
1282
1283   sess->mutex = g_mutex_new();
1284   sess->direction = dir;
1285   sess->vtl = vtl;
1286   sess->track = track;
1287   sess->port = g_strdup(port);
1288   sess->ok = TRUE;
1289   sess->window_title = (dir == GPS_DOWN) ? _("GPS Download") : _("GPS Upload");
1290   sess->vvp = vvp;
1291
1292   // This must be done inside the main thread as the uniquify causes screen updates
1293   //  (originally performed this nearer the point of upload in the thread)
1294   if ( dir == GPS_UP ) {
1295     // Enforce unique names in the layer upload to the GPS device
1296     // NB this may only be a Garmin device restriction (and may be not every Garmin device either...)
1297     // Thus this maintains the older code in built restriction
1298     if ( ! vik_trw_layer_uniquify ( sess->vtl, vlp ) )
1299       vik_statusbar_set_message ( vik_window_get_statusbar (VIK_WINDOW(VIK_GTK_WINDOW_FROM_LAYER(sess->vtl))), VIK_STATUSBAR_INFO,
1300                                   _("Warning - GPS Upload items may overwrite each other") );
1301   }
1302
1303 #if defined (VIK_CONFIG_REALTIME_GPS_TRACKING) && defined (GPSD_API_MAJOR_VERSION)
1304   sess->realtime_tracking = tracking;
1305 #endif
1306
1307   if (do_tracks)
1308     tracks = "-t";
1309   else
1310     tracks = "";
1311   if (do_routes)
1312     routes = "-r";
1313   else
1314     routes = "";
1315   if (do_waypoints)
1316     waypoints = "-w";
1317   else
1318     waypoints = "";
1319
1320   sess->cmd_args = g_strdup_printf("-D 9 %s %s %s -%c %s",
1321                                    tracks, routes, waypoints, (dir == GPS_DOWN) ? 'i' : 'o', protocol);
1322   tracks = NULL;
1323   waypoints = NULL;
1324
1325   // Only create dialog if we're going to do some transferring
1326   if ( do_tracks || do_waypoints || do_routes ) {
1327     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 );
1328     gtk_dialog_set_response_sensitive ( GTK_DIALOG(sess->dialog),
1329                                         GTK_RESPONSE_ACCEPT, FALSE );
1330     gtk_window_set_title ( GTK_WINDOW(sess->dialog), sess->window_title );
1331
1332     sess->status_label = gtk_label_new (_("Status: detecting gpsbabel"));
1333     gtk_box_pack_start ( GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(sess->dialog))), sess->status_label, FALSE, FALSE, 5 );
1334     gtk_widget_show_all(sess->status_label);
1335
1336     sess->gps_label = gtk_label_new (_("GPS device: N/A"));
1337     sess->ver_label = gtk_label_new ("");
1338     sess->id_label = gtk_label_new ("");
1339     sess->wp_label = gtk_label_new ("");
1340     sess->trk_label = gtk_label_new ("");
1341     sess->rte_label = gtk_label_new ("");
1342
1343     gtk_box_pack_start ( GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(sess->dialog))), sess->gps_label, FALSE, FALSE, 5 );
1344     gtk_box_pack_start ( GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(sess->dialog))), sess->wp_label, FALSE, FALSE, 5 );
1345     gtk_box_pack_start ( GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(sess->dialog))), sess->trk_label, FALSE, FALSE, 5 );
1346     gtk_box_pack_start ( GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(sess->dialog))), sess->rte_label, FALSE, FALSE, 5 );
1347
1348     gtk_widget_show_all(sess->dialog);
1349
1350     sess->progress_label = sess->wp_label;
1351     sess->total_count = -1;
1352
1353     // Starting gps read/write thread
1354     g_thread_create((GThreadFunc)gps_comm_thread, sess, FALSE, NULL );
1355
1356     gtk_dialog_set_default_response ( GTK_DIALOG(sess->dialog), GTK_RESPONSE_ACCEPT );
1357     gtk_dialog_run(GTK_DIALOG(sess->dialog));
1358
1359     gtk_widget_destroy(sess->dialog);
1360   }
1361   else {
1362     if ( !turn_off )
1363       a_dialog_info_msg ( VIK_GTK_WINDOW_FROM_LAYER(vtl), _("No GPS items selected for transfer.") );
1364   }
1365
1366   g_mutex_lock(sess->mutex);
1367
1368   if (sess->ok) {
1369     sess->ok = FALSE;   /* tell thread to stop */
1370     g_mutex_unlock(sess->mutex);
1371   }
1372   else {
1373     if ( turn_off ) {
1374       // No need for thread for powering off device (should be quick operation...) - so use babel command directly:
1375       gchar *device_off = g_strdup_printf("-i %s,%s", protocol, "power_off");
1376       gboolean result = a_babel_convert_from (NULL, (const char*)device_off, (const char*)port, NULL, NULL, NULL);
1377       if ( !result )
1378         a_dialog_error_msg ( VIK_GTK_WINDOW_FROM_LAYER(vtl), _("Could not turn off device.") );
1379       g_free ( device_off );
1380     }
1381     g_mutex_unlock(sess->mutex);
1382     gps_session_delete(sess);
1383   }
1384
1385   return 0;
1386 }
1387
1388 static void gps_upload_cb( gpointer layer_and_vlp[2] )
1389 {
1390   VikGpsLayer *vgl = (VikGpsLayer *)layer_and_vlp[0];
1391   VikLayersPanel *vlp = VIK_LAYERS_PANEL(layer_and_vlp[1]);
1392   VikTrwLayer *vtl = vgl->trw_children[TRW_UPLOAD];
1393   VikWindow *vw = VIK_WINDOW(VIK_GTK_WINDOW_FROM_LAYER(vgl));
1394   VikViewport *vvp = vik_window_viewport(vw);
1395   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);
1396 }
1397
1398 static void gps_download_cb( gpointer layer_and_vlp[2] )
1399 {
1400   VikGpsLayer *vgl = (VikGpsLayer *)layer_and_vlp[0];
1401   VikTrwLayer *vtl = vgl->trw_children[TRW_DOWNLOAD];
1402   VikWindow *vw = VIK_WINDOW(VIK_GTK_WINDOW_FROM_LAYER(vgl));
1403   VikViewport *vvp = vik_window_viewport(vw);
1404 #if defined (VIK_CONFIG_REALTIME_GPS_TRACKING) && defined (GPSD_API_MAJOR_VERSION)
1405   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);
1406 #else
1407   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);
1408 #endif
1409 }
1410
1411 static void gps_empty_upload_cb( gpointer layer_and_vlp[2] )
1412 {
1413   VikGpsLayer *vgl = (VikGpsLayer *)layer_and_vlp[0];
1414   // Get confirmation from the user
1415   if ( ! a_dialog_yes_or_no ( VIK_GTK_WINDOW_FROM_WIDGET(layer_and_vlp[1]),
1416                               _("Are you sure you want to delete GPS Upload data?"),
1417                               NULL ) )
1418     return;
1419   vik_trw_layer_delete_all_waypoints ( vgl-> trw_children[TRW_UPLOAD]);
1420   vik_trw_layer_delete_all_tracks ( vgl-> trw_children[TRW_UPLOAD]);
1421   vik_trw_layer_delete_all_routes ( vgl-> trw_children[TRW_UPLOAD]);
1422 }
1423
1424 static void gps_empty_download_cb( gpointer layer_and_vlp[2] )
1425 {
1426   VikGpsLayer *vgl = (VikGpsLayer *)layer_and_vlp[0];
1427   // Get confirmation from the user
1428   if ( ! a_dialog_yes_or_no ( VIK_GTK_WINDOW_FROM_WIDGET(layer_and_vlp[1]),
1429                               _("Are you sure you want to delete GPS Download data?"),
1430                               NULL ) )
1431     return;
1432   vik_trw_layer_delete_all_waypoints ( vgl-> trw_children[TRW_DOWNLOAD]);
1433   vik_trw_layer_delete_all_tracks ( vgl-> trw_children[TRW_DOWNLOAD]);
1434   vik_trw_layer_delete_all_routes ( vgl-> trw_children[TRW_DOWNLOAD]);
1435 }
1436
1437 #if defined (VIK_CONFIG_REALTIME_GPS_TRACKING) && defined (GPSD_API_MAJOR_VERSION)
1438 static void gps_empty_realtime_cb( gpointer layer_and_vlp[2] )
1439 {
1440   VikGpsLayer *vgl = (VikGpsLayer *)layer_and_vlp[0];
1441   // Get confirmation from the user
1442   if ( ! a_dialog_yes_or_no ( VIK_GTK_WINDOW_FROM_WIDGET(layer_and_vlp[1]),
1443                               _("Are you sure you want to delete GPS Realtime data?"),
1444                               NULL ) )
1445     return;
1446   vik_trw_layer_delete_all_waypoints ( vgl-> trw_children[TRW_REALTIME]);
1447   vik_trw_layer_delete_all_tracks ( vgl-> trw_children[TRW_REALTIME]);
1448 }
1449 #endif
1450
1451 static void gps_empty_all_cb( gpointer layer_and_vlp[2] )
1452 {
1453   VikGpsLayer *vgl = (VikGpsLayer *)layer_and_vlp[0];
1454   // Get confirmation from the user
1455   if ( ! a_dialog_yes_or_no ( VIK_GTK_WINDOW_FROM_WIDGET(layer_and_vlp[1]),
1456                               _("Are you sure you want to delete All GPS data?"),
1457                               NULL ) )
1458     return;
1459   vik_trw_layer_delete_all_waypoints ( vgl-> trw_children[TRW_UPLOAD]);
1460   vik_trw_layer_delete_all_tracks ( vgl-> trw_children[TRW_UPLOAD]);
1461   vik_trw_layer_delete_all_routes ( vgl-> trw_children[TRW_UPLOAD]);
1462   vik_trw_layer_delete_all_waypoints ( vgl-> trw_children[TRW_DOWNLOAD]);
1463   vik_trw_layer_delete_all_tracks ( vgl-> trw_children[TRW_DOWNLOAD]);
1464   vik_trw_layer_delete_all_routes ( vgl-> trw_children[TRW_DOWNLOAD]);
1465 #if defined (VIK_CONFIG_REALTIME_GPS_TRACKING) && defined (GPSD_API_MAJOR_VERSION)
1466   vik_trw_layer_delete_all_waypoints ( vgl-> trw_children[TRW_REALTIME]);
1467   vik_trw_layer_delete_all_tracks ( vgl-> trw_children[TRW_REALTIME]);
1468 #endif
1469 }
1470
1471 #if defined (VIK_CONFIG_REALTIME_GPS_TRACKING) && defined (GPSD_API_MAJOR_VERSION)
1472 static void realtime_tracking_draw(VikGpsLayer *vgl, VikViewport *vp)
1473 {
1474   struct LatLon ll;
1475   VikCoord nw, se;
1476   struct LatLon lnw, lse;
1477   vik_viewport_screen_to_coord ( vp, -20, -20, &nw );
1478   vik_viewport_screen_to_coord ( vp, vik_viewport_get_width(vp)+20, vik_viewport_get_width(vp)+20, &se );
1479   vik_coord_to_latlon ( &nw, &lnw );
1480   vik_coord_to_latlon ( &se, &lse );
1481   if ( vgl->realtime_fix.fix.latitude > lse.lat &&
1482        vgl->realtime_fix.fix.latitude < lnw.lat &&
1483        vgl->realtime_fix.fix.longitude > lnw.lon &&
1484        vgl->realtime_fix.fix.longitude < lse.lon ) {
1485     VikCoord gps;
1486     gint x, y;
1487     gint half_back_x, half_back_y;
1488     gint half_back_bg_x, half_back_bg_y;
1489     gint pt_x, pt_y;
1490     gint ptbg_x;
1491     gint side1_x, side1_y, side2_x, side2_y;
1492     gint side1bg_x, side1bg_y, side2bg_x, side2bg_y;
1493
1494     ll.lat = vgl->realtime_fix.fix.latitude;
1495     ll.lon = vgl->realtime_fix.fix.longitude;
1496     vik_coord_load_from_latlon ( &gps, vik_viewport_get_coord_mode(vp), &ll);
1497     vik_viewport_coord_to_screen ( vp, &gps, &x, &y );
1498
1499     gdouble heading_cos = cos(DEG2RAD(vgl->realtime_fix.fix.track));
1500     gdouble heading_sin = sin(DEG2RAD(vgl->realtime_fix.fix.track));
1501
1502     half_back_y = y+8*heading_cos;
1503     half_back_x = x-8*heading_sin;
1504     half_back_bg_y = y+10*heading_cos;
1505     half_back_bg_x = x-10*heading_sin;
1506
1507     pt_y = half_back_y-24*heading_cos;
1508     pt_x = half_back_x+24*heading_sin;
1509     //ptbg_y = half_back_bg_y-28*heading_cos;
1510     ptbg_x = half_back_bg_x+28*heading_sin;
1511
1512     side1_y = half_back_y+9*heading_sin;
1513     side1_x = half_back_x+9*heading_cos;
1514     side1bg_y = half_back_bg_y+11*heading_sin;
1515     side1bg_x = half_back_bg_x+11*heading_cos;
1516
1517     side2_y = half_back_y-9*heading_sin;
1518     side2_x = half_back_x-9*heading_cos;
1519     side2bg_y = half_back_bg_y-11*heading_sin;
1520     side2bg_x = half_back_bg_x-11*heading_cos;
1521
1522      GdkPoint trian[3] = { { pt_x, pt_y }, {side1_x, side1_y}, {side2_x, side2_y} };
1523      GdkPoint trian_bg[3] = { { ptbg_x, pt_y }, {side1bg_x, side1bg_y}, {side2bg_x, side2bg_y} };
1524
1525      vik_viewport_draw_polygon ( vp, vgl->realtime_track_bg_gc, TRUE, trian_bg, 3 );
1526      vik_viewport_draw_polygon ( vp, vgl->realtime_track_gc, TRUE, trian, 3 );
1527      vik_viewport_draw_rectangle ( vp,
1528          (vgl->realtime_fix.fix.mode > MODE_2D) ? vgl->realtime_track_pt2_gc : vgl->realtime_track_pt1_gc,
1529          TRUE, x-2, y-2, 4, 4 );
1530      //vgl->realtime_track_pt_gc = (vgl->realtime_track_pt_gc == vgl->realtime_track_pt1_gc) ? vgl->realtime_track_pt2_gc : vgl->realtime_track_pt1_gc;
1531   }
1532 }
1533
1534 static void create_realtime_trackpoint(VikGpsLayer *vgl, gboolean forced)
1535 {
1536     struct LatLon ll;
1537     GList *last_tp;
1538
1539     /* Note that fix.time is a double, but it should not affect the precision
1540        for most GPS */
1541     time_t cur_timestamp = vgl->realtime_fix.fix.time;
1542     time_t last_timestamp = vgl->last_fix.fix.time;
1543
1544     if (cur_timestamp < last_timestamp) {
1545       return;
1546     }
1547
1548     if (vgl->realtime_record && vgl->realtime_fix.dirty) {
1549       gboolean replace = FALSE;
1550       int heading = (int)floor(vgl->realtime_fix.fix.track);
1551       int last_heading = (int)floor(vgl->last_fix.fix.track);
1552       int alt = isnan(vgl->realtime_fix.fix.altitude) ? VIK_DEFAULT_ALTITUDE : floor(vgl->realtime_fix.fix.altitude);
1553       int last_alt = isnan(vgl->last_fix.fix.altitude) ? VIK_DEFAULT_ALTITUDE : floor(vgl->last_fix.fix.altitude);
1554       if (((last_tp = g_list_last(vgl->realtime_track->trackpoints)) != NULL) &&
1555           (vgl->realtime_fix.fix.mode > MODE_2D) &&
1556           (vgl->last_fix.fix.mode <= MODE_2D) &&
1557           ((cur_timestamp - last_timestamp) < 2)) {
1558         g_free(last_tp->data);
1559         vgl->realtime_track->trackpoints = g_list_delete_link(vgl->realtime_track->trackpoints, last_tp);
1560         replace = TRUE;
1561       }
1562       if (replace ||
1563           ((cur_timestamp != last_timestamp) &&
1564           ((forced ||
1565             ((heading < last_heading) && (heading < (last_heading - 3))) ||
1566             ((heading > last_heading) && (heading > (last_heading + 3))) ||
1567             ((alt != VIK_DEFAULT_ALTITUDE) && (alt != last_alt)))))) {
1568         /* TODO: check for new segments */
1569         VikTrackpoint *tp = vik_trackpoint_new();
1570         tp->newsegment = FALSE;
1571         tp->has_timestamp = TRUE;
1572         tp->timestamp = vgl->realtime_fix.fix.time;
1573         tp->altitude = alt;
1574         /* speed only available for 3D fix. Check for NAN when use this speed */
1575         tp->speed = vgl->realtime_fix.fix.speed;
1576         tp->course = vgl->realtime_fix.fix.track;
1577         tp->nsats = vgl->realtime_fix.satellites_used;
1578         tp->fix_mode = vgl->realtime_fix.fix.mode;
1579
1580         ll.lat = vgl->realtime_fix.fix.latitude;
1581         ll.lon = vgl->realtime_fix.fix.longitude;
1582         vik_coord_load_from_latlon(&tp->coord,
1583              vik_trw_layer_get_coord_mode(vgl->trw_children[TRW_REALTIME]), &ll);
1584
1585         vgl->realtime_track->trackpoints = g_list_append(vgl->realtime_track->trackpoints, tp);
1586         vgl->realtime_fix.dirty = FALSE;
1587         vgl->realtime_fix.satellites_used = 0;
1588         vgl->last_fix = vgl->realtime_fix;
1589       }
1590     }
1591
1592 }
1593
1594 static void gpsd_raw_hook(VglGpsd *vgpsd, gchar *data)
1595 {
1596   gboolean update_all = FALSE;
1597   VikGpsLayer *vgl = vgpsd->vgl;
1598
1599   if (!vgl->realtime_tracking) {
1600     g_warning("%s: receiving GPS data while not in realtime mode", __PRETTY_FUNCTION__);
1601     return;
1602   }
1603
1604   if ((vgpsd->gpsd.fix.mode >= MODE_2D) &&
1605       !isnan(vgpsd->gpsd.fix.latitude) &&
1606       !isnan(vgpsd->gpsd.fix.longitude) &&
1607       !isnan(vgpsd->gpsd.fix.track)) {
1608
1609     VikWindow *vw = VIK_WINDOW(VIK_GTK_WINDOW_FROM_LAYER(vgl));
1610     VikViewport *vvp = vik_window_viewport(vw);
1611     vgl->realtime_fix.fix = vgpsd->gpsd.fix;
1612     vgl->realtime_fix.satellites_used = vgpsd->gpsd.satellites_used;
1613     vgl->realtime_fix.dirty = TRUE;
1614
1615     struct LatLon ll;
1616     VikCoord vehicle_coord;
1617
1618     ll.lat = vgl->realtime_fix.fix.latitude;
1619     ll.lon = vgl->realtime_fix.fix.longitude;
1620     vik_coord_load_from_latlon(&vehicle_coord,
1621            vik_trw_layer_get_coord_mode(vgl->trw_children[TRW_REALTIME]), &ll);
1622
1623     if ((vgl->vehicle_position == VEHICLE_POSITION_CENTERED) ||
1624         (vgl->realtime_jump_to_start && vgl->first_realtime_trackpoint)) {
1625       vik_viewport_set_center_coord(vvp, &vehicle_coord);
1626       update_all = TRUE;
1627     }
1628     else if (vgl->vehicle_position == VEHICLE_POSITION_ON_SCREEN) {
1629       const int hdiv = 6;
1630       const int vdiv = 6;
1631       const int px = 20; /* adjust ment in pixels to make sure vehicle is inside the box */
1632       gint width = vik_viewport_get_width(vvp);
1633       gint height = vik_viewport_get_height(vvp);
1634       gint vx, vy;
1635
1636       vik_viewport_coord_to_screen(vvp, &vehicle_coord, &vx, &vy);
1637       update_all = TRUE;
1638       if (vx < (width/hdiv))
1639         vik_viewport_set_center_screen(vvp, vx - width/2 + width/hdiv + px, vy);
1640       else if (vx > (width - width/hdiv))
1641         vik_viewport_set_center_screen(vvp, vx + width/2 - width/hdiv - px, vy);
1642       else if (vy < (height/vdiv))
1643         vik_viewport_set_center_screen(vvp, vx, vy - height/2 + height/vdiv + px);
1644       else if (vy > (height - height/vdiv))
1645         vik_viewport_set_center_screen(vvp, vx, vy + height/2 - height/vdiv - px);
1646       else
1647         update_all = FALSE;
1648     }
1649
1650     vgl->first_realtime_trackpoint = FALSE;
1651     create_realtime_trackpoint(vgl, FALSE);
1652
1653     vik_layer_emit_update ( update_all ? VIK_LAYER(vgl) : VIK_LAYER(vgl->trw_children[TRW_REALTIME]) ); // NB update from background thread
1654   }
1655 }
1656
1657 static gboolean gpsd_data_available(GIOChannel *source, GIOCondition condition, gpointer data)
1658 {
1659   VikGpsLayer *vgl = data;
1660   if (condition == G_IO_IN) {
1661 #if GPSD_API_MAJOR_VERSION == 3 || GPSD_API_MAJOR_VERSION == 4
1662     if (!gps_poll(&vgl->vgpsd->gpsd)) {
1663 #elif GPSD_API_MAJOR_VERSION == 5
1664     if (gps_read(&vgl->vgpsd->gpsd) > -1) {
1665       // Reuse old function to perform operations on the new GPS data
1666       gpsd_raw_hook(vgl->vgpsd, NULL);
1667 #else
1668       // Broken compile
1669 #endif
1670       return TRUE;
1671     }
1672     else {
1673       g_warning("Disconnected from gpsd. Trying to reconnect");
1674       rt_gpsd_disconnect(vgl);
1675       rt_gpsd_connect(vgl, FALSE);
1676     }
1677   }
1678   return FALSE; /* no further calling */
1679 }
1680
1681 static gchar *make_track_name(VikTrwLayer *vtl)
1682 {
1683   const gchar basename[] = "REALTIME";
1684   const gint bufsize = sizeof(basename) + 5;
1685   gchar *name = g_malloc(bufsize);
1686   strcpy(name, basename);
1687   gint i = 2;
1688
1689   while (vik_trw_layer_get_track(vtl, name) != NULL) {
1690     g_snprintf(name, bufsize, "%s#%d", basename, i);
1691     i++;
1692   }
1693   return(name);
1694
1695 }
1696
1697 static gboolean rt_gpsd_try_connect(gpointer *data)
1698 {
1699   VikGpsLayer *vgl = (VikGpsLayer *)data;
1700 #if GPSD_API_MAJOR_VERSION == 3
1701   struct gps_data_t *gpsd = gps_open(vgl->gpsd_host, vgl->gpsd_port);
1702
1703   if (gpsd == NULL) {
1704 #elif GPSD_API_MAJOR_VERSION == 4
1705   vgl->vgpsd = g_malloc(sizeof(VglGpsd));
1706
1707   if (gps_open_r(vgl->gpsd_host, vgl->gpsd_port, /*(struct gps_data_t *)*/vgl->vgpsd) != 0) {
1708 #elif GPSD_API_MAJOR_VERSION == 5
1709   vgl->vgpsd = g_malloc(sizeof(VglGpsd));
1710   if (gps_open(vgl->gpsd_host, vgl->gpsd_port, &vgl->vgpsd->gpsd) != 0) {
1711 #else
1712 // Delibrately break compilation...
1713 #endif
1714     g_warning("Failed to connect to gpsd at %s (port %s). Will retry in %d seconds",
1715                      vgl->gpsd_host, vgl->gpsd_port, vgl->gpsd_retry_interval);
1716     return TRUE;   /* keep timer running */
1717   }
1718
1719 #if GPSD_API_MAJOR_VERSION == 3
1720   vgl->vgpsd = realloc(gpsd, sizeof(VglGpsd));
1721 #endif
1722   vgl->vgpsd->vgl = vgl;
1723
1724   vgl->realtime_fix.dirty = vgl->last_fix.dirty = FALSE;
1725   /* track alt/time graph uses VIK_DEFAULT_ALTITUDE (0.0) as invalid */
1726   vgl->realtime_fix.fix.altitude = vgl->last_fix.fix.altitude = VIK_DEFAULT_ALTITUDE;
1727   vgl->realtime_fix.fix.speed = vgl->last_fix.fix.speed = NAN;
1728
1729   if (vgl->realtime_record) {
1730     VikTrwLayer *vtl = vgl->trw_children[TRW_REALTIME];
1731     vgl->realtime_track = vik_track_new();
1732     vgl->realtime_track->visible = TRUE;
1733     vik_trw_layer_add_track(vtl, make_track_name(vtl), vgl->realtime_track);
1734   }
1735
1736 #if GPSD_API_MAJOR_VERSION == 3 || GPSD_API_MAJOR_VERSION == 4
1737   gps_set_raw_hook(&vgl->vgpsd->gpsd, gpsd_raw_hook);
1738 #endif
1739
1740   vgl->realtime_io_channel = g_io_channel_unix_new(vgl->vgpsd->gpsd.gps_fd);
1741   vgl->realtime_io_watch_id = g_io_add_watch( vgl->realtime_io_channel,
1742                     G_IO_IN | G_IO_ERR | G_IO_HUP, gpsd_data_available, vgl);
1743
1744 #if GPSD_API_MAJOR_VERSION == 3
1745   gps_query(&vgl->vgpsd->gpsd, "w+x");
1746 #endif
1747 #if GPSD_API_MAJOR_VERSION == 4 || GPSD_API_MAJOR_VERSION == 5
1748   gps_stream(&vgl->vgpsd->gpsd, WATCH_ENABLE, NULL);
1749 #endif
1750
1751   return FALSE;  /* no longer called by timeout */
1752 }
1753
1754 static gboolean rt_ask_retry(VikGpsLayer *vgl)
1755 {
1756   GtkWidget *dialog = gtk_message_dialog_new (VIK_GTK_WINDOW_FROM_LAYER(vgl),
1757                           GTK_DIALOG_DESTROY_WITH_PARENT,
1758                           GTK_MESSAGE_QUESTION,
1759                           GTK_BUTTONS_YES_NO,
1760                           "Failed to connect to gpsd at %s (port %s)\n"
1761                           "Should Viking keep trying (every %d seconds)?",
1762                           vgl->gpsd_host, vgl->gpsd_port,
1763                           vgl->gpsd_retry_interval);
1764
1765   gint res = gtk_dialog_run(GTK_DIALOG(dialog));
1766   gtk_widget_destroy(dialog);
1767   return (res == GTK_RESPONSE_YES);
1768 }
1769
1770 static gboolean rt_gpsd_connect(VikGpsLayer *vgl, gboolean ask_if_failed)
1771 {
1772   vgl->realtime_retry_timer = 0;
1773   if (rt_gpsd_try_connect((gpointer *)vgl)) {
1774     if (vgl->gpsd_retry_interval <= 0) {
1775       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);
1776       return FALSE;
1777     }
1778     else if (ask_if_failed && !rt_ask_retry(vgl))
1779       return FALSE;
1780     else
1781       vgl->realtime_retry_timer = g_timeout_add_seconds(vgl->gpsd_retry_interval,
1782         (GSourceFunc)rt_gpsd_try_connect, (gpointer *)vgl);
1783   }
1784   return TRUE;
1785 }
1786
1787 static void rt_gpsd_disconnect(VikGpsLayer *vgl)
1788 {
1789   if (vgl->realtime_retry_timer) {
1790     g_source_remove(vgl->realtime_retry_timer);
1791     vgl->realtime_retry_timer = 0;
1792   }
1793   if (vgl->realtime_io_watch_id) {
1794     g_source_remove(vgl->realtime_io_watch_id);
1795     vgl->realtime_io_watch_id = 0;
1796   }
1797   if (vgl->realtime_io_channel) {
1798     GError *error = NULL;
1799     g_io_channel_shutdown (vgl->realtime_io_channel, FALSE, &error);
1800     vgl->realtime_io_channel = NULL;
1801   }
1802   if (vgl->vgpsd) {
1803 #if GPSD_API_MAJOR_VERSION == 4 || GPSD_API_MAJOR_VERSION == 5
1804     gps_stream(&vgl->vgpsd->gpsd, WATCH_DISABLE, NULL);
1805 #endif
1806     gps_close(&vgl->vgpsd->gpsd);
1807 #if GPSD_API_MAJOR_VERSION == 3
1808     free(vgl->vgpsd);
1809 #elif GPSD_API_MAJOR_VERSION == 4 || GPSD_API_MAJOR_VERSION == 5
1810     g_free(vgl->vgpsd);
1811 #endif
1812     vgl->vgpsd = NULL;
1813   }
1814
1815   if (vgl->realtime_record && vgl->realtime_track) {
1816     if ((vgl->realtime_track->trackpoints == NULL) || (vgl->realtime_track->trackpoints->next == NULL))
1817       vik_trw_layer_delete_track(vgl->trw_children[TRW_REALTIME], vgl->realtime_track);
1818     vgl->realtime_track = NULL;
1819   }
1820 }
1821
1822 static void gps_start_stop_tracking_cb( gpointer layer_and_vlp[2])
1823 {
1824   VikGpsLayer *vgl = (VikGpsLayer *)layer_and_vlp[0];
1825   vgl->realtime_tracking = (vgl->realtime_tracking == FALSE);
1826
1827   /* Make sure we are still in the boat with libgps */
1828   g_assert((VIK_GPS_MODE_2D == MODE_2D) && (VIK_GPS_MODE_3D == MODE_3D));
1829
1830   if (vgl->realtime_tracking) {
1831     vgl->first_realtime_trackpoint = TRUE;
1832     if (!rt_gpsd_connect(vgl, TRUE)) {
1833       vgl->first_realtime_trackpoint = FALSE;
1834       vgl->realtime_tracking = FALSE;
1835     }
1836   }
1837   else {  /* stop realtime tracking */
1838     vgl->first_realtime_trackpoint = FALSE;
1839     rt_gpsd_disconnect(vgl);
1840   }
1841 }
1842 #endif /* VIK_CONFIG_REALTIME_GPS_TRACKING */