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