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