src/file.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) 2012, Guilhem Bonnefille <guilhem.bonnefille@gmail.com>
   6  * Copyright (C) 2012-2013, Rob Norris <rw_norris@hotmail.com>
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21  *
  22  */
  23
  24 #ifdef HAVE_CONFIG_H
  25 #include "config.h"
  26 #endif
  27 #include "viking.h"
  28
  29 #include "jpg.h"
  30 #include "gpx.h"
  31 #include "geojson.h"
  32 #include "babel.h"
  33 #include "gpsmapper.h"
  34
  35 #include <string.h>
  36 #include <stdlib.h>
  37 #include <stdio.h>
  38 #ifdef HAVE_UNISTD_H
  39 #include <unistd.h>
  40 #endif
  41 #include <glib.h>
  42 #include <glib/gstdio.h>
  43 #include <glib/gi18n.h>
  44
  45 #include "file.h"
  46 #include "misc/strtod.h"
  47
  48 #define TEST_BOOLEAN(str) (! ((str)[0] == '\0' || (str)[0] == '0' || (str)[0] == 'n' || (str)[0] == 'N' || (str)[0] == 'f' || (str)[0] == 'F') )
  49 #define VIK_MAGIC "#VIK"
  50 #define GPX_MAGIC "<?xm"
  51 #define VIK_MAGIC_LEN 4
  52 #define GPX_MAGIC_LEN 4
  53
  54 #define VIKING_FILE_VERSION 1
  55
  56 typedef struct _Stack Stack;
  57
  58 struct _Stack {
  59   Stack *under;
  60   gpointer data;
  61 };
  62
  63 static void pop(Stack **stack) {
  64   Stack *tmp = (*stack)->under;
  65   g_free ( *stack );
  66   *stack = tmp;
  67 }
  68
  69 static void push(Stack **stack)
  70 {
  71   Stack *tmp = g_malloc ( sizeof ( Stack ) );
  72   tmp->under = *stack;
  73   *stack = tmp;
  74 }
  75
  76 static gboolean check_magic ( FILE *f, const gchar *magic_number, guint magic_length )
  77 {
  78   gchar magic[magic_length];
  79   gboolean rv = FALSE;
  80   gint8 i;
  81   if ( fread(magic, 1, sizeof(magic), f) == sizeof(magic) &&
  82       strncmp(magic, magic_number, sizeof(magic)) == 0 )
  83     rv = TRUE;
  84   for ( i = sizeof(magic)-1; i >= 0; i-- ) /* the ol' pushback */
  85     ungetc(magic[i],f);
  86   return rv;
  87 }
  88
  89
  90 static gboolean str_starts_with ( const gchar *haystack, const gchar *needle, guint16 len_needle, gboolean must_be_longer )
  91 {
  92   if ( strlen(haystack) > len_needle - (!must_be_longer) && strncasecmp ( haystack, needle, len_needle ) == 0 )
  93     return TRUE;
  94   return FALSE;
  95 }
  96
  97 void file_write_layer_param ( FILE *f, const gchar *name, VikLayerParamType type, VikLayerParamData data ) {
  98       /* string lists are handled differently. We get a GList (that shouldn't
  99        * be freed) back for get_param and if it is null we shouldn't write
 100        * anything at all (otherwise we'd read in a list with an empty string,
 101        * not an empty string list.
 102        */
 103       if ( type == VIK_LAYER_PARAM_STRING_LIST ) {
 104         if ( data.sl ) {
 105           GList *iter = (GList *)data.sl;
 106           while ( iter ) {
 107             fprintf ( f, "%s=", name );
 108             fprintf ( f, "%s\n", (gchar *)(iter->data) );
 109             iter = iter->next;
 110           }
 111         }
 112       } else {
 113         fprintf ( f, "%s=", name );
 114         switch ( type )
 115         {
 116           case VIK_LAYER_PARAM_DOUBLE: {
 117   //          char buf[15]; /* locale independent */
 118   //          fprintf ( f, "%s\n", (char *) g_dtostr (data.d, buf, sizeof (buf)) ); break;
 119               fprintf ( f, "%f\n", data.d );
 120               break;
 121          }
 122           case VIK_LAYER_PARAM_UINT: fprintf ( f, "%d\n", data.u ); break;
 123           case VIK_LAYER_PARAM_INT: fprintf ( f, "%d\n", data.i ); break;
 124           case VIK_LAYER_PARAM_BOOLEAN: fprintf ( f, "%c\n", data.b ? 't' : 'f' ); break;
 125           case VIK_LAYER_PARAM_STRING: fprintf ( f, "%s\n", data.s ? data.s : "" ); break;
 126           case VIK_LAYER_PARAM_COLOR: fprintf ( f, "#%.2x%.2x%.2x\n", (int)(data.c.red/256),(int)(data.c.green/256),(int)(data.c.blue/256)); break;
 127           default: break;
 128         }
 129       }
 130 }
 131
 132 static void write_layer_params_and_data ( VikLayer *l, FILE *f )
 133 {
 134   VikLayerParam *params = vik_layer_get_interface(l->type)->params;
 135   VikLayerFuncGetParam get_param = vik_layer_get_interface(l->type)->get_param;
 136
 137   fprintf ( f, "name=%s\n", l->name ? l->name : "" );
 138   if ( !l->visible )
 139     fprintf ( f, "visible=f\n" );
 140
 141   if ( params && get_param )
 142   {
 143     VikLayerParamData data;
 144     guint16 i, params_count = vik_layer_get_interface(l->type)->params_count;
 145     for ( i = 0; i < params_count; i++ )
 146     {
 147       data = get_param(l, i, TRUE);
 148       file_write_layer_param(f, params[i].name, params[i].type, data);
 149     }
 150   }
 151   if ( vik_layer_get_interface(l->type)->write_file_data )
 152   {
 153     fprintf ( f, "\n\n~LayerData\n" );
 154     vik_layer_get_interface(l->type)->write_file_data ( l, f );
 155     fprintf ( f, "~EndLayerData\n" );
 156   }
 157   /* foreach param:
 158      write param, and get_value, etc.
 159      then run layer data, and that's it.
 160   */
 161 }
 162
 163 static void file_write ( VikAggregateLayer *top, FILE *f, gpointer vp )
 164 {
 165   Stack *stack = NULL;
 166   VikLayer *current_layer;
 167   struct LatLon ll;
 168   VikViewportDrawMode mode;
 169   gchar *modestring = NULL;
 170
 171   push(&stack);
 172   stack->data = (gpointer) vik_aggregate_layer_get_children(VIK_AGGREGATE_LAYER(top));
 173   stack->under = NULL;
 174
 175   /* crazhy CRAZHY */
 176   vik_coord_to_latlon ( vik_viewport_get_center ( VIK_VIEWPORT(vp) ), &ll );
 177
 178   mode = vik_viewport_get_drawmode ( VIK_VIEWPORT(vp) );
 179   switch ( mode ) {
 180     case VIK_VIEWPORT_DRAWMODE_UTM: modestring = "utm"; break;
 181     case VIK_VIEWPORT_DRAWMODE_EXPEDIA: modestring = "expedia"; break;
 182     case VIK_VIEWPORT_DRAWMODE_MERCATOR: modestring = "mercator"; break;
 183     case VIK_VIEWPORT_DRAWMODE_LATLON: modestring = "latlon"; break;
 184     default:
 185       g_critical("Houston, we've had a problem. mode=%d", mode);
 186   }
 187
 188   fprintf ( f, "#VIKING GPS Data file " VIKING_URL "\n" );
 189   fprintf ( f, "FILE_VERSION=%d\n", VIKING_FILE_VERSION );
 190   fprintf ( f, "\nxmpp=%f\nympp=%f\nlat=%f\nlon=%f\nmode=%s\ncolor=%s\nhighlightcolor=%s\ndrawscale=%s\ndrawcentermark=%s\ndrawhighlight=%s\n",
 191       vik_viewport_get_xmpp ( VIK_VIEWPORT(vp) ), vik_viewport_get_ympp ( VIK_VIEWPORT(vp) ), ll.lat, ll.lon,
 192       modestring, vik_viewport_get_background_color(VIK_VIEWPORT(vp)),
 193       vik_viewport_get_highlight_color(VIK_VIEWPORT(vp)),
 194       vik_viewport_get_draw_scale(VIK_VIEWPORT(vp)) ? "t" : "f",
 195       vik_viewport_get_draw_centermark(VIK_VIEWPORT(vp)) ? "t" : "f",
 196       vik_viewport_get_draw_highlight(VIK_VIEWPORT(vp)) ? "t" : "f" );
 197
 198   if ( ! VIK_LAYER(top)->visible )
 199     fprintf ( f, "visible=f\n" );
 200
 201   while (stack && stack->data)
 202   {
 203     current_layer = VIK_LAYER(((GList *)stack->data)->data);
 204     fprintf ( f, "\n~Layer %s\n", vik_layer_get_interface(current_layer->type)->fixed_layer_name );
 205     write_layer_params_and_data ( current_layer, f );
 206     if ( current_layer->type == VIK_LAYER_AGGREGATE && !vik_aggregate_layer_is_empty(VIK_AGGREGATE_LAYER(current_layer)) )
 207     {
 208       push(&stack);
 209       stack->data = (gpointer) vik_aggregate_layer_get_children(VIK_AGGREGATE_LAYER(current_layer));
 210     }
 211     else if ( current_layer->type == VIK_LAYER_GPS && !vik_gps_layer_is_empty(VIK_GPS_LAYER(current_layer)) )
 212     {
 213       push(&stack);
 214       stack->data = (gpointer) vik_gps_layer_get_children(VIK_GPS_LAYER(current_layer));
 215     }
 216     else
 217     {
 218       stack->data = (gpointer) ((GList *)stack->data)->next;
 219       fprintf ( f, "~EndLayer\n\n" );
 220       while ( stack && (!stack->data) )
 221       {
 222         pop(&stack);
 223         if ( stack )
 224         {
 225           stack->data = (gpointer) ((GList *)stack->data)->next;
 226           fprintf ( f, "~EndLayer\n\n" );
 227         }
 228       }
 229     }
 230   }
 231 /*
 232   get vikaggregatelayer's children (?)
 233   foreach write ALL params,
 234   then layer data (IF function exists)
 235   then endlayer
 236
 237   impl:
 238   stack of layers (LIST) we are working on
 239   when layer->next == NULL ...
 240   we move on.
 241 */
 242 }
 243
 244 static void string_list_delete ( gpointer key, gpointer l, gpointer user_data )
 245 {
 246   /* 20071021 bugfix */
 247   GList *iter = (GList *) l;
 248   while ( iter ) {
 249     g_free ( iter->data );
 250     iter = iter->next;
 251   }
 252   g_list_free ( (GList *) l );
 253 }
 254
 255 static void string_list_set_param (gint i, GList *list, gpointer *layer_and_vp)
 256 {
 257   VikLayerSetParam vlsp;
 258   vlsp.id                  = i;
 259   vlsp.data.sl             = list;
 260   vlsp.vp                  = layer_and_vp[1];
 261   vlsp.is_file_operation   = TRUE;
 262   vlsp.dirpath             = (const gchar*)layer_and_vp[2];
 263
 264   vik_layer_set_param ( VIK_LAYER(layer_and_vp[0]), &vlsp );
 265 }
 266
 267 /**
 268  * Read in a Viking file and return how successful the parsing was
 269  * ATM this will always work, in that even if there are parsing problems
 270  *  then there will be no new values to override the defaults
 271  *
 272  * TODO flow up line number(s) / error messages of problems encountered...
 273  *
 274  */
 275 static gboolean file_read ( VikAggregateLayer *top, FILE *f, const gchar *dirpath, VikViewport *vp )
 276 {
 277   Stack *stack = NULL;
 278   struct LatLon ll = { 0.0, 0.0 };
 279   gchar buffer[4096];
 280   gchar *line;
 281   guint16 len;
 282   long line_num = 0;
 283
 284   VikLayerParam *params = NULL; /* for current layer, so we don't have to keep on looking up interface */
 285   guint8 params_count = 0;
 286
 287   GHashTable *string_lists = g_hash_table_new(g_direct_hash,g_direct_equal);
 288
 289   gboolean successful_read = TRUE;
 290
 291   push(&stack);
 292   stack->under = NULL;
 293   stack->data = (gpointer) top;
 294
 295   while ( fgets ( buffer, 4096, f ) )
 296   {
 297     line_num++;
 298
 299     line = buffer;
 300     while ( *line == ' ' || *line =='\t' )
 301       line++;
 302
 303     if ( line[0] == '#' )
 304       continue;
 305
 306
 307     len = strlen(line);
 308     if ( len > 0 && line[len-1] == '\n' )
 309       line[--len] = '\0';
 310     if ( len > 0 && line[len-1] == '\r' )
 311       line[--len] = '\0';
 312
 313     if ( len == 0 )
 314       continue;
 315
 316
 317     if ( line[0] == '~' )
 318     {
 319       line++; len--;
 320       if ( *line == '\0' )
 321         continue;
 322       else if ( str_starts_with ( line, "Layer ", 6, TRUE ) )
 323       {
 324         int parent_type = VIK_LAYER(stack->data)->type;
 325         if ( ( ! stack->data ) || ((parent_type != VIK_LAYER_AGGREGATE) && (parent_type != VIK_LAYER_GPS)) )
 326         {
 327           successful_read = FALSE;
 328           g_warning ( "Line %ld: Layer command inside non-Aggregate Layer (type %d)", line_num, parent_type );
 329           push(&stack); /* inside INVALID layer */
 330           stack->data = NULL;
 331           continue;
 332         }
 333         else
 334         {
 335           VikLayerTypeEnum type = vik_layer_type_from_string ( line+6 );
 336           push(&stack);
 337           if ( type == VIK_LAYER_NUM_TYPES )
 338           {
 339             successful_read = FALSE;
 340             g_warning ( "Line %ld: Unknown type %s", line_num, line+6 );
 341             stack->data = NULL;
 342           }
 343           else if (parent_type == VIK_LAYER_GPS)
 344           {
 345             stack->data = (gpointer) vik_gps_layer_get_a_child(VIK_GPS_LAYER(stack->under->data));
 346             params = vik_layer_get_interface(type)->params;
 347             params_count = vik_layer_get_interface(type)->params_count;
 348           }
 349           else
 350           {
 351             stack->data = (gpointer) vik_layer_create ( type, vp, FALSE );
 352             params = vik_layer_get_interface(type)->params;
 353             params_count = vik_layer_get_interface(type)->params_count;
 354           }
 355         }
 356       }
 357       else if ( str_starts_with ( line, "EndLayer", 8, FALSE ) )
 358       {
 359         if ( stack->under == NULL ) {
 360           successful_read = FALSE;
 361           g_warning ( "Line %ld: Mismatched ~EndLayer command", line_num );
 362         }
 363         else
 364         {
 365           /* add any string lists we've accumulated */
 366           gpointer layer_and_vp[3];
 367           layer_and_vp[0] = stack->data;
 368           layer_and_vp[1] = vp;
 369           layer_and_vp[2] = (gpointer)dirpath;
 370           g_hash_table_foreach ( string_lists, (GHFunc) string_list_set_param, layer_and_vp );
 371           g_hash_table_remove_all ( string_lists );
 372
 373           if ( stack->data && stack->under->data )
 374           {
 375             if (VIK_LAYER(stack->under->data)->type == VIK_LAYER_AGGREGATE) {
 376               vik_aggregate_layer_add_layer ( VIK_AGGREGATE_LAYER(stack->under->data), VIK_LAYER(stack->data), FALSE );
 377               vik_layer_post_read ( VIK_LAYER(stack->data), vp, TRUE );
 378             }
 379             else if (VIK_LAYER(stack->under->data)->type == VIK_LAYER_GPS) {
 380               /* TODO: anything else needs to be done here ? */
 381             }
 382             else {
 383               successful_read = FALSE;
 384               g_warning ( "Line %ld: EndLayer command inside non-Aggregate Layer (type %d)", line_num, VIK_LAYER(stack->data)->type );
 385             }
 386           }
 387           pop(&stack);
 388         }
 389       }
 390       else if ( str_starts_with ( line, "LayerData", 9, FALSE ) )
 391       {
 392         if ( stack->data && vik_layer_get_interface(VIK_LAYER(stack->data)->type)->read_file_data )
 393         {
 394           /* must read until hits ~EndLayerData */
 395           if ( ! vik_layer_get_interface(VIK_LAYER(stack->data)->type)->read_file_data ( VIK_LAYER(stack->data), f, dirpath ) )
 396             successful_read = FALSE;
 397         }
 398         else
 399         { /* simply skip layer data over */
 400           while ( fgets ( buffer, 4096, f ) )
 401           {
 402             line_num++;
 403
 404             line = buffer;
 405
 406             len = strlen(line);
 407             if ( len > 0 && line[len-1] == '\n' )
 408               line[--len] = '\0';
 409             if ( len > 0 && line[len-1] == '\r' )
 410               line[--len] = '\0';
 411             if ( strcasecmp ( line, "~EndLayerData" ) == 0 )
 412               break;
 413           }
 414           continue;
 415         }
 416       }
 417       else
 418       {
 419         successful_read = FALSE;
 420         g_warning ( "Line %ld: Unknown tilde command", line_num );
 421       }
 422     }
 423     else
 424     {
 425       gint32 eq_pos = -1;
 426       guint16 i;
 427       if ( ! stack->data )
 428         continue;
 429
 430       for ( i = 0; i < len; i++ )
 431         if ( line[i] == '=' )
 432           eq_pos = i;
 433
 434       if ( stack->under == NULL && eq_pos == 12 && strncasecmp ( line, "FILE_VERSION", eq_pos ) == 0) {
 435         gint version = strtol(line+13, NULL, 10);
 436         g_debug ( "%s: reading file version %d", __FUNCTION__, version );
 437         if ( version > VIKING_FILE_VERSION )
 438           successful_read = FALSE;
 439         // However we'll still carry and attempt to read whatever we can
 440       }
 441       else if ( stack->under == NULL && eq_pos == 4 && strncasecmp ( line, "xmpp", eq_pos ) == 0) /* "hard coded" params: global & for all layer-types */
 442         vik_viewport_set_xmpp ( VIK_VIEWPORT(vp), strtod_i8n ( line+5, NULL ) );
 443       else if ( stack->under == NULL && eq_pos == 4 && strncasecmp ( line, "ympp", eq_pos ) == 0)
 444         vik_viewport_set_ympp ( VIK_VIEWPORT(vp), strtod_i8n ( line+5, NULL ) );
 445       else if ( stack->under == NULL && eq_pos == 3 && strncasecmp ( line, "lat", eq_pos ) == 0 )
 446         ll.lat = strtod_i8n ( line+4, NULL );
 447       else if ( stack->under == NULL && eq_pos == 3 && strncasecmp ( line, "lon", eq_pos ) == 0 )
 448         ll.lon = strtod_i8n ( line+4, NULL );
 449       else if ( stack->under == NULL && eq_pos == 4 && strncasecmp ( line, "mode", eq_pos ) == 0 && strcasecmp ( line+5, "utm" ) == 0)
 450         vik_viewport_set_drawmode ( VIK_VIEWPORT(vp), VIK_VIEWPORT_DRAWMODE_UTM);
 451       else if ( stack->under == NULL && eq_pos == 4 && strncasecmp ( line, "mode", eq_pos ) == 0 && strcasecmp ( line+5, "expedia" ) == 0)
 452         vik_viewport_set_drawmode ( VIK_VIEWPORT(vp), VIK_VIEWPORT_DRAWMODE_EXPEDIA );
 453       else if ( stack->under == NULL && eq_pos == 4 && strncasecmp ( line, "mode", eq_pos ) == 0 && strcasecmp ( line+5, "google" ) == 0)
 454       {
 455         successful_read = FALSE;
 456         g_warning ( _("Draw mode '%s' no more supported"), "google" );
 457       }
 458       else if ( stack->under == NULL && eq_pos == 4 && strncasecmp ( line, "mode", eq_pos ) == 0 && strcasecmp ( line+5, "kh" ) == 0)
 459       {
 460         successful_read = FALSE;
 461         g_warning ( _("Draw mode '%s' no more supported"), "kh" );
 462       }
 463       else if ( stack->under == NULL && eq_pos == 4 && strncasecmp ( line, "mode", eq_pos ) == 0 && strcasecmp ( line+5, "mercator" ) == 0)
 464         vik_viewport_set_drawmode ( VIK_VIEWPORT(vp), VIK_VIEWPORT_DRAWMODE_MERCATOR );
 465       else if ( stack->under == NULL && eq_pos == 4 && strncasecmp ( line, "mode", eq_pos ) == 0 && strcasecmp ( line+5, "latlon" ) == 0)
 466         vik_viewport_set_drawmode ( VIK_VIEWPORT(vp), VIK_VIEWPORT_DRAWMODE_LATLON );
 467       else if ( stack->under == NULL && eq_pos == 5 && strncasecmp ( line, "color", eq_pos ) == 0 )
 468         vik_viewport_set_background_color ( VIK_VIEWPORT(vp), line+6 );
 469       else if ( stack->under == NULL && eq_pos == 14 && strncasecmp ( line, "highlightcolor", eq_pos ) == 0 )
 470         vik_viewport_set_highlight_color ( VIK_VIEWPORT(vp), line+15 );
 471       else if ( stack->under == NULL && eq_pos == 9 && strncasecmp ( line, "drawscale", eq_pos ) == 0 )
 472         vik_viewport_set_draw_scale ( VIK_VIEWPORT(vp), TEST_BOOLEAN(line+10) );
 473       else if ( stack->under == NULL && eq_pos == 14 && strncasecmp ( line, "drawcentermark", eq_pos ) == 0 )
 474         vik_viewport_set_draw_centermark ( VIK_VIEWPORT(vp), TEST_BOOLEAN(line+15) );
 475       else if ( stack->under == NULL && eq_pos == 13 && strncasecmp ( line, "drawhighlight", eq_pos ) == 0 )
 476         vik_viewport_set_draw_highlight ( VIK_VIEWPORT(vp), TEST_BOOLEAN(line+14) );
 477       else if ( stack->under && eq_pos == 4 && strncasecmp ( line, "name", eq_pos ) == 0 )
 478         vik_layer_rename ( VIK_LAYER(stack->data), line+5 );
 479       else if ( eq_pos == 7 && strncasecmp ( line, "visible", eq_pos ) == 0 )
 480         VIK_LAYER(stack->data)->visible = TEST_BOOLEAN(line+8);
 481       else if ( eq_pos != -1 && stack->under )
 482       {
 483         gboolean found_match = FALSE;
 484
 485         /* go thru layer params. if len == eq_pos && starts_with jazz, set it. */
 486         /* also got to check for name and visible. */
 487
 488         if ( ! params )
 489         {
 490           successful_read = FALSE;
 491           g_warning ( "Line %ld: No options for this kind of layer", line_num );
 492           continue;
 493         }
 494
 495         for ( i = 0; i < params_count; i++ )
 496           if ( strlen(params[i].name) == eq_pos && strncasecmp ( line, params[i].name, eq_pos ) == 0 )
 497           {
 498             VikLayerParamData x;
 499             line += eq_pos+1;
 500             if ( params[i].type == VIK_LAYER_PARAM_STRING_LIST ) {
 501               GList *l = g_list_append ( g_hash_table_lookup ( string_lists, GINT_TO_POINTER ((gint) i) ),
 502                                          g_strdup(line) );
 503               g_hash_table_replace ( string_lists, GINT_TO_POINTER ((gint)i), l );
 504               /* add the value to a list, possibly making a new list.
 505                * this will be passed to the layer when we read an ~EndLayer */
 506             } else {
 507               switch ( params[i].type )
 508               {
 509                 case VIK_LAYER_PARAM_DOUBLE: x.d = strtod_i8n(line, NULL); break;
 510                 case VIK_LAYER_PARAM_UINT: x.u = strtoul(line, NULL, 10); break;
 511                 case VIK_LAYER_PARAM_INT: x.i = strtol(line, NULL, 10); break;
 512                 case VIK_LAYER_PARAM_BOOLEAN: x.b = TEST_BOOLEAN(line); break;
 513                 case VIK_LAYER_PARAM_COLOR: memset(&(x.c), 0, sizeof(x.c)); /* default: black */
 514                                           gdk_color_parse ( line, &(x.c) ); break;
 515                 /* STRING or STRING_LIST -- if STRING_LIST, just set param to add a STRING */
 516                 default: x.s = line;
 517               }
 518
 519               VikLayerSetParam vlsp;
 520               vlsp.id                  = i;
 521               vlsp.data                = x;
 522               vlsp.vp                  = vp;
 523               vlsp.is_file_operation   = TRUE;
 524               vlsp.dirpath             = dirpath;
 525               vik_layer_set_param ( VIK_LAYER(stack->data), &vlsp );
 526             }
 527             found_match = TRUE;
 528             break;
 529           }
 530         if ( ! found_match ) {
 531           // ATM don't flow up this issue because at least one internal parameter has changed from version 1.3
 532           //   and don't what to worry users about raising such issues
 533           // TODO Maybe hold old values here - compare the line value against them and if a match
 534           //       generate a different style of message in the GUI...
 535           // successful_read = FALSE;
 536           g_warning ( "Line %ld: Unknown parameter. Line:\n%s", line_num, line );
 537         }
 538       }
 539       else {
 540         successful_read = FALSE;
 541         g_warning ( "Line %ld: Invalid parameter or parameter outside of layer.", line_num );
 542       }
 543     }
 544 /* could be:
 545 [Layer Type=Bla]
 546 [EndLayer]
 547 [LayerData]
 548 name=this
 549 #comment
 550 */
 551   }
 552
 553   while ( stack )
 554   {
 555     if ( stack->under && stack->under->data && stack->data )
 556     {
 557       vik_aggregate_layer_add_layer ( VIK_AGGREGATE_LAYER(stack->under->data), VIK_LAYER(stack->data), FALSE );
 558       vik_layer_post_read ( VIK_LAYER(stack->data), vp, TRUE );
 559     }
 560     pop(&stack);
 561   }
 562
 563   if ( ll.lat != 0.0 || ll.lon != 0.0 )
 564     vik_viewport_set_center_latlon ( VIK_VIEWPORT(vp), &ll, TRUE );
 565
 566   if ( ( ! VIK_LAYER(top)->visible ) && VIK_LAYER(top)->realized )
 567     vik_treeview_item_set_visible ( VIK_LAYER(top)->vt, &(VIK_LAYER(top)->iter), FALSE );
 568
 569   /* delete anything we've forgotten about -- should only happen when file ends before an EndLayer */
 570   g_hash_table_foreach ( string_lists, string_list_delete, NULL );
 571   g_hash_table_destroy ( string_lists );
 572
 573   return successful_read;
 574 }
 575
 576 /*
 577 read thru file
 578 if "[Layer Type="
 579   push(&stack)
 580   new default layer of type (str_to_type) (check interface->name)
 581 if "[EndLayer]"
 582   VikLayer *vl = stack->data;
 583   pop(&stack);
 584   vik_aggregate_layer_add_layer(stack->data, vl);
 585 if "[LayerData]"
 586   vik_layer_data ( VIK_LAYER_DATA(stack->data), f, vp );
 587
 588 */
 589
 590 /* ---------------------------------------------------- */
 591
 592 static FILE *xfopen ( const char *fn )
 593 {
 594   if ( strcmp(fn,"-") == 0 )
 595     return stdin;
 596   else
 597     return g_fopen(fn, "r");
 598 }
 599
 600 static void xfclose ( FILE *f )
 601 {
 602   if ( f != stdin && f != stdout ) {
 603     fclose ( f );
 604     f = NULL;
 605   }
 606 }
 607
 608 /*
 609  * Function to determine if a filename is a 'viking' type file
 610  */
 611 gboolean check_file_magic_vik ( const gchar *filename )
 612 {
 613   gboolean result = FALSE;
 614   FILE *ff = xfopen ( filename );
 615   if ( ff ) {
 616     result = check_magic ( ff, VIK_MAGIC, VIK_MAGIC_LEN );
 617     xfclose ( ff );
 618   }
 619   return result;
 620 }
 621
 622 /**
 623  * append_file_ext:
 624  *
 625  * Append a file extension, if not already present.
 626  *
 627  * Returns: a newly allocated string
 628  */
 629 gchar *append_file_ext ( const gchar *filename, VikFileType_t type )
 630 {
 631   gchar *new_name = NULL;
 632   const gchar *ext = NULL;
 633
 634   /* Select an extension */
 635   switch (type)
 636   {
 637   case FILE_TYPE_GPX:
 638     ext = ".gpx";
 639     break;
 640   case FILE_TYPE_KML:
 641     ext = ".kml";
 642     break;
 643   case FILE_TYPE_GEOJSON:
 644     ext = ".geojson";
 645     break;
 646   case FILE_TYPE_GPSMAPPER:
 647   case FILE_TYPE_GPSPOINT:
 648   default:
 649     /* Do nothing, ext already set to NULL */
 650     break;
 651   }
 652
 653   /* Do */
 654   if ( ext != NULL && ! a_file_check_ext ( filename, ext ) )
 655     new_name = g_strconcat ( filename, ext, NULL );
 656   else
 657     /* Simply duplicate */
 658     new_name = g_strdup ( filename );
 659
 660   return new_name;
 661 }
 662
 663 VikLoadType_t a_file_load ( VikAggregateLayer *top, VikViewport *vp, VikTrwLayer *vtl, const gchar *filename_or_uri )
 664 {
 665   g_return_val_if_fail ( vp != NULL, LOAD_TYPE_READ_FAILURE );
 666
 667   char *filename = (char *)filename_or_uri;
 668   if (strncmp(filename, "file://", 7) == 0) {
 669     // Consider replacing this with:
 670     // filename = g_filename_from_uri ( entry, NULL, NULL );
 671     // Since this doesn't support URIs properly (i.e. will failure if is it has %20 characters in it)
 672     filename = filename + 7;
 673     g_debug ( "Loading file %s from URI %s", filename, filename_or_uri );
 674   }
 675   FILE *f = xfopen ( filename );
 676
 677   if ( ! f )
 678     return LOAD_TYPE_READ_FAILURE;
 679
 680   VikLoadType_t load_answer = LOAD_TYPE_OTHER_SUCCESS;
 681
 682   gchar *dirpath = g_path_get_dirname ( filename );
 683   // Attempt loading the primary file type first - our internal .vik file:
 684   if ( check_magic ( f, VIK_MAGIC, VIK_MAGIC_LEN ) )
 685   {
 686     if ( file_read ( top, f, dirpath, vp ) )
 687       load_answer = LOAD_TYPE_VIK_SUCCESS;
 688     else
 689       load_answer = LOAD_TYPE_VIK_FAILURE_NON_FATAL;
 690   }
 691   else if ( a_jpg_magic_check ( filename ) ) {
 692     if ( ! a_jpg_load_file ( top, filename, vp ) )
 693       load_answer = LOAD_TYPE_UNSUPPORTED_FAILURE;
 694   }
 695   else
 696   {
 697         // For all other file types which consist of tracks, routes and/or waypoints,
 698         //  must be loaded into a new TrackWaypoint layer (hence it be created)
 699     gboolean success = TRUE; // Detect load failures - mainly to remove the layer created as it's not required
 700
 701     // Add to specified layer
 702     gboolean add_new = !IS_VIK_TRW_LAYER(vtl);
 703     if (add_new) {
 704       vtl = VIK_TRW_LAYER (vik_layer_create ( VIK_LAYER_TRW, vp, FALSE ));
 705       vik_layer_rename ( VIK_LAYER(vtl), a_file_basename ( filename ) );
 706     }
 707
 708     // In fact both kml & gpx files start the same as they are in xml
 709     if ( a_file_check_ext ( filename, ".kml" ) && check_magic ( f, GPX_MAGIC, GPX_MAGIC_LEN ) ) {
 710       // Implicit Conversion
 711       ProcessOptions po = { "-i kml", filename, NULL, NULL, NULL, NULL };
 712       if ( ! ( success = a_babel_convert_from ( vtl, &po, NULL, NULL, NULL ) ) ) {
 713         load_answer = LOAD_TYPE_GPSBABEL_FAILURE;
 714       }
 715     }
 716     // NB use a extension check first, as a GPX file header may have a Byte Order Mark (BOM) in it
 717     //    - which currently confuses our check_magic function
 718     else if ( a_file_check_ext ( filename, ".gpx" ) || check_magic ( f, GPX_MAGIC, GPX_MAGIC_LEN ) ) {
 719       if ( ! ( success = a_gpx_read_file ( vtl, f ) ) ) {
 720         load_answer = LOAD_TYPE_GPX_FAILURE;
 721       }
 722     }
 723     else {
 724       // Try final supported file type
 725       if ( ! ( success = a_gpspoint_read_file ( vtl, f, dirpath ) ) ) {
 726         // Failure here means we don't know how to handle the file
 727         load_answer = LOAD_TYPE_UNSUPPORTED_FAILURE;
 728       }
 729     }
 730     // Clean up when we can't handle the file
 731     if ( ! success ) {
 732       // free up layer
 733       g_object_unref ( vtl );
 734     }
 735     else {
 736       // Complete the setup from the successful load
 737       vik_layer_post_read ( VIK_LAYER(vtl), vp, TRUE );
 738       if (add_new) {
 739         vik_aggregate_layer_add_layer ( top, VIK_LAYER(vtl), FALSE );
 740       }
 741       else {
 742         // Make it more accessible in layers panel
 743         vik_layer_expand_tree ( VIK_LAYER(vtl) );
 744       }
 745       vik_trw_layer_auto_set_view ( vtl, vp );
 746     }
 747   }
 748   g_free ( dirpath );
 749   xfclose(f);
 750   return load_answer;
 751 }
 752
 753 gboolean a_file_save ( VikAggregateLayer *top, gpointer vp, const gchar *filename )
 754 {
 755   FILE *f;
 756
 757   if (strncmp(filename, "file://", 7) == 0)
 758     filename = filename + 7;
 759
 760   f = g_fopen(filename, "w");
 761
 762   if ( ! f )
 763     return FALSE;
 764
 765   // Enable relative paths in .vik files to work
 766   gchar *cwd = g_get_current_dir();
 767   gchar *dir = g_path_get_dirname ( filename );
 768   if ( dir ) {
 769     if ( g_chdir ( dir ) ) {
 770       g_warning ( "Could not change directory to %s", dir );
 771     }
 772     g_free (dir);
 773   }
 774
 775   file_write ( top, f, vp );
 776
 777   // Restore previous working directory
 778   if ( cwd ) {
 779     if ( g_chdir ( cwd ) ) {
 780       g_warning ( "Could not return to directory %s", cwd );
 781     }
 782     g_free (cwd);
 783   }
 784
 785   fclose(f);
 786   f = NULL;
 787
 788   return TRUE;
 789 }
 790
 791
 792 /* example:
 793      gboolean is_gpx = a_file_check_ext ( "a/b/c.gpx", ".gpx" );
 794 */
 795 gboolean a_file_check_ext ( const gchar *filename, const gchar *fileext )
 796 {
 797   g_return_val_if_fail ( filename != NULL, FALSE );
 798   g_return_val_if_fail ( fileext && fileext[0]=='.', FALSE );
 799   const gchar *basename = a_file_basename(filename);
 800   if (!basename)
 801     return FALSE;
 802
 803   const char * dot = strrchr(basename, '.');
 804   if (dot && !strcmp(dot, fileext))
 805     return TRUE;
 806
 807   return FALSE;
 808 }
 809
 810 /**
 811  * a_file_export:
 812  * @vtl: The TrackWaypoint to export data from
 813  * @filename: The name of the file to be written
 814  * @file_type: Choose one of the supported file types for the export
 815  * @trk: If specified then only export this track rather than the whole layer
 816  * @write_hidden: Whether to write invisible items
 817  *
 818  * A general export command to convert from Viking TRW layer data to an external supported format.
 819  * The write_hidden option is provided mainly to be able to transfer selected items when uploading to a GPS
 820  */
 821 gboolean a_file_export ( VikTrwLayer *vtl, const gchar *filename, VikFileType_t file_type, VikTrack *trk, gboolean write_hidden )
 822 {
 823   GpxWritingOptions options = { FALSE, FALSE, write_hidden, FALSE };
 824   FILE *f = g_fopen ( filename, "w" );
 825   if ( f )
 826   {
 827     gboolean result = TRUE;
 828
 829     if ( trk ) {
 830       switch ( file_type ) {
 831         case FILE_TYPE_GPX:
 832           // trk defined so can set the option
 833           options.is_route = trk->is_route;
 834           a_gpx_write_track_file ( trk, f, &options );
 835           break;
 836         default:
 837           g_critical("Houston, we've had a problem. file_type=%d", file_type);
 838       }
 839     } else {
 840       switch ( file_type ) {
 841         case FILE_TYPE_GPSMAPPER:
 842           a_gpsmapper_write_file ( vtl, f );
 843           break;
 844         case FILE_TYPE_GPX:
 845           a_gpx_write_file ( vtl, f, &options );
 846           break;
 847         case FILE_TYPE_GPSPOINT:
 848           a_gpspoint_write_file ( vtl, f );
 849           break;
 850         case FILE_TYPE_GEOJSON:
 851           result = a_geojson_write_file ( vtl, f );
 852           break;
 853         case FILE_TYPE_KML:
 854           fclose ( f );
 855           switch ( a_vik_get_kml_export_units () ) {
 856             case VIK_KML_EXPORT_UNITS_STATUTE:
 857               return a_babel_convert_to ( vtl, NULL, "-o kml", filename, NULL, NULL );
 858               break;
 859             case VIK_KML_EXPORT_UNITS_NAUTICAL:
 860               return a_babel_convert_to ( vtl, NULL, "-o kml,units=n", filename, NULL, NULL );
 861               break;
 862             default:
 863               // VIK_KML_EXPORT_UNITS_METRIC:
 864               return a_babel_convert_to ( vtl, NULL, "-o kml,units=m", filename, NULL, NULL );
 865               break;
 866           }
 867           break;
 868         default:
 869           g_critical("Houston, we've had a problem. file_type=%d", file_type);
 870       }
 871     }
 872     fclose ( f );
 873     return result;
 874   }
 875   return FALSE;
 876 }
 877
 878 /**
 879  * a_file_export_babel:
 880  */
 881 gboolean a_file_export_babel ( VikTrwLayer *vtl, const gchar *filename, const gchar *format,
 882                                gboolean tracks, gboolean routes, gboolean waypoints )
 883 {
 884   gchar *args = g_strdup_printf("%s %s %s -o %s",
 885                                 tracks ? "-t" : "",
 886                                 routes ? "-r" : "",
 887                                 waypoints ? "-w" : "",
 888                                 format);
 889   gboolean result = a_babel_convert_to ( vtl, NULL, args, filename, NULL, NULL );
 890   g_free(args);
 891   return result;
 892 }