src/viktrwlayer.c

   1 /*
   2  * viking -- GPS Data and Topo Analyzer, Explorer, and Manager
   3  *
   4  * Copyright (C) 2003-2005, Evan Battaglia <gtoevan@gmx.net>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  *
  20  */
  21
  22 #define WAYPOINT_FONT "Sans 8"
  23
  24 /* WARNING: If you go beyond this point, we are NOT responsible for any ill effects on your sanity */
  25 /* viktrwlayer.c -- 2200 lines can make a difference in the state of things */
  26
  27 #include "viking.h"
  28 #include "viktrwlayer_pixmap.h"
  29 #include "viktrwlayer_tpwin.h"
  30 #include "viktrwlayer_propwin.h"
  31 #include "thumbnails.h"
  32 #include "background.h"
  33
  34 #include <math.h>
  35 #include <string.h>
  36 #include <stdlib.h>
  37 #include <ctype.h>
  38
  39 #define VIK_TRW_LAYER_TRACK_GC 13
  40 #define VIK_TRW_LAYER_TRACK_GC_RATES 10
  41 #define VIK_TRW_LAYER_TRACK_GC_MIN 0
  42 #define VIK_TRW_LAYER_TRACK_GC_MAX 11
  43 #define VIK_TRW_LAYER_TRACK_GC_BLACK 12
  44
  45 #define DRAWMODE_BY_TRACK 0
  46 #define DRAWMODE_BY_VELOCITY 1
  47 #define DRAWMODE_ALL_BLACK 2
  48
  49 #define POINTS 1
  50 #define LINES 2
  51
  52 /* this is how it knows when you click if you are clicking close to a trackpoint. */
  53 #define TRACKPOINT_SIZE_APPROX 5
  54 #define WAYPOINT_SIZE_APPROX 5
  55
  56 enum {
  57 VIK_TRW_LAYER_SUBLAYER_TRACKS,
  58 VIK_TRW_LAYER_SUBLAYER_WAYPOINTS,
  59 VIK_TRW_LAYER_SUBLAYER_TRACK,
  60 VIK_TRW_LAYER_SUBLAYER_WAYPOINT
  61 };
  62
  63 enum { WP_SYMBOL_FILLED_SQUARE, WP_SYMBOL_SQUARE, WP_SYMBOL_CIRCLE, WP_SYMBOL_X, WP_NUM_SYMBOLS };
  64
  65 struct _VikTrwLayer {
  66   VikLayer vl;
  67   GHashTable *tracks;
  68   GHashTable *tracks_iters;
  69   GHashTable *waypoints_iters;
  70   GHashTable *waypoints;
  71   GtkTreeIter waypoints_iter, tracks_iter;
  72   gboolean tracks_visible, waypoints_visible;
  73   guint8 drawmode;
  74   guint8 drawpoints;
  75   guint8 drawlines;
  76   guint8 line_thickness;
  77   guint8 bg_line_thickness;
  78
  79   guint8 wp_symbol;
  80   guint8 wp_size;
  81
  82   gdouble velocity_min, velocity_max;
  83   GArray *track_gc;
  84   guint16 track_gc_iter;
  85   GdkGC *track_bg_gc;
  86   GdkGC *waypoint_gc;
  87   GdkGC *waypoint_text_gc;
  88   GdkGC *waypoint_bg_gc;
  89   GdkFont *waypoint_font;
  90   VikTrack *current_track;
  91   guint16 ct_x1, ct_y1, ct_x2, ct_y2;
  92
  93   VikCoordMode coord_mode;
  94
  95   /* wp editing tool */
  96   VikWaypoint *current_wp;
  97   gchar *current_wp_name;
  98   gboolean moving_wp;
  99   gboolean waypoint_rightclick;
 100
 101   /* track editing tool */
 102   GList *current_tpl;
 103   gchar *current_tp_track_name;
 104   VikTrwLayerTpwin *tpwin;
 105
 106   /* weird hack for joining tracks */
 107   GList *last_tpl;
 108   gchar *last_tp_track_name;
 109
 110   /* track editing tool -- more specifically, moving tps */
 111   gboolean moving_tp;
 112
 113   gboolean drawlabels;
 114   gboolean drawimages;
 115   guint8 image_alpha;
 116   GQueue *image_cache;
 117   guint8 image_size;
 118   guint16 image_cache_size;
 119
 120   /* for waypoint text */
 121   PangoLayout *wplabellayout;
 122
 123   gboolean has_verified_thumbnails;
 124
 125   GtkMenu *wp_right_click_menu;
 126
 127 };
 128
 129 /* A caached waypoint image. */
 130 typedef struct {
 131   GdkPixbuf *pixbuf;
 132   gchar *image; /* filename */
 133 } CachedPixbuf;
 134
 135 struct DrawingParams {
 136   VikViewport *vp;
 137   VikTrwLayer *vtl;
 138   gdouble xmpp, ympp;
 139   guint16 width, height;
 140   const VikCoord *center;
 141   gint track_gc_iter;
 142   gboolean one_zone, lat_lon;
 143   gdouble ce1, ce2, cn1, cn2;
 144 };
 145
 146 static void trw_layer_find_maxmin_waypoints ( const gchar *name, const VikWaypoint *w, struct LatLon maxmin[2] );
 147 static void trw_layer_find_maxmin_tracks ( const gchar *name, GList **t, struct LatLon maxmin[2] );
 148
 149 static void trw_layer_new_track_gcs ( VikTrwLayer *vtl, VikViewport *vp );
 150 static void trw_layer_free_track_gcs ( VikTrwLayer *vtl );
 151
 152 static gint calculate_velocity ( VikTrwLayer *vtl, VikTrackpoint *tp1, VikTrackpoint *tp2 );
 153 static void trw_layer_draw_track_cb ( const gchar *name, VikTrack *track, struct DrawingParams *dp );
 154 static void trw_layer_draw_waypoint ( const gchar *name, VikWaypoint *wp, struct DrawingParams *dp );
 155
 156 static void goto_coord ( VikLayersPanel *vlp, const VikCoord *coord );
 157 static void trw_layer_goto_track_startpoint ( gpointer pass_along[5] );
 158 static void trw_layer_goto_track_endpoint ( gpointer pass_along[6] );
 159 static void trw_layer_merge_by_timestamp ( gpointer pass_along[6] );
 160 static void trw_layer_split_by_timestamp ( gpointer pass_along[6] );
 161 static void trw_layer_centerize ( gpointer layer_and_vlp[2] );
 162 static void trw_layer_export ( gpointer layer_and_vlp[2], guint file_type );
 163 static void trw_layer_goto_wp ( gpointer layer_and_vlp[2] );
 164 static void trw_layer_new_wp ( gpointer lav[2] );
 165
 166 /* pop-up items */
 167 static void trw_layer_properties_item ( gpointer pass_along[5] );
 168 static void trw_layer_goto_waypoint ( gpointer pass_along[5] );
 169 static void trw_layer_waypoint_gc_webpage ( gpointer pass_along[5] );
 170
 171 static void trw_layer_realize_waypoint ( gchar *name, VikWaypoint *wp, gpointer pass_along[4] );
 172 static void trw_layer_realize_track ( gchar *name, VikTrack *track, gpointer pass_along[4] );
 173 static void init_drawing_params ( struct DrawingParams *dp, VikViewport *vp );
 174
 175 static gboolean tool_new_waypoint ( VikTrwLayer *vtl, GdkEventButton *event, VikViewport *vvp );
 176 static gboolean tool_new_track ( VikTrwLayer *vtl, GdkEventButton *event, VikViewport *vvp );
 177
 178 static VikTrwLayer *trw_layer_copy ( VikTrwLayer *vtl, gpointer vp );
 179 static gboolean trw_layer_set_param ( VikTrwLayer *vtl, guint16 id, VikLayerParamData data, VikViewport *vp );
 180 static VikLayerParamData trw_layer_get_param ( VikTrwLayer *vtl, guint16 id );
 181
 182 static gpointer trw_layer_copy_item ( VikTrwLayer *vtl, gint subtype, gpointer sublayer );
 183 static gboolean trw_layer_paste_item ( VikTrwLayer *vtl, gint subtype, gpointer item );
 184 static void trw_layer_free_copied_item ( gint subtype, gpointer item );
 185
 186 static void trw_layer_cancel_tps_of_track ( VikTrwLayer *vtl, const gchar *trk_name );
 187 static void trw_layer_cancel_last_tp ( VikTrwLayer *vtl );
 188 static void trw_layer_cancel_current_tp ( VikTrwLayer *vtl, gboolean destroy );
 189 static void trw_layer_tpwin_response ( VikTrwLayer *vtl, gint response );
 190 static void trw_layer_tpwin_init ( VikTrwLayer *vtl );
 191 static gboolean tool_edit_trackpoint ( VikTrwLayer *vtl, GdkEventButton *event, VikViewport *vvp );
 192 static gboolean tool_edit_trackpoint_release ( VikTrwLayer *vtl, GdkEventButton *event, VikViewport *vvp );
 193 static gboolean tool_show_picture ( VikTrwLayer *vtl, GdkEventButton *event, VikViewport *vvp );
 194
 195 static gboolean tool_edit_waypoint ( VikTrwLayer *vtl, GdkEventButton *event, VikViewport *vvp );
 196 static gboolean tool_edit_waypoint_release ( VikTrwLayer *vtl, GdkEventButton *event, VikViewport *vvp );
 197
 198 static gboolean uppercase_exists_in_hash ( GHashTable *hash, const gchar *str );
 199
 200 static void cached_pixbuf_free ( CachedPixbuf *cp );
 201 static gint cached_pixbuf_cmp ( CachedPixbuf *cp, const gchar *name );
 202 static void trw_layer_verify_thumbnails ( VikTrwLayer *vtl, GtkWidget *vp );
 203
 204 static VikTrackpoint *closest_tp_in_five_pixel_interval ( VikTrwLayer *vtl, VikViewport *vvp, gint x, gint y );
 205 static VikWaypoint *closest_wp_in_five_pixel_interval ( VikTrwLayer *vtl, VikViewport *vvp, gint x, gint y );
 206
 207 static void trw_layer_change_coord_mode ( VikTrwLayer *vtl, VikCoordMode dest_mode );
 208
 209 static VikToolInterface trw_layer_tools[] = {
 210   { "Create Waypoint", (VikToolInterfaceFunc) tool_new_waypoint, NULL },
 211   { "Create Track", (VikToolInterfaceFunc) tool_new_track, NULL },
 212   { "Edit Waypoint", (VikToolInterfaceFunc) tool_edit_waypoint, (VikToolInterfaceFunc) tool_edit_waypoint_release },
 213   { "Edit Trackpoint", (VikToolInterfaceFunc) tool_edit_trackpoint, (VikToolInterfaceFunc) tool_edit_trackpoint_release },
 214   { "Show Picture", (VikToolInterfaceFunc) tool_show_picture, NULL },
 215 };
 216
 217
 218 /****** PARAMETERS ******/
 219
 220 static gchar *params_groups[] = { "Waypoints", "Tracks", "Waypoint Images" };
 221 enum { GROUP_WAYPOINTS, GROUP_TRACKS, GROUP_IMAGES };
 222
 223 static gchar *params_drawmodes[] = { "Draw by Track", "Draw by Velocity", "All Tracks Black", 0 };
 224 static gchar *params_wpsymbols[] = { "Filled Square", "Square", "Circle", "X", 0 };
 225
 226 static VikLayerParamScale params_scales[] = {
 227  /* min  max    step digits */
 228  {  1,   10,    1,   0 }, /* line_thickness */
 229  {  0.0, 99.0,  1,   2 }, /* velocity_min */
 230  {  1.0, 100.0, 1.0, 2 }, /* velocity_max */
 231                 /* 5 * step == how much to turn */
 232  {  16,   128,  3.2, 0 }, /* image_size */
 233  {   0,   255,  5,   0 }, /* image alpha */
 234  {   5,   500,  5,   0 }, /* image cache_size */
 235  {   0,   8,    1,   0 }, /* image cache_size */
 236  {   1,  64,    1,   0 }, /* wpsize */
 237 };
 238
 239 VikLayerParam trw_layer_params[] = {
 240   { "tracks_visible", VIK_LAYER_PARAM_BOOLEAN, VIK_LAYER_NOT_IN_PROPERTIES },
 241   { "waypoints_visible", VIK_LAYER_PARAM_BOOLEAN, VIK_LAYER_NOT_IN_PROPERTIES },
 242
 243   { "drawmode", VIK_LAYER_PARAM_UINT, GROUP_TRACKS, "Track Drawing Mode:", VIK_LAYER_WIDGET_RADIOGROUP, params_drawmodes },
 244   { "drawlines", VIK_LAYER_PARAM_BOOLEAN, GROUP_TRACKS, "Draw Track Lines", VIK_LAYER_WIDGET_CHECKBUTTON },
 245   { "drawpoints", VIK_LAYER_PARAM_BOOLEAN, GROUP_TRACKS, "Draw Trackpoints", VIK_LAYER_WIDGET_CHECKBUTTON },
 246   { "line_thickness", VIK_LAYER_PARAM_UINT, GROUP_TRACKS, "Track Thickness:", VIK_LAYER_WIDGET_SPINBUTTON, params_scales + 0 },
 247   { "bg_line_thickness", VIK_LAYER_PARAM_UINT, GROUP_TRACKS, "Track BG Thickness:", VIK_LAYER_WIDGET_SPINBUTTON, params_scales + 6 },
 248   { "trackbgcolor", VIK_LAYER_PARAM_COLOR, GROUP_TRACKS, "Track Background Color", VIK_LAYER_WIDGET_COLOR, 0 },
 249   { "velocity_min", VIK_LAYER_PARAM_DOUBLE, GROUP_TRACKS, "Min Track Velocity:", VIK_LAYER_WIDGET_SPINBUTTON, params_scales + 1 },
 250   { "velocity_max", VIK_LAYER_PARAM_DOUBLE, GROUP_TRACKS, "Max Track Velocity:", VIK_LAYER_WIDGET_SPINBUTTON, params_scales + 2 },
 251
 252   { "drawlabels", VIK_LAYER_PARAM_BOOLEAN, GROUP_WAYPOINTS, "Draw Labels", VIK_LAYER_WIDGET_CHECKBUTTON },
 253   { "wpcolor", VIK_LAYER_PARAM_COLOR, GROUP_WAYPOINTS, "Waypoint Color:", VIK_LAYER_WIDGET_COLOR, 0 },
 254   { "wptextcolor", VIK_LAYER_PARAM_COLOR, GROUP_WAYPOINTS, "Waypoint Text:", VIK_LAYER_WIDGET_COLOR, 0 },
 255   { "wpbgcolor", VIK_LAYER_PARAM_COLOR, GROUP_WAYPOINTS, "Background:", VIK_LAYER_WIDGET_COLOR, 0 },
 256   { "wpbgand", VIK_LAYER_PARAM_BOOLEAN, GROUP_WAYPOINTS, "Fake BG Color Translucency:", VIK_LAYER_WIDGET_CHECKBUTTON, 0 },
 257   { "wpsymbol", VIK_LAYER_PARAM_UINT, GROUP_WAYPOINTS, "Waypoint symbol:", VIK_LAYER_WIDGET_RADIOGROUP, params_wpsymbols },
 258   { "wpsize", VIK_LAYER_PARAM_UINT, GROUP_WAYPOINTS, "Waypoint size:", VIK_LAYER_WIDGET_SPINBUTTON, params_scales + 7 },
 259
 260   { "drawimages", VIK_LAYER_PARAM_BOOLEAN, GROUP_IMAGES, "Draw Waypoint Images", VIK_LAYER_WIDGET_CHECKBUTTON },
 261   { "image_size", VIK_LAYER_PARAM_UINT, GROUP_IMAGES, "Image Size (pixels):", VIK_LAYER_WIDGET_HSCALE, params_scales + 3 },
 262   { "image_alpha", VIK_LAYER_PARAM_UINT, GROUP_IMAGES, "Image Alpha:", VIK_LAYER_WIDGET_HSCALE, params_scales + 4 },
 263   { "image_cache_size", VIK_LAYER_PARAM_UINT, GROUP_IMAGES, "Image Memory Cache Size:", VIK_LAYER_WIDGET_HSCALE, params_scales + 5 },
 264 };
 265
 266 enum { PARAM_TV, PARAM_WV, PARAM_DM, PARAM_DL, PARAM_DP, PARAM_LT, PARAM_BLT, PARAM_TBGC, PARAM_VMIN, PARAM_VMAX, PARAM_DLA, PARAM_WPC, PARAM_WPTC, PARAM_WPBC, PARAM_WPBA, PARAM_WPSYM, PARAM_WPSIZE, PARAM_DI, PARAM_IS, PARAM_IA, PARAM_ICS, NUM_PARAMS };
 267
 268 /****** END PARAMETERS ******/
 269
 270 VikLayerInterface vik_trw_layer_interface = {
 271   "TrackWaypoint",
 272   &trwlayer_pixbuf,
 273
 274   trw_layer_tools,
 275   sizeof(trw_layer_tools) / sizeof(VikToolInterface),
 276
 277   trw_layer_params,
 278   NUM_PARAMS,
 279   params_groups, /* params_groups */
 280   sizeof(params_groups)/sizeof(params_groups[0]),    /* number of groups */
 281
 282   (VikLayerFuncCreate)                  vik_trw_layer_create,
 283   (VikLayerFuncRealize)                 vik_trw_layer_realize,
 284   (VikLayerFuncPostRead)                trw_layer_verify_thumbnails,
 285   (VikLayerFuncFree)                    vik_trw_layer_free,
 286
 287   (VikLayerFuncProperties)              NULL,
 288   (VikLayerFuncDraw)                    vik_trw_layer_draw,
 289   (VikLayerFuncChangeCoordMode)         trw_layer_change_coord_mode,
 290
 291   (VikLayerFuncAddMenuItems)            vik_trw_layer_add_menu_items,
 292   (VikLayerFuncSublayerAddMenuItems)    vik_trw_layer_sublayer_add_menu_items,
 293
 294   (VikLayerFuncSublayerRenameRequest)   vik_trw_layer_sublayer_rename_request,
 295   (VikLayerFuncSublayerToggleVisible)   vik_trw_layer_sublayer_toggle_visible,
 296
 297   (VikLayerFuncCopy)                    trw_layer_copy,
 298
 299   (VikLayerFuncSetParam)                trw_layer_set_param,
 300   (VikLayerFuncGetParam)                trw_layer_get_param,
 301
 302   (VikLayerFuncReadFileData)            a_gpspoint_read_file,
 303   (VikLayerFuncWriteFileData)           a_gpspoint_write_file,
 304
 305   (VikLayerFuncCopyItem)                trw_layer_copy_item,
 306   (VikLayerFuncPasteItem)               trw_layer_paste_item,
 307   (VikLayerFuncFreeCopiedItem)          trw_layer_free_copied_item,
 308 };
 309
 310 /* for copy & paste (I think?) */
 311 typedef struct {
 312   gchar *name;
 313   VikWaypoint *wp;
 314 } NamedWaypoint;
 315
 316 typedef struct {
 317   gchar *name;
 318   VikTrack *tr;
 319 } NamedTrack;
 320
 321 GType vik_trw_layer_get_type ()
 322 {
 323   static GType vtl_type = 0;
 324
 325   if (!vtl_type)
 326   {
 327     static const GTypeInfo vtl_info =
 328     {
 329       sizeof (VikTrwLayerClass),
 330       NULL, /* base_init */
 331       NULL, /* base_finalize */
 332       NULL, /* class init */
 333       NULL, /* class_finalize */
 334       NULL, /* class_data */
 335       sizeof (VikTrwLayer),
 336       0,
 337       NULL /* instance init */
 338     };
 339     vtl_type = g_type_register_static ( VIK_LAYER_TYPE, "VikTrwLayer", &vtl_info, 0 );
 340   }
 341
 342   return vtl_type;
 343 }
 344
 345
 346 static gpointer trw_layer_copy_item ( VikTrwLayer *vtl, gint subtype, gpointer sublayer )
 347 {
 348   if ( subtype == VIK_TRW_LAYER_SUBLAYER_WAYPOINT && sublayer )
 349   {
 350     NamedWaypoint *nw = g_malloc ( sizeof ( NamedWaypoint ) );
 351     nw->name = g_strdup(sublayer);
 352     nw->wp = vik_waypoint_copy ( g_hash_table_lookup ( vtl->waypoints, sublayer ) );
 353     return nw;
 354   }
 355   if ( subtype == VIK_TRW_LAYER_SUBLAYER_TRACK && sublayer )
 356   {
 357     NamedTrack *nt = g_malloc ( sizeof ( NamedTrack ) );
 358     nt->name = g_strdup(sublayer);
 359     nt->tr = g_hash_table_lookup ( vtl->tracks, sublayer );
 360     vik_track_ref(nt->tr);
 361     return nt;
 362   }
 363   return NULL;
 364 }
 365
 366 static gboolean trw_layer_paste_item ( VikTrwLayer *vtl, gint subtype, gpointer item )
 367 {
 368   if ( subtype == VIK_TRW_LAYER_SUBLAYER_WAYPOINT && item )
 369   {
 370     NamedWaypoint *nw = (NamedWaypoint *) item;
 371     vik_trw_layer_add_waypoint ( vtl, g_strdup(nw->name), vik_waypoint_copy(nw->wp) );
 372     return TRUE;
 373   }
 374   if ( subtype == VIK_TRW_LAYER_SUBLAYER_TRACK && item )
 375   {
 376     NamedTrack *nt = (NamedTrack *) item;
 377     vik_trw_layer_add_track ( vtl, g_strdup(nt->name), vik_track_copy(nt->tr) );
 378     return TRUE;
 379   }
 380   return FALSE;
 381 }
 382
 383 static void trw_layer_free_copied_item ( gint subtype, gpointer item )
 384 {
 385   if ( subtype == VIK_TRW_LAYER_SUBLAYER_WAYPOINT && item )
 386   {
 387     NamedWaypoint *nw = (NamedWaypoint *) item;
 388     g_free ( nw->name );
 389     vik_waypoint_free ( nw->wp );
 390     g_free ( nw );
 391   }
 392   if ( subtype == VIK_TRW_LAYER_SUBLAYER_TRACK && item )
 393   {
 394     NamedTrack *nt = (NamedTrack *) item;
 395     g_free ( nt->name );
 396     vik_track_free ( nt->tr );
 397     g_free ( nt );
 398   }
 399 }
 400
 401 static void waypoint_copy ( const gchar *name, VikWaypoint *wp, GHashTable *dest )
 402 {
 403   g_hash_table_insert ( dest, g_strdup(name), vik_waypoint_copy(wp) );
 404 }
 405
 406 static gboolean trw_layer_set_param ( VikTrwLayer *vtl, guint16 id, VikLayerParamData data, VikViewport *vp )
 407 {
 408   switch ( id )
 409   {
 410     case PARAM_TV: vtl->tracks_visible = data.b; break;
 411     case PARAM_WV: vtl->waypoints_visible = data.b; break;
 412     case PARAM_DM: vtl->drawmode = data.u; break;
 413     case PARAM_DP: vtl->drawpoints = data.b; break;
 414     case PARAM_DL: vtl->drawlines = data.b; break;
 415     case PARAM_LT: if ( data.u > 0 && data.u < 15 && data.u != vtl->line_thickness )
 416                    {
 417                      vtl->line_thickness = data.u;
 418                      trw_layer_new_track_gcs ( vtl, vp );
 419                    }
 420                    break;
 421     case PARAM_BLT: if ( data.u > 0 && data.u <= 8 && data.u != vtl->bg_line_thickness )
 422                    {
 423                      vtl->bg_line_thickness = data.u;
 424                      trw_layer_new_track_gcs ( vtl, vp );
 425                    }
 426                    break;
 427     case PARAM_VMIN: vtl->velocity_min = data.d; break;
 428     case PARAM_VMAX: vtl->velocity_max = data.d; break;
 429     case PARAM_TBGC: gdk_gc_set_rgb_fg_color(vtl->track_bg_gc, &(data.c)); break;
 430     case PARAM_DLA: vtl->drawlabels = data.b; break;
 431     case PARAM_DI: vtl->drawimages = data.b; break;
 432     case PARAM_IS: if ( data.u != vtl->image_size )
 433       {
 434         vtl->image_size = data.u;
 435         g_list_foreach ( vtl->image_cache->head, (GFunc) cached_pixbuf_free, NULL );
 436         g_queue_free ( vtl->image_cache );
 437         vtl->image_cache = g_queue_new ();
 438       }
 439       break;
 440     case PARAM_IA: vtl->image_alpha = data.u; break;
 441     case PARAM_ICS: vtl->image_cache_size = data.u;
 442       while ( vtl->image_cache->length > vtl->image_cache_size ) /* if shrinking cache_size, free pixbuf ASAP */
 443           cached_pixbuf_free ( g_queue_pop_tail ( vtl->image_cache ) );
 444       break;
 445     case PARAM_WPC: gdk_gc_set_rgb_fg_color(vtl->waypoint_gc, &(data.c)); break;
 446     case PARAM_WPTC: gdk_gc_set_rgb_fg_color(vtl->waypoint_text_gc, &(data.c)); break;
 447     case PARAM_WPBC: gdk_gc_set_rgb_fg_color(vtl->waypoint_bg_gc, &(data.c)); break;
 448     case PARAM_WPBA: gdk_gc_set_function(vtl->waypoint_bg_gc, data.b ? GDK_AND : GDK_COPY ); break;
 449     case PARAM_WPSYM: if ( data.u < WP_NUM_SYMBOLS ) vtl->wp_symbol = data.u; break;
 450     case PARAM_WPSIZE: if ( data.u > 0 && data.u <= 64 ) vtl->wp_size = data.u; break;
 451   }
 452   return TRUE;
 453 }
 454
 455 static VikLayerParamData trw_layer_get_param ( VikTrwLayer *vtl, guint16 id )
 456 {
 457   VikLayerParamData rv;
 458   switch ( id )
 459   {
 460     case PARAM_TV: rv.b = vtl->tracks_visible; break;
 461     case PARAM_WV: rv.b = vtl->waypoints_visible; break;
 462     case PARAM_DM: rv.u = vtl->drawmode; break;
 463     case PARAM_DP: rv.b = vtl->drawpoints; break;
 464     case PARAM_DL: rv.b = vtl->drawlines; break;
 465     case PARAM_LT: rv.u = vtl->line_thickness; break;
 466     case PARAM_BLT: rv.u = vtl->bg_line_thickness; break;
 467     case PARAM_VMIN: rv.d = vtl->velocity_min; break;
 468     case PARAM_VMAX: rv.d = vtl->velocity_max; break;
 469     case PARAM_DLA: rv.b = vtl->drawlabels; break;
 470     case PARAM_DI: rv.b = vtl->drawimages; break;
 471     case PARAM_TBGC: vik_gc_get_fg_color(vtl->track_bg_gc, &(rv.c)); break;
 472     case PARAM_IS: rv.u = vtl->image_size; break;
 473     case PARAM_IA: rv.u = vtl->image_alpha; break;
 474     case PARAM_ICS: rv.u = vtl->image_cache_size; break;
 475     case PARAM_WPC: vik_gc_get_fg_color(vtl->waypoint_gc, &(rv.c)); break;
 476     case PARAM_WPTC: vik_gc_get_fg_color(vtl->waypoint_text_gc, &(rv.c)); break;
 477     case PARAM_WPBC: vik_gc_get_fg_color(vtl->waypoint_bg_gc, &(rv.c)); break;
 478     case PARAM_WPBA: rv.b = (vik_gc_get_function(vtl->waypoint_bg_gc)==GDK_AND); break;
 479     case PARAM_WPSYM: rv.u = vtl->wp_symbol; break;
 480     case PARAM_WPSIZE: rv.u = vtl->wp_size; break;
 481   }
 482   return rv;
 483 }
 484
 485 static void track_copy ( const gchar *name, VikTrack *tr, GHashTable *dest )
 486 {
 487   g_hash_table_insert ( dest, g_strdup ( name ), vik_track_copy(tr) );
 488 }
 489
 490 static VikTrwLayer *trw_layer_copy ( VikTrwLayer *vtl, gpointer vp )
 491 {
 492   VikTrwLayer *rv = vik_trw_layer_new ( vtl->drawmode );
 493   PangoFontDescription *pfd;
 494   rv->wplabellayout = gtk_widget_create_pango_layout (GTK_WIDGET(vp), NULL);
 495   pfd = pango_font_description_from_string (WAYPOINT_FONT);
 496   pango_layout_set_font_description (rv->wplabellayout, pfd);
 497   /* freeing PangoFontDescription, cause it has been copied by prev. call */
 498   pango_font_description_free (pfd);
 499
 500   rv->tracks_visible = vtl->tracks_visible;
 501   rv->waypoints_visible = vtl->waypoints_visible;
 502   rv->drawpoints = vtl->drawpoints;
 503   rv->drawlines = vtl->drawlines;
 504   rv->line_thickness = vtl->line_thickness;
 505   rv->bg_line_thickness = vtl->bg_line_thickness;
 506   rv->velocity_min = vtl->velocity_min;
 507   rv->velocity_max = vtl->velocity_max;
 508   rv->drawlabels = vtl->drawlabels;
 509   rv->drawimages = vtl->drawimages;
 510   rv->image_size = vtl->image_size;
 511   rv->image_alpha = vtl->image_alpha;
 512   rv->image_cache_size = vtl->image_cache_size;
 513   rv->has_verified_thumbnails = TRUE;
 514   rv->coord_mode = vtl->coord_mode;
 515   rv->wp_symbol = vtl->wp_symbol;
 516   rv->wp_size = vtl->wp_size;
 517
 518   trw_layer_new_track_gcs ( rv, VIK_VIEWPORT(vp) );
 519
 520   rv->waypoint_gc = gdk_gc_new ( GTK_WIDGET(vp)->window );
 521   gdk_gc_set_line_attributes ( rv->waypoint_gc, 2, GDK_LINE_SOLID, GDK_CAP_ROUND, GDK_JOIN_ROUND );
 522
 523   rv->waypoint_text_gc = gdk_gc_new ( GTK_WIDGET(vp)->window );
 524   rv->waypoint_bg_gc = gdk_gc_new ( GTK_WIDGET(vp)->window );
 525   gdk_gc_copy ( rv->waypoint_gc, vtl->waypoint_gc );
 526   gdk_gc_copy ( rv->waypoint_text_gc, vtl->waypoint_text_gc );
 527   gdk_gc_copy ( rv->waypoint_bg_gc, vtl->waypoint_bg_gc );
 528
 529   rv->waypoint_font = gdk_font_load ( "-*-helvetica-bold-r-normal-*-*-100-*-*-p-*-iso8859-1" );
 530
 531   g_hash_table_foreach ( vtl->waypoints, (GHFunc) waypoint_copy, rv->waypoints );
 532   g_hash_table_foreach ( vtl->tracks, (GHFunc) track_copy, rv->tracks );
 533
 534   return rv;
 535 }
 536
 537 VikTrwLayer *vik_trw_layer_new ( gint drawmode )
 538 {
 539   VikTrwLayer *rv = VIK_TRW_LAYER ( g_object_new ( VIK_TRW_LAYER_TYPE, NULL ) );
 540   vik_layer_init ( VIK_LAYER(rv), VIK_LAYER_TRW );
 541
 542   rv->waypoints = g_hash_table_new_full ( g_str_hash, g_str_equal, g_free, (GDestroyNotify) vik_waypoint_free );
 543   rv->tracks = g_hash_table_new_full ( g_str_hash, g_str_equal, g_free, (GDestroyNotify) vik_track_free );
 544   rv->tracks_iters = g_hash_table_new_full ( g_str_hash, g_str_equal, NULL, g_free );
 545   rv->waypoints_iters = g_hash_table_new_full ( g_str_hash, g_str_equal, NULL, g_free );
 546
 547   /* TODO: constants at top */
 548   rv->waypoints_visible = rv->tracks_visible = TRUE;
 549   rv->drawmode = drawmode;
 550   rv->drawpoints = TRUE;
 551   rv->drawlines = TRUE;
 552   rv->wplabellayout = NULL;
 553   rv->wp_right_click_menu = NULL;
 554   rv->waypoint_gc = NULL;
 555   rv->waypoint_text_gc = NULL;
 556   rv->waypoint_bg_gc = NULL;
 557   rv->track_gc = NULL;
 558   rv->velocity_max = 5.0;
 559   rv->velocity_min = 0.0;
 560   rv->line_thickness = 1;
 561   rv->line_thickness = 0;
 562   rv->current_wp = NULL;
 563   rv->current_wp_name = NULL;
 564   rv->current_track = NULL;
 565   rv->current_tpl = NULL;
 566   rv->current_tp_track_name = NULL;
 567   rv->moving_tp = FALSE;
 568   rv->moving_wp = FALSE;
 569   rv->waypoint_rightclick = FALSE;
 570   rv->last_tpl = NULL;
 571   rv->last_tp_track_name = NULL;
 572   rv->tpwin = NULL;
 573   rv->image_cache = g_queue_new();
 574   rv->image_size = 64;
 575   rv->image_alpha = 255;
 576   rv->image_cache_size = 300;
 577   rv->drawimages = TRUE;
 578   rv->drawlabels = TRUE;
 579   return rv;
 580 }
 581
 582
 583 void vik_trw_layer_free ( VikTrwLayer *trwlayer )
 584 {
 585   g_hash_table_destroy(trwlayer->waypoints);
 586   g_hash_table_destroy(trwlayer->tracks);
 587
 588   /* ODC: replace with GArray */
 589   trw_layer_free_track_gcs ( trwlayer );
 590
 591   if ( trwlayer->wp_right_click_menu )
 592     gtk_object_sink ( GTK_OBJECT(trwlayer->wp_right_click_menu) );
 593
 594   if ( trwlayer->wplabellayout != NULL)
 595     g_object_unref ( G_OBJECT ( trwlayer->wplabellayout ) );
 596
 597   if ( trwlayer->waypoint_gc != NULL )
 598     g_object_unref ( G_OBJECT ( trwlayer->waypoint_gc ) );
 599
 600   if ( trwlayer->waypoint_text_gc != NULL )
 601     g_object_unref ( G_OBJECT ( trwlayer->waypoint_text_gc ) );
 602
 603   if ( trwlayer->waypoint_bg_gc != NULL )
 604     g_object_unref ( G_OBJECT ( trwlayer->waypoint_bg_gc ) );
 605
 606   if ( trwlayer->waypoint_font != NULL )
 607     gdk_font_unref ( trwlayer->waypoint_font );
 608
 609   if ( trwlayer->tpwin != NULL )
 610     gtk_widget_destroy ( GTK_WIDGET(trwlayer->tpwin) );
 611
 612   g_list_foreach ( trwlayer->image_cache->head, (GFunc) cached_pixbuf_free, NULL );
 613   g_queue_free ( trwlayer->image_cache );
 614 }
 615
 616 static void init_drawing_params ( struct DrawingParams *dp, VikViewport *vp )
 617 {
 618   dp->vp = vp;
 619   dp->xmpp = vik_viewport_get_xmpp ( vp );
 620   dp->ympp = vik_viewport_get_ympp ( vp );
 621   dp->width = vik_viewport_get_width ( vp );
 622   dp->height = vik_viewport_get_height ( vp );
 623   dp->center = vik_viewport_get_center ( vp );
 624   dp->one_zone = vik_viewport_is_one_zone ( vp ); /* false if some other projection besides UTM */
 625   dp->lat_lon = vik_viewport_get_coord_mode ( vp ) == VIK_COORD_LATLON;
 626
 627   if ( dp->one_zone )
 628   {
 629     gint w2, h2;
 630     w2 = dp->xmpp * (dp->width / 2) + 1600 / dp->xmpp;
 631     h2 = dp->ympp * (dp->height / 2) + 1600 / dp->ympp;
 632     /* leniency -- for tracks. Obviously for waypoints this SHOULD be a lot smaller */
 633
 634     dp->ce1 = dp->center->east_west-w2;
 635     dp->ce2 = dp->center->east_west+w2;
 636     dp->cn1 = dp->center->north_south-h2;
 637     dp->cn2 = dp->center->north_south+h2;
 638   } else if ( dp->lat_lon ) {
 639     VikCoord upperleft, bottomright;
 640     /* quick & dirty calculation; really want to check all corners due to lat/lon smaller at top in northern hemisphere */
 641     /* this also DOESN'T WORK if you are crossing 180/-180 lon. I don't plan to in the near future...  */
 642     vik_viewport_screen_to_coord ( vp, -500, -500, &upperleft );
 643     vik_viewport_screen_to_coord ( vp, dp->width+500, dp->height+500, &bottomright );
 644     dp->ce1 = upperleft.east_west;
 645     dp->ce2 = bottomright.east_west;
 646     dp->cn1 = bottomright.north_south;
 647     dp->cn2 = upperleft.north_south;
 648   }
 649
 650   dp->track_gc_iter = 0;
 651 }
 652
 653 static gint calculate_velocity ( VikTrwLayer *vtl, VikTrackpoint *tp1, VikTrackpoint *tp2 )
 654 {
 655   static gdouble rv = 0;
 656   if ( tp1->has_timestamp && tp2->has_timestamp )
 657   {
 658     rv = ( vik_coord_diff ( &(tp1->coord), &(tp2->coord) )
 659            / (tp1->timestamp - tp2->timestamp) ) - vtl->velocity_min;
 660
 661     if ( rv < 0 )
 662       return VIK_TRW_LAYER_TRACK_GC_MIN;
 663     else if ( vtl->velocity_min >= vtl->velocity_max )
 664       return VIK_TRW_LAYER_TRACK_GC_MAX;
 665
 666     rv *= (VIK_TRW_LAYER_TRACK_GC_RATES / (vtl->velocity_max - vtl->velocity_min));
 667
 668     if ( rv >= VIK_TRW_LAYER_TRACK_GC_MAX )
 669       return VIK_TRW_LAYER_TRACK_GC_MAX;
 670     return (gint) rv;
 671  }
 672  else
 673    return VIK_TRW_LAYER_TRACK_GC_BLACK;
 674 }
 675
 676 void draw_utm_skip_insignia ( VikViewport *vvp, GdkGC *gc, gint x, gint y )
 677 {
 678   vik_viewport_draw_line ( vvp, gc, x+5, y, x-5, y );
 679   vik_viewport_draw_line ( vvp, gc, x, y+5, x, y-5 );
 680   vik_viewport_draw_line ( vvp, gc, x+5, y+5, x-5, y-5 );
 681   vik_viewport_draw_line ( vvp, gc, x+5, y-5, x-5, y+5 );
 682 }
 683
 684 static void trw_layer_draw_track ( const gchar *name, VikTrack *track, struct DrawingParams *dp, gboolean drawing_white_background )
 685 {
 686   /* TODO: this function is a mess, get rid of any redundancy */
 687   GList *list = track->trackpoints;
 688   gboolean useoldvals = TRUE;
 689
 690   gboolean drawpoints;
 691
 692   const guint8 tp_size_reg = 2;
 693   const guint8 tp_size_cur = 4;
 694   guint8 tp_size;
 695
 696   if ( ! track->visible )
 697     return;
 698
 699   /* admittedly this is not an efficient way to do it because we go through the whole GC thing all over... */
 700   if ( dp->vtl->bg_line_thickness && !drawing_white_background )
 701     trw_layer_draw_track ( name, track, dp, TRUE );
 702
 703   if ( drawing_white_background )
 704     drawpoints = FALSE;
 705   else
 706     drawpoints = dp->vtl->drawpoints;
 707
 708   if (list) {
 709     int x, y, oldx, oldy;
 710     VikTrackpoint *tp = VIK_TRACKPOINT(list->data);
 711
 712     tp_size = (list == dp->vtl->current_tpl) ? tp_size_cur : tp_size_reg;
 713
 714     vik_viewport_coord_to_screen ( dp->vp, &(tp->coord), &x, &y );
 715
 716     if ( (drawpoints) && dp->track_gc_iter < VIK_TRW_LAYER_TRACK_GC )
 717     {
 718       GdkPoint trian[3] = { { x, y-(3*tp_size) }, { x-(2*tp_size), y+(2*tp_size) }, {x+(2*tp_size), y+(2*tp_size)} };
 719       vik_viewport_draw_polygon ( dp->vp, g_array_index(dp->vtl->track_gc, GdkGC *, dp->track_gc_iter), TRUE, trian, 3 );
 720     }
 721
 722     oldx = x;
 723     oldy = y;
 724
 725     if ( dp->vtl->drawmode == DRAWMODE_ALL_BLACK )
 726       dp->track_gc_iter = VIK_TRW_LAYER_TRACK_GC_MAX + 1;
 727
 728     while ((list = g_list_next(list)))
 729     {
 730       tp = VIK_TRACKPOINT(list->data);
 731       tp_size = (list == dp->vtl->current_tpl) ? tp_size_cur : tp_size_reg;
 732
 733       /* check some stuff -- but only if we're in UTM and there's only ONE ZONE; or lat lon */
 734       if ( (!dp->one_zone && !dp->lat_lon) ||     /* UTM & zones; do everything */
 735              ( ((!dp->one_zone) || tp->coord.utm_zone == dp->center->utm_zone) &&   /* only check zones if UTM & one_zone */
 736              tp->coord.east_west < dp->ce2 && tp->coord.east_west > dp->ce1 &&  /* both UTM and lat lon */
 737              tp->coord.north_south > dp->cn1 && tp->coord.north_south < dp->cn2 ) )
 738       {
 739         vik_viewport_coord_to_screen ( dp->vp, &(tp->coord), &x, &y );
 740
 741         if ( drawpoints && ! drawing_white_background )
 742         {
 743           if ( list->next ) {
 744             vik_viewport_draw_rectangle ( dp->vp, g_array_index(dp->vtl->track_gc, GdkGC *, dp->track_gc_iter), TRUE, x-tp_size, y-tp_size, 2*tp_size, 2*tp_size );
 745
 746 #if 0
 747             if ( VIK_TRACKPOINT(list->next->data)->altitude != VIK_DEFAULT_ALTITUDE )
 748               vik_viewport_draw_line ( dp->vp, g_array_index(dp->vtl->track_gc, GdkGC *, dp->track_gc_iter), x, y, x, y-(VIK_TRACKPOINT(list->next->data)->altitude-540)/5);
 749 #endif
 750
 751             vik_viewport_draw_rectangle ( dp->vp, g_array_index(dp->vtl->track_gc, GdkGC *, dp->track_gc_iter), TRUE, x-tp_size, y-tp_size, 2*tp_size, 2*tp_size );
 752
 753             /* stops */
 754             if (0 && VIK_TRACKPOINT(list->next->data)->timestamp - VIK_TRACKPOINT(list->data)->timestamp > 60 )
 755               vik_viewport_draw_arc ( dp->vp, g_array_index(dp->vtl->track_gc, GdkGC *, 11), TRUE, x-(3*tp_size), y-(3*tp_size), 6*tp_size, 6*tp_size, 0, 360*64 );
 756           }
 757           else
 758             vik_viewport_draw_arc ( dp->vp, g_array_index(dp->vtl->track_gc, GdkGC *, dp->track_gc_iter), TRUE, x-(2*tp_size), y-(2*tp_size), 4*tp_size, 4*tp_size, 0, 360*64 );
 759         }
 760
 761         if ((!tp->newsegment) && (dp->vtl->drawlines))
 762         {
 763           VikTrackpoint *tp2 = VIK_TRACKPOINT(list->prev->data);
 764
 765           /* UTM only: zone check */
 766           if ( drawpoints && dp->vtl->coord_mode == VIK_COORD_UTM && tp->coord.utm_zone != dp->center->utm_zone )
 767             draw_utm_skip_insignia (  dp->vp, g_array_index(dp->vtl->track_gc, GdkGC *, dp->track_gc_iter), x, y);
 768
 769           if ( dp->vtl->drawmode == DRAWMODE_BY_VELOCITY )
 770             dp->track_gc_iter = calculate_velocity ( dp->vtl, tp, tp2 );
 771
 772           if (!useoldvals)
 773             vik_viewport_coord_to_screen ( dp->vp, &(tp2->coord), &oldx, &oldy );
 774
 775           if ( drawing_white_background )
 776             vik_viewport_draw_line ( dp->vp, dp->vtl->track_bg_gc, oldx, oldy, x, y);
 777           else
 778             vik_viewport_draw_line ( dp->vp, g_array_index(dp->vtl->track_gc, GdkGC *, dp->track_gc_iter), oldx, oldy, x, y);
 779         }
 780
 781         oldx = x;
 782         oldy = y;
 783         useoldvals = TRUE;
 784       }
 785       else {
 786         if (useoldvals && dp->vtl->drawlines && (!tp->newsegment))
 787         {
 788           VikTrackpoint *tp2 = VIK_TRACKPOINT(list->prev->data);
 789           if ( dp->vtl->coord_mode != VIK_COORD_UTM || tp->coord.utm_zone == dp->center->utm_zone )
 790           {
 791             vik_viewport_coord_to_screen ( dp->vp, &(tp->coord), &x, &y );
 792             if ( dp->vtl->drawmode == DRAWMODE_BY_VELOCITY )
 793               dp->track_gc_iter = calculate_velocity ( dp->vtl, tp, tp2 );
 794
 795             if ( drawing_white_background )
 796               vik_viewport_draw_line ( dp->vp, dp->vtl->track_bg_gc, oldx, oldy, x, y);
 797             else
 798               vik_viewport_draw_line ( dp->vp, g_array_index(dp->vtl->track_gc, GdkGC *, dp->track_gc_iter), oldx, oldy, x, y);
 799           }
 800           else
 801           {
 802             vik_viewport_coord_to_screen ( dp->vp, &(tp2->coord), &x, &y );
 803             draw_utm_skip_insignia ( dp->vp, g_array_index(dp->vtl->track_gc, GdkGC *, dp->track_gc_iter), x, y );
 804           }
 805         }
 806         useoldvals = FALSE;
 807       }
 808     }
 809   }
 810   if ( dp->vtl->drawmode == DRAWMODE_BY_TRACK )
 811     if ( ++(dp->track_gc_iter) >= VIK_TRW_LAYER_TRACK_GC )
 812       dp->track_gc_iter = 0;
 813 }
 814
 815 /* the only reason this exists is so that trw_layer_draw_track can first call itself to draw the white track background */
 816 static void trw_layer_draw_track_cb ( const gchar *name, VikTrack *track, struct DrawingParams *dp )
 817 {
 818   trw_layer_draw_track ( name, track, dp, FALSE );
 819 }
 820
 821 static void cached_pixbuf_free ( CachedPixbuf *cp )
 822 {
 823   g_object_unref ( G_OBJECT(cp->pixbuf) );
 824   g_free ( cp->image );
 825 }
 826
 827 static gint cached_pixbuf_cmp ( CachedPixbuf *cp, const gchar *name )
 828 {
 829   return strcmp ( cp->image, name );
 830 }
 831
 832 static void trw_layer_draw_waypoint ( const gchar *name, VikWaypoint *wp, struct DrawingParams *dp )
 833 {
 834   if ( wp->visible )
 835   if ( (!dp->one_zone) || ( wp->coord.utm_zone == dp->center->utm_zone &&
 836              wp->coord.east_west < dp->ce2 && wp->coord.east_west > dp->ce1 &&
 837              wp->coord.north_south > dp->cn1 && wp->coord.north_south < dp->cn2 ) )
 838   {
 839     gint x, y;
 840     vik_viewport_coord_to_screen ( dp->vp, &(wp->coord), &x, &y );
 841
 842     /* if in shrunken_cache, get that. If not, get and add to shrunken_cache */
 843
 844     if ( wp->image && dp->vtl->drawimages )
 845     {
 846       GdkPixbuf *pixbuf = NULL;
 847       GList *l;
 848
 849       if ( dp->vtl->image_alpha == 0)
 850         return;
 851
 852       l = g_list_find_custom ( dp->vtl->image_cache->head, wp->image, (GCompareFunc) cached_pixbuf_cmp );
 853       if ( l )
 854         pixbuf = ((CachedPixbuf *) l->data)->pixbuf;
 855       else
 856       {
 857         gchar *image = wp->image;
 858         GdkPixbuf *regularthumb = a_thumbnails_get ( wp->image );
 859         if ( ! regularthumb )
 860         {
 861           regularthumb = a_thumbnails_get_default (); /* cache one 'not yet loaded' for all thumbs not loaded */
 862           image = "\x12\x00"; /* this shouldn't occur naturally. */
 863         }
 864         if ( regularthumb )
 865         {
 866           CachedPixbuf *cp = NULL;
 867           cp = g_malloc ( sizeof ( CachedPixbuf ) );
 868           if ( dp->vtl->image_size == 128 )
 869             cp->pixbuf = regularthumb;
 870           else
 871           {
 872             cp->pixbuf = a_thumbnails_scale_pixbuf(regularthumb, dp->vtl->image_size, dp->vtl->image_size);
 873             g_assert ( cp->pixbuf );
 874             g_object_unref ( G_OBJECT(regularthumb) );
 875           }
 876           cp->image = g_strdup ( image );
 877
 878           /* needed so 'click picture' tool knows how big the pic is; we don't
 879            * store it in cp because they may have been freed already. */
 880           wp->image_width = gdk_pixbuf_get_width ( cp->pixbuf );
 881           wp->image_height = gdk_pixbuf_get_height ( cp->pixbuf );
 882
 883           g_queue_push_head ( dp->vtl->image_cache, cp );
 884           if ( dp->vtl->image_cache->length > dp->vtl->image_cache_size )
 885             cached_pixbuf_free ( g_queue_pop_tail ( dp->vtl->image_cache ) );
 886
 887           pixbuf = cp->pixbuf;
 888         }
 889         else
 890         {
 891           pixbuf = a_thumbnails_get_default (); /* thumbnail not yet loaded */
 892         }
 893       }
 894       if ( pixbuf )
 895       {
 896         gint w, h;
 897         w = gdk_pixbuf_get_width ( pixbuf );
 898         h = gdk_pixbuf_get_height ( pixbuf );
 899
 900         if ( x+(w/2) > 0 && y+(h/2) > 0 && x-(w/2) < dp->width && y-(h/2) < dp->height ) /* always draw within boundaries */
 901         {
 902           if ( dp->vtl->image_alpha == 255 )
 903             vik_viewport_draw_pixbuf ( dp->vp, pixbuf, 0, 0, x - (w/2), y - (h/2), w, h );
 904           else
 905             vik_viewport_draw_pixbuf_with_alpha ( dp->vp, pixbuf, dp->vtl->image_alpha, 0, 0, x - (w/2), y - (h/2), w, h );
 906         }
 907         return; /* if failed to draw picture, default to drawing regular waypoint (below) */
 908       }
 909     }
 910
 911     /* DRAW ACTUAL DOT */
 912     if ( wp == dp->vtl->current_wp ) {
 913       switch ( dp->vtl->wp_symbol ) {
 914         case WP_SYMBOL_FILLED_SQUARE: vik_viewport_draw_rectangle ( dp->vp, dp->vtl->waypoint_gc, TRUE, x - (dp->vtl->wp_size), y - (dp->vtl->wp_size), dp->vtl->wp_size*2, dp->vtl->wp_size*2 ); break;
 915         case WP_SYMBOL_SQUARE: vik_viewport_draw_rectangle ( dp->vp, dp->vtl->waypoint_gc, FALSE, x - (dp->vtl->wp_size), y - (dp->vtl->wp_size), dp->vtl->wp_size*2, dp->vtl->wp_size*2 ); break;
 916         case WP_SYMBOL_CIRCLE: vik_viewport_draw_arc ( dp->vp, dp->vtl->waypoint_gc, TRUE, x - dp->vtl->wp_size, y - dp->vtl->wp_size, dp->vtl->wp_size, dp->vtl->wp_size, 0, 360*64 ); break;
 917         case WP_SYMBOL_X: vik_viewport_draw_line ( dp->vp, dp->vtl->waypoint_gc, x - dp->vtl->wp_size*2, y - dp->vtl->wp_size*2, x + dp->vtl->wp_size*2, y + dp->vtl->wp_size*2 );
 918                           vik_viewport_draw_line ( dp->vp, dp->vtl->waypoint_gc, x - dp->vtl->wp_size*2, y + dp->vtl->wp_size*2, x + dp->vtl->wp_size*2, y - dp->vtl->wp_size*2 );
 919       }
 920     }
 921     else {
 922       switch ( dp->vtl->wp_symbol ) {
 923         case WP_SYMBOL_FILLED_SQUARE: vik_viewport_draw_rectangle ( dp->vp, dp->vtl->waypoint_gc, TRUE, x - dp->vtl->wp_size/2, y - dp->vtl->wp_size/2, dp->vtl->wp_size, dp->vtl->wp_size ); break;
 924         case WP_SYMBOL_SQUARE: vik_viewport_draw_rectangle ( dp->vp, dp->vtl->waypoint_gc, FALSE, x - dp->vtl->wp_size/2, y - dp->vtl->wp_size/2, dp->vtl->wp_size, dp->vtl->wp_size ); break;
 925         case WP_SYMBOL_CIRCLE: vik_viewport_draw_arc ( dp->vp, dp->vtl->waypoint_gc, TRUE, x-dp->vtl->wp_size/2, y-dp->vtl->wp_size/2, dp->vtl->wp_size, dp->vtl->wp_size, 0, 360*64 ); break;
 926         case WP_SYMBOL_X: vik_viewport_draw_line ( dp->vp, dp->vtl->waypoint_gc, x-dp->vtl->wp_size, y-dp->vtl->wp_size, x+dp->vtl->wp_size, y+dp->vtl->wp_size );
 927                           vik_viewport_draw_line ( dp->vp, dp->vtl->waypoint_gc, x-dp->vtl->wp_size, y+dp->vtl->wp_size, x+dp->vtl->wp_size, y-dp->vtl->wp_size ); break;
 928       }
 929     }
 930
 931     if ( dp->vtl->drawlabels )
 932     {
 933       /* thanks to the GPSDrive people (Fritz Ganter et al.) for hints on this part ... yah, I'm too lazy to study documentation */
 934       gint width, height;
 935       pango_layout_set_text ( dp->vtl->wplabellayout, name, -1 );
 936       pango_layout_get_pixel_size ( dp->vtl->wplabellayout, &width, &height );
 937       vik_viewport_draw_rectangle ( dp->vp, dp->vtl->waypoint_bg_gc, TRUE, x + dp->vtl->wp_size - 1, y-1,width+1,height-1);
 938       vik_viewport_draw_layout ( dp->vp, dp->vtl->waypoint_text_gc, x + dp->vtl->wp_size, y, dp->vtl->wplabellayout );
 939     }
 940   }
 941 }
 942
 943 void vik_trw_layer_draw ( VikTrwLayer *l, gpointer data )
 944 {
 945   static struct DrawingParams dp;
 946   g_assert ( l != NULL );
 947
 948   init_drawing_params ( &dp, VIK_VIEWPORT(data) );
 949   dp.vtl = l;
 950
 951   if ( l->tracks_visible )
 952     g_hash_table_foreach ( l->tracks, (GHFunc) trw_layer_draw_track_cb, &dp );
 953
 954   if (l->waypoints_visible)
 955     g_hash_table_foreach ( l->waypoints, (GHFunc) trw_layer_draw_waypoint, &dp );
 956 }
 957
 958 static void trw_layer_free_track_gcs ( VikTrwLayer *vtl )
 959 {
 960   int i;
 961   if ( vtl->track_bg_gc )
 962   {
 963     g_object_unref ( vtl->track_bg_gc );
 964     vtl->track_bg_gc = NULL;
 965   }
 966
 967   if ( ! vtl->track_gc )
 968     return;
 969   for ( i = vtl->track_gc->len - 1; i >= 0; i-- )
 970     g_object_unref ( g_array_index ( vtl->track_gc, GObject *, i ) );
 971   g_array_free ( vtl->track_gc, TRUE );
 972   vtl->track_gc = NULL;
 973 }
 974
 975 static void trw_layer_new_track_gcs ( VikTrwLayer *vtl, VikViewport *vp )
 976 {
 977   GdkGC *gc[ VIK_TRW_LAYER_TRACK_GC ];
 978   gint width = vtl->line_thickness;
 979
 980   if ( vtl->track_gc )
 981     trw_layer_free_track_gcs ( vtl );
 982
 983   if ( vtl->track_bg_gc )
 984     g_object_unref ( vtl->track_bg_gc );
 985   vtl->track_bg_gc = vik_viewport_new_gc ( vp, "#FFFFFF", width + vtl->bg_line_thickness );
 986
 987   vtl->track_gc = g_array_sized_new ( FALSE, FALSE, sizeof ( GdkGC * ), VIK_TRW_LAYER_TRACK_GC );
 988
 989   gc[0] = vik_viewport_new_gc ( vp, "#2d870a", width ); /* below range */
 990
 991   gc[1] = vik_viewport_new_gc ( vp, "#0a8742", width );
 992   gc[2] = vik_viewport_new_gc ( vp, "#0a8783", width );
 993   gc[3] = vik_viewport_new_gc ( vp, "#0a4d87", width );
 994   gc[4] = vik_viewport_new_gc ( vp, "#05469f", width );
 995   gc[5] = vik_viewport_new_gc ( vp, "#1b059f", width );
 996   gc[6] = vik_viewport_new_gc ( vp, "#2d059f", width );
 997   gc[7] = vik_viewport_new_gc ( vp, "#4a059f", width );
 998   gc[8] = vik_viewport_new_gc ( vp, "#84059f", width );
 999   gc[9] = vik_viewport_new_gc ( vp, "#96059f", width );
1000   gc[10] = vik_viewport_new_gc ( vp, "#f22ef2", width );
1001
1002   gc[11] = vik_viewport_new_gc ( vp, "#ff0000", width ); /* above range */
1003
1004   gc[12] = vik_viewport_new_gc ( vp, "#000000", width ); /* black / no speed data */
1005
1006   g_array_append_vals ( vtl->track_gc, gc, VIK_TRW_LAYER_TRACK_GC );
1007 }
1008
1009 VikTrwLayer *vik_trw_layer_create ( VikViewport *vp )
1010 {
1011   VikTrwLayer *rv = vik_trw_layer_new ( 0 );
1012   PangoFontDescription *pfd;
1013   rv->wplabellayout = gtk_widget_create_pango_layout (GTK_WIDGET(vp), NULL);
1014   pfd = pango_font_description_from_string (WAYPOINT_FONT);
1015   pango_layout_set_font_description (rv->wplabellayout, pfd);
1016   /* freeing PangoFontDescription, cause it has been copied by prev. call */
1017   pango_font_description_free (pfd);
1018
1019   vik_layer_rename ( VIK_LAYER(rv), vik_trw_layer_interface.name );
1020
1021   trw_layer_new_track_gcs ( rv, vp );
1022
1023   rv->waypoint_gc = vik_viewport_new_gc ( vp, "#000000", 2 );
1024   rv->waypoint_text_gc = vik_viewport_new_gc ( vp, "#FFFFFF", 1 );
1025   rv->waypoint_bg_gc = vik_viewport_new_gc ( vp, "#8383C4", 1 );
1026   gdk_gc_set_function ( rv->waypoint_bg_gc, GDK_AND );
1027
1028   rv->waypoint_font = gdk_font_load ( "-*-helvetica-bold-r-normal-*-*-100-*-*-p-*-iso8859-1" );
1029
1030   rv->has_verified_thumbnails = FALSE;
1031   rv->wp_symbol = WP_SYMBOL_FILLED_SQUARE;
1032   rv->wp_size = 4;
1033
1034   rv->coord_mode = vik_viewport_get_coord_mode ( vp );
1035
1036   return rv;
1037 }
1038
1039 static void trw_layer_realize_track ( gchar *name, VikTrack *track, gpointer pass_along[4] )
1040 {
1041   GtkTreeIter *new_iter = g_malloc(sizeof(GtkTreeIter));
1042
1043 #ifdef VIK_CONFIG_ALPHABETIZED_TRW
1044   vik_treeview_add_sublayer_alphabetized ( (VikTreeview *) pass_along[3], (GtkTreeIter *) pass_along[0], (GtkTreeIter *) pass_along[1], name, pass_along[2], name, (gint) pass_along[4], NULL, TRUE, TRUE );
1045 #else
1046   vik_treeview_add_sublayer ( (VikTreeview *) pass_along[3], (GtkTreeIter *) pass_along[0], (GtkTreeIter *) pass_along[1], name, pass_along[2], name, (gint) pass_along[4], NULL, TRUE, TRUE );
1047 #endif
1048
1049   *new_iter = *((GtkTreeIter *) pass_along[1]);
1050   g_hash_table_insert ( VIK_TRW_LAYER(pass_along[2])->tracks_iters, name, new_iter );
1051
1052   if ( ! track->visible )
1053     vik_treeview_item_set_visible ( (VikTreeview *) pass_along[3], (GtkTreeIter *) pass_along[1], FALSE );
1054 }
1055
1056 static void trw_layer_realize_waypoint ( gchar *name, VikWaypoint *wp, gpointer pass_along[4] )
1057 {
1058   GtkTreeIter *new_iter = g_malloc(sizeof(GtkTreeIter));
1059 #ifdef VIK_CONFIG_ALPHABETIZED_TRW
1060   vik_treeview_add_sublayer_alphabetized ( (VikTreeview *) pass_along[3], (GtkTreeIter *) pass_along[0], (GtkTreeIter *) pass_along[1], name, pass_along[2], name, (gint) pass_along[4], NULL, TRUE, TRUE );
1061 #else
1062   vik_treeview_add_sublayer ( (VikTreeview *) pass_along[3], (GtkTreeIter *) pass_along[0], (GtkTreeIter *) pass_along[1], name, pass_along[2], name, (gint) pass_along[4], NULL, TRUE, TRUE );
1063 #endif
1064
1065   *new_iter = *((GtkTreeIter *) pass_along[1]);
1066   g_hash_table_insert ( VIK_TRW_LAYER(pass_along[2])->waypoints_iters, name, new_iter );
1067
1068   if ( ! wp->visible )
1069     vik_treeview_item_set_visible ( (VikTreeview *) pass_along[3], (GtkTreeIter *) pass_along[1], FALSE );
1070 }
1071
1072
1073 void vik_trw_layer_realize ( VikTrwLayer *vtl, VikTreeview *vt, GtkTreeIter *layer_iter )
1074 {
1075   GtkTreeIter iter2;
1076   gpointer pass_along[5] = { &(vtl->tracks_iter), &iter2, vtl, vt, (gpointer) VIK_TRW_LAYER_SUBLAYER_TRACK };
1077
1078 #ifdef VIK_CONFIG_ALPHABETIZED_TRW
1079   vik_treeview_add_sublayer_alphabetized ( (VikTreeview *) vt, layer_iter, &(vtl->tracks_iter), "Tracks", vtl, NULL, VIK_TRW_LAYER_SUBLAYER_TRACKS, NULL, TRUE, FALSE );
1080 #else
1081   vik_treeview_add_sublayer ( (VikTreeview *) vt, layer_iter, &(vtl->tracks_iter), "Tracks", vtl, NULL, VIK_TRW_LAYER_SUBLAYER_TRACKS, NULL, TRUE, FALSE );
1082 #endif
1083   if ( ! vtl->tracks_visible )
1084     vik_treeview_item_set_visible ( (VikTreeview *) vt, &(vtl->tracks_iter), FALSE );
1085
1086   g_hash_table_foreach ( vtl->tracks, (GHFunc) trw_layer_realize_track, pass_along );
1087
1088 #ifdef VIK_CONFIG_ALPHABETIZED_TRW
1089   vik_treeview_add_sublayer_alphabetized ( (VikTreeview *) vt, layer_iter, &(vtl->waypoints_iter), "Waypoints", vtl, NULL, VIK_TRW_LAYER_SUBLAYER_WAYPOINTS, NULL, TRUE, FALSE );
1090 #else
1091   vik_treeview_add_sublayer ( (VikTreeview *) vt, layer_iter, &(vtl->waypoints_iter), "Waypoints", vtl, NULL, VIK_TRW_LAYER_SUBLAYER_WAYPOINTS, NULL, TRUE, FALSE );
1092 #endif
1093
1094   if ( ! vtl->waypoints_visible )
1095     vik_treeview_item_set_visible ( (VikTreeview *) vt, &(vtl->waypoints_iter), FALSE );
1096
1097   pass_along[0] = &(vtl->waypoints_iter);
1098   pass_along[4] = (gpointer) VIK_TRW_LAYER_SUBLAYER_WAYPOINT;
1099
1100   g_hash_table_foreach ( vtl->waypoints, (GHFunc) trw_layer_realize_waypoint, pass_along );
1101
1102 }
1103
1104 gboolean vik_trw_layer_sublayer_toggle_visible ( VikTrwLayer *l, gint subtype, gpointer sublayer )
1105 {
1106   switch ( subtype )
1107   {
1108     case VIK_TRW_LAYER_SUBLAYER_TRACKS: return (l->tracks_visible ^= 1);
1109     case VIK_TRW_LAYER_SUBLAYER_WAYPOINTS: return (l->waypoints_visible ^= 1);
1110     case VIK_TRW_LAYER_SUBLAYER_TRACK:
1111     {
1112       VikTrack *t = g_hash_table_lookup ( l->tracks, sublayer );
1113       if (t)
1114         return (t->visible ^= 1);
1115       else
1116         return TRUE;
1117     }
1118     case VIK_TRW_LAYER_SUBLAYER_WAYPOINT:
1119     {
1120       VikWaypoint *t = g_hash_table_lookup ( l->waypoints, sublayer );
1121       if (t)
1122         return (t->visible ^= 1);
1123       else
1124         return TRUE;
1125     }
1126   }
1127   return TRUE;
1128 }
1129
1130 GHashTable *vik_trw_layer_get_tracks ( VikTrwLayer *l )
1131 {
1132   return l->tracks;
1133 }
1134
1135 GHashTable *vik_trw_layer_get_waypoints ( VikTrwLayer *l )
1136 {
1137   return l->waypoints;
1138 }
1139
1140 static void trw_layer_find_maxmin_waypoints ( const gchar *name, const VikWaypoint *w, struct LatLon maxmin[2] )
1141 {
1142   static VikCoord fixme;
1143   vik_coord_copy_convert ( &(w->coord), VIK_COORD_LATLON, &fixme );
1144   if ( VIK_LATLON(&fixme)->lat > maxmin[0].lat || maxmin[0].lat == 0.0 )
1145     maxmin[0].lat = VIK_LATLON(&fixme)->lat;
1146   if ( VIK_LATLON(&fixme)->lat < maxmin[1].lat || maxmin[1].lat == 0.0 )
1147     maxmin[1].lat = VIK_LATLON(&fixme)->lat;
1148   if ( VIK_LATLON(&fixme)->lon > maxmin[0].lon || maxmin[0].lon == 0.0 )
1149     maxmin[0].lon = VIK_LATLON(&fixme)->lon;
1150   if ( VIK_LATLON(&fixme)->lon < maxmin[1].lon || maxmin[1].lon == 0.0 )
1151     maxmin[1].lon = VIK_LATLON(&fixme)->lon;
1152 }
1153
1154 static void trw_layer_find_maxmin_tracks ( const gchar *name, GList **t, struct LatLon maxmin[2] )
1155 {
1156   GList *tr = *t;
1157   static VikCoord fixme;
1158
1159   while ( tr )
1160   {
1161     vik_coord_copy_convert ( &(VIK_TRACKPOINT(tr->data)->coord), VIK_COORD_LATLON, &fixme );
1162     if ( VIK_LATLON(&fixme)->lat > maxmin[0].lat || maxmin[0].lat == 0.0 )
1163       maxmin[0].lat = VIK_LATLON(&fixme)->lat;
1164     if ( VIK_LATLON(&fixme)->lat < maxmin[1].lat || maxmin[1].lat == 0.0 )
1165       maxmin[1].lat = VIK_LATLON(&fixme)->lat;
1166     if ( VIK_LATLON(&fixme)->lon > maxmin[0].lon || maxmin[0].lon == 0.0 )
1167       maxmin[0].lon = VIK_LATLON(&fixme)->lon;
1168     if ( VIK_LATLON(&fixme)->lon < maxmin[1].lon || maxmin[1].lon == 0.0 )
1169       maxmin[1].lon = VIK_LATLON(&fixme)->lon;
1170     tr = tr->next;
1171   }
1172 }
1173
1174
1175 gboolean vik_trw_layer_find_center ( VikTrwLayer *vtl, VikCoord *dest )
1176 {
1177   /* TODO: what if there's only one waypoint @ 0,0, it will think nothing found. like I don't have more important things to worry about... */
1178   struct LatLon maxmin[2] = { {0.0,0.0}, {0.0,0.0} };
1179   g_hash_table_foreach ( vtl->waypoints, (GHFunc) trw_layer_find_maxmin_waypoints, maxmin );
1180   g_hash_table_foreach ( vtl->tracks, (GHFunc) trw_layer_find_maxmin_tracks, maxmin );
1181   if (maxmin[0].lat == 0.0 && maxmin[0].lon == 0.0 && maxmin[1].lat == 0.0 && maxmin[1].lon == 0.0)
1182     return FALSE;
1183   else
1184   {
1185     struct LatLon average = { (maxmin[0].lat+maxmin[1].lat)/2, (maxmin[0].lon+maxmin[1].lon)/2 };
1186     vik_coord_load_from_latlon ( dest, vtl->coord_mode, &average );
1187     return TRUE;
1188   }
1189 }
1190
1191 static void trw_layer_centerize ( gpointer layer_and_vlp[2] )
1192 {
1193   VikCoord coord;
1194   if ( vik_trw_layer_find_center ( VIK_TRW_LAYER(layer_and_vlp[0]), &coord ) )
1195     goto_coord ( VIK_LAYERS_PANEL(layer_and_vlp[1]), &coord );
1196   else
1197     a_dialog_info_msg ( VIK_GTK_WINDOW_FROM_LAYER(layer_and_vlp[0]), "This layer has no waypoints or trackpoints." );
1198 }
1199
1200 static void trw_layer_export ( gpointer layer_and_vlp[2], guint file_type )
1201 {
1202   GtkWidget *file_selector;
1203   const gchar *fn;
1204   gboolean failed = FALSE;
1205   file_selector = gtk_file_selection_new ("Export Layer");
1206
1207   while ( gtk_dialog_run ( GTK_DIALOG(file_selector) ) == GTK_RESPONSE_OK )
1208   {
1209     fn = gtk_file_selection_get_filename (GTK_FILE_SELECTION(file_selector) );
1210     if ( access ( fn, F_OK ) != 0 )
1211     {
1212       gtk_widget_hide ( file_selector );
1213       failed = ! a_file_export ( VIK_TRW_LAYER(layer_and_vlp[0]), fn, file_type );
1214       break;
1215     }
1216     else
1217     {
1218       if ( a_dialog_overwrite ( VIK_GTK_WINDOW_FROM_LAYER(layer_and_vlp[0]), "The file \"%s\" exists, do you wish to overwrite it?", a_file_basename ( fn ) ) )
1219       {
1220         gtk_widget_hide ( file_selector );
1221         failed = ! a_file_export ( VIK_TRW_LAYER(layer_and_vlp[0]), fn, file_type );
1222         break;
1223       }
1224     }
1225   }
1226   gtk_widget_destroy ( file_selector );
1227   if ( failed )
1228     a_dialog_error_msg ( VIK_GTK_WINDOW_FROM_LAYER(layer_and_vlp[0]), "The filename you requested could not be opened for writing." );
1229 }
1230
1231 static void trw_layer_export_gpspoint ( gpointer layer_and_vlp[2] )
1232 {
1233   trw_layer_export ( layer_and_vlp, FILE_TYPE_GPSPOINT );
1234 }
1235
1236 static void trw_layer_export_gpsmapper ( gpointer layer_and_vlp[2] )
1237 {
1238   trw_layer_export ( layer_and_vlp, FILE_TYPE_GPSMAPPER );
1239 }
1240
1241 static void trw_layer_goto_wp ( gpointer layer_and_vlp[2] )
1242 {
1243   GHashTable *wps = vik_trw_layer_get_waypoints ( VIK_TRW_LAYER(layer_and_vlp[0]) );
1244   GtkWidget *dia = gtk_dialog_new_with_buttons ("Create",
1245                                                  VIK_GTK_WINDOW_FROM_LAYER(layer_and_vlp[0]),
1246                                                  GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
1247                                                  GTK_STOCK_CANCEL,
1248                                                  GTK_RESPONSE_REJECT,
1249                                                  GTK_STOCK_OK,
1250                                                  GTK_RESPONSE_ACCEPT,
1251                                                  NULL);
1252
1253   GtkWidget *label, *entry;
1254   label = gtk_label_new("Waypoint Name:");
1255   entry = gtk_entry_new();
1256
1257   gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dia)->vbox), label, FALSE, FALSE, 0);
1258   gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dia)->vbox), entry, FALSE, FALSE, 0);
1259   gtk_widget_show_all ( label );
1260   gtk_widget_show_all ( entry );
1261
1262   while ( gtk_dialog_run ( GTK_DIALOG(dia) ) == GTK_RESPONSE_ACCEPT )
1263   {
1264     VikWaypoint *wp;
1265     gchar *upname = g_strdup(gtk_entry_get_text(GTK_ENTRY(entry)));
1266     int i;
1267
1268     for ( i = strlen(upname)-1; i >= 0; i-- )
1269       upname[i] = toupper(upname[i]);
1270
1271     wp = g_hash_table_lookup ( wps, upname );
1272
1273     if (!wp)
1274       a_dialog_error_msg ( VIK_GTK_WINDOW_FROM_LAYER(layer_and_vlp[0]), "Waypoint not found in this layer." );
1275     else
1276     {
1277       vik_viewport_set_center_coord ( vik_layers_panel_get_viewport(VIK_LAYERS_PANEL(layer_and_vlp[1])), &(wp->coord) );
1278       vik_layers_panel_emit_update ( VIK_LAYERS_PANEL(layer_and_vlp[1]) );
1279       vik_treeview_select_iter ( VIK_LAYER(layer_and_vlp[0])->vt, g_hash_table_lookup ( VIK_TRW_LAYER(layer_and_vlp[0])->waypoints_iters, upname ) );
1280       break;
1281     }
1282
1283     g_free ( upname );
1284
1285   }
1286   gtk_widget_destroy ( dia );
1287 }
1288
1289 gboolean vik_trw_layer_new_waypoint ( VikTrwLayer *vtl, GtkWindow *w, const VikCoord *def_coord )
1290 {
1291   gchar *name;
1292   static VikWaypoint st_wp;
1293   st_wp.coord = *def_coord;
1294   st_wp.altitude = VIK_DEFAULT_ALTITUDE;
1295
1296   if ( a_dialog_new_waypoint ( w, &name, &st_wp, vik_trw_layer_get_waypoints ( vtl ), vtl->coord_mode ) )
1297   {
1298     VikWaypoint *wp = vik_waypoint_new();
1299     *wp = st_wp;
1300     vik_trw_layer_add_waypoint ( vtl, name, wp );
1301     return TRUE;
1302   }
1303   return FALSE;
1304 }
1305
1306 static void trw_layer_new_wp ( gpointer lav[2] )
1307 {
1308   VikTrwLayer *vtl = VIK_TRW_LAYER(lav[0]);
1309   VikLayersPanel *vlp = VIK_LAYERS_PANEL(lav[1]);
1310   /* TODO longone: okay, if layer above (aggregate) is invisible but vtl->visible is true, this redraws for no reason.
1311      instead return true if you want to update. */
1312   if ( vik_trw_layer_new_waypoint ( vtl, VIK_GTK_WINDOW_FROM_LAYER(vtl), vik_viewport_get_center(vik_layers_panel_get_viewport(vlp))) && VIK_LAYER(vtl)->visible )
1313     vik_layers_panel_emit_update ( vlp );
1314 }
1315
1316 void vik_trw_layer_add_menu_items ( VikTrwLayer *vtl, GtkMenu *menu, gpointer vlp )
1317 {
1318   static gpointer pass_along[2];
1319   GtkWidget *item;
1320   pass_along[0] = vtl;
1321   pass_along[1] = vlp;
1322
1323   item = gtk_menu_item_new();
1324   gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
1325   gtk_widget_show ( item );
1326
1327   item = gtk_menu_item_new_with_label ( "Goto Center of Layer" );
1328   g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_centerize), pass_along );
1329   gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
1330   gtk_widget_show ( item );
1331
1332   item = gtk_menu_item_new_with_label ( "Goto Waypoint" );
1333   g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_goto_wp), pass_along );
1334   gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
1335   gtk_widget_show ( item );
1336
1337   item = gtk_menu_item_new_with_label ( "Export Layer as GPSPoint" );
1338   g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_export_gpspoint), pass_along );
1339   gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
1340   gtk_widget_show ( item );
1341
1342   item = gtk_menu_item_new_with_label ( "Export Layer as GPSMapper" );
1343   g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_export_gpsmapper), pass_along );
1344   gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
1345   gtk_widget_show ( item );
1346
1347   item = gtk_menu_item_new_with_label ( "New Waypoint" );
1348   g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_new_wp), pass_along );
1349   gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
1350   gtk_widget_show ( item );
1351 }
1352
1353 void vik_trw_layer_add_waypoint ( VikTrwLayer *vtl, gchar *name, VikWaypoint *wp )
1354 {
1355   if ( VIK_LAYER(vtl)->realized )
1356   {
1357     VikWaypoint *oldwp = VIK_WAYPOINT ( g_hash_table_lookup ( vtl->waypoints, name ) );
1358     if ( oldwp )
1359       wp->visible = oldwp->visible; /* same visibility so we don't have to update viktreeview */
1360     else
1361     {
1362       GtkTreeIter *iter = g_malloc(sizeof(GtkTreeIter));
1363 #ifdef VIK_CONFIG_ALPHABETIZED_TRW
1364       vik_treeview_add_sublayer_alphabetized ( VIK_LAYER(vtl)->vt, &(vtl->waypoints_iter), iter, name, vtl, name, VIK_TRW_LAYER_SUBLAYER_WAYPOINT, NULL, TRUE, TRUE );
1365 #else
1366       vik_treeview_add_sublayer ( VIK_LAYER(vtl)->vt, &(vtl->waypoints_iter), iter, name, vtl, name, VIK_TRW_LAYER_SUBLAYER_WAYPOINT, NULL, TRUE, TRUE );
1367 #endif
1368       vik_treeview_select_iter ( VIK_LAYER(vtl)->vt, iter );
1369       g_hash_table_insert ( vtl->waypoints_iters, name, iter );
1370       wp->visible = TRUE;
1371     }
1372   }
1373   else
1374     wp->visible = TRUE;
1375
1376   g_hash_table_insert ( vtl->waypoints, name, wp );
1377
1378 }
1379
1380 void vik_trw_layer_add_track ( VikTrwLayer *vtl, gchar *name, VikTrack *t )
1381 {
1382   if ( VIK_LAYER(vtl)->realized )
1383   {
1384     VikTrack *oldt = VIK_TRACK ( g_hash_table_lookup ( vtl->tracks, name ) );
1385     if ( oldt )
1386       t->visible = oldt->visible; /* same visibility so we don't have to update viktreeview */
1387     else
1388     {
1389       GtkTreeIter *iter = g_malloc(sizeof(GtkTreeIter));
1390 #ifdef VIK_CONFIG_ALPHABETIZED_TRW
1391       vik_treeview_add_sublayer_alphabetized ( VIK_LAYER(vtl)->vt, &(vtl->tracks_iter), iter, name, vtl, name, VIK_TRW_LAYER_SUBLAYER_TRACK, NULL, TRUE, TRUE );
1392 #else
1393       vik_treeview_add_sublayer ( VIK_LAYER(vtl)->vt, &(vtl->tracks_iter), iter, name, vtl, name, VIK_TRW_LAYER_SUBLAYER_TRACK, NULL, TRUE, TRUE );
1394 #endif
1395       vik_treeview_select_iter ( VIK_LAYER(vtl)->vt, iter );
1396       g_hash_table_insert ( vtl->tracks_iters, name, iter );
1397       t->visible = TRUE;
1398     }
1399   }
1400   else
1401     t->visible = TRUE;
1402
1403   g_hash_table_insert ( vtl->tracks, name, t );
1404
1405 }
1406
1407 static gboolean uppercase_exists_in_hash ( GHashTable *hash, const gchar *str )
1408 {
1409   gchar *upp = g_strdup ( str );
1410   gboolean rv;
1411   char *tmp = upp;
1412   while  ( *tmp )
1413   {
1414     *tmp = toupper(*tmp);
1415     tmp++;
1416   }
1417   rv = g_hash_table_lookup ( hash, upp ) ? TRUE : FALSE;
1418   g_free (upp);
1419   return rv;
1420 }
1421
1422 /* to be called whenever a track has been deleted or may have been changed. */
1423 static void trw_layer_cancel_tps_of_track ( VikTrwLayer *vtl, const gchar *trk_name )
1424 {
1425   if (vtl->current_tp_track_name && g_strcasecmp(trk_name, vtl->current_tp_track_name) == 0)
1426     trw_layer_cancel_current_tp ( vtl, FALSE );
1427   else if (vtl->last_tp_track_name && g_strcasecmp(trk_name, vtl->last_tp_track_name) == 0)
1428     trw_layer_cancel_last_tp ( vtl );
1429 }
1430
1431 static gboolean trw_layer_delete_track ( VikTrwLayer *vtl, const gchar *trk_name )
1432 {
1433   VikTrack *t = g_hash_table_lookup ( vtl->tracks, trk_name );
1434   gboolean was_visible = FALSE;
1435   if ( t )
1436   {
1437     GtkTreeIter *it;
1438     was_visible = t->visible;
1439     if ( t == vtl->current_track )
1440       vtl->current_track = NULL;
1441
1442     /* could be current_tp, so we have to check */
1443     trw_layer_cancel_tps_of_track ( vtl, trk_name );
1444
1445     g_assert ( ( it = g_hash_table_lookup ( vtl->tracks_iters, trk_name ) ) );
1446     vik_treeview_item_delete ( VIK_LAYER(vtl)->vt, it );
1447     g_hash_table_remove ( vtl->tracks_iters, trk_name );
1448
1449     /* do this last because trk_name may be pointing to actual orig key */
1450     g_hash_table_remove ( vtl->tracks, trk_name );
1451   }
1452   return was_visible;
1453 }
1454
1455 static void trw_layer_delete_item ( gpointer pass_along[5] )
1456 {
1457   VikTrwLayer *vtl = VIK_TRW_LAYER(pass_along[0]);
1458   gboolean was_visible = FALSE;
1459   if ( (gint) pass_along[2] == VIK_TRW_LAYER_SUBLAYER_WAYPOINT )
1460   {
1461     VikWaypoint *wp;
1462     wp = g_hash_table_lookup ( vtl->waypoints, pass_along[3] );
1463     if ( wp )
1464     {
1465       GtkTreeIter *it;
1466
1467       if ( wp == vtl->current_wp ) {
1468         vtl->current_wp = NULL;
1469         vtl->current_wp_name = NULL;
1470         vtl->moving_wp = FALSE;
1471       }
1472
1473       was_visible = wp->visible;
1474       g_assert ( ( it = g_hash_table_lookup ( vtl->waypoints_iters, (gchar *) pass_along[3] ) ) );
1475       vik_treeview_item_delete ( VIK_LAYER(vtl)->vt, it );
1476       g_hash_table_remove ( vtl->waypoints_iters, (gchar *) pass_along[3] );
1477       g_hash_table_remove ( vtl->waypoints, pass_along[3] ); /* last because this frees name */
1478     }
1479   }
1480   else
1481   {
1482     was_visible = trw_layer_delete_track ( vtl, (gchar *) pass_along[3] );
1483   }
1484
1485   if ( was_visible )
1486     vik_layer_emit_update ( VIK_LAYER(vtl) );
1487 }
1488
1489
1490 static void trw_layer_properties_item ( gpointer pass_along[5] )
1491 {
1492   VikTrwLayer *vtl = VIK_TRW_LAYER(pass_along[0]);
1493   if ( (gint) pass_along[2] == VIK_TRW_LAYER_SUBLAYER_WAYPOINT )
1494   {
1495     VikWaypoint *wp = g_hash_table_lookup ( vtl->waypoints, pass_along[3] );
1496     if ( wp )
1497     {
1498       if ( a_dialog_new_waypoint ( VIK_GTK_WINDOW_FROM_LAYER(vtl), NULL, wp, NULL, vtl->coord_mode ) )
1499
1500       if ( VIK_LAYER(vtl)->visible )
1501         vik_layer_emit_update ( VIK_LAYER(vtl) );
1502     }
1503   }
1504   else
1505   {
1506     VikTrack *tr = g_hash_table_lookup ( vtl->tracks, pass_along[3] );
1507     if ( tr )
1508     {
1509       gint resp = vik_trw_layer_propwin_run ( VIK_GTK_WINDOW_FROM_LAYER(vtl), tr, pass_along[1] /* vlp */ );
1510       if ( resp == VIK_TRW_LAYER_PROPWIN_DEL_DUP )
1511       {
1512         vik_track_remove_dup_points(tr);
1513         /* above operation could have deleted current_tp or last_tp */
1514         trw_layer_cancel_tps_of_track ( vtl, (gchar *) pass_along[3] );
1515         vik_layer_emit_update ( VIK_LAYER(vtl) );
1516       }
1517       if ( resp == VIK_TRW_LAYER_PROPWIN_REVERSE )
1518       {
1519         vik_track_reverse(tr);
1520         vik_layer_emit_update ( VIK_LAYER(vtl) );
1521       }
1522       else if ( resp == VIK_TRW_LAYER_PROPWIN_SPLIT )
1523       {
1524         /* get new tracks, add them, resolve naming conflicts (free if cancel), and delete old. old can still exist on clipboard. */
1525         guint ntracks;
1526         VikTrack **tracks = vik_track_split_into_segments(tr, &ntracks);
1527         gchar *new_tr_name;
1528         guint i;
1529         for ( i = 0; i < ntracks; i++ )
1530         {
1531           g_assert ( tracks[i] );
1532           new_tr_name = g_strdup_printf("%s #%d", (gchar *) pass_along[3], i+1);
1533           /* if ( (wp_exists) && (! overwrite) ) */
1534           /* don't need to upper case new_tr_name because old tr name was uppercase */
1535           if ( g_hash_table_lookup ( vtl->tracks, new_tr_name ) &&
1536              ( ! a_dialog_overwrite ( VIK_GTK_WINDOW_FROM_LAYER(vtl), "The track \"%s\" exists, do you wish to overwrite it?", new_tr_name ) ) )
1537           {
1538             gchar *new_new_tr_name = a_dialog_new_track ( VIK_GTK_WINDOW_FROM_LAYER(vtl), vtl->tracks );
1539             g_free ( new_tr_name );
1540             if (new_new_tr_name)
1541               new_tr_name = new_new_tr_name;
1542             else
1543             {
1544               new_tr_name = NULL;
1545               vik_track_free ( tracks[i] );
1546             }
1547           }
1548           if ( new_tr_name )
1549             vik_trw_layer_add_track ( vtl, new_tr_name, tracks[i] );
1550
1551         }
1552         if ( tracks )
1553         {
1554           g_free ( tracks );
1555           trw_layer_delete_track ( vtl, (gchar *) pass_along[3] );
1556           vik_layer_emit_update ( VIK_LAYER(vtl) ); /* chase thru the hoops */
1557         }
1558       }
1559     }
1560   }
1561 }
1562
1563 static void goto_coord ( VikLayersPanel *vlp, const VikCoord *coord )
1564 {
1565   vik_viewport_set_center_coord ( vik_layers_panel_get_viewport(vlp), coord );
1566   vik_layers_panel_emit_update ( vlp );
1567 }
1568
1569 static void trw_layer_goto_track_startpoint ( gpointer pass_along[5] )
1570 {
1571   GList *trps = ((VikTrack *) g_hash_table_lookup ( VIK_TRW_LAYER(pass_along[0])->tracks, pass_along[3] ))->trackpoints;
1572   if ( trps && trps->data )
1573     goto_coord ( VIK_LAYERS_PANEL(pass_along[1]), &(((VikTrackpoint *) trps->data)->coord));
1574 }
1575
1576 static void trw_layer_goto_track_center ( gpointer pass_along[5] )
1577 {
1578   GList **trps = g_hash_table_lookup ( VIK_TRW_LAYER(pass_along[0])->tracks, pass_along[3] );
1579   if ( trps && *trps )
1580   {
1581     struct LatLon average, maxmin[2] = { {0,0}, {0,0} };
1582     VikCoord coord;
1583     trw_layer_find_maxmin_tracks ( NULL, trps, maxmin );
1584     average.lat = (maxmin[0].lat+maxmin[1].lat)/2;
1585     average.lon = (maxmin[0].lon+maxmin[1].lon)/2;
1586     vik_coord_load_from_latlon ( &coord, VIK_TRW_LAYER(pass_along[0])->coord_mode, &average );
1587     goto_coord ( VIK_LAYERS_PANEL(pass_along[1]), &coord);
1588   }
1589 }
1590
1591 static void trw_layer_goto_track_endpoint ( gpointer pass_along[6] )
1592 {
1593   GList *trps = ((VikTrack *) g_hash_table_lookup ( VIK_TRW_LAYER(pass_along[0])->tracks, pass_along[3] ))->trackpoints;
1594   if ( !trps )
1595     return;
1596   trps = g_list_last(trps);
1597   goto_coord ( VIK_LAYERS_PANEL(pass_along[1]), &(((VikTrackpoint *) trps->data)->coord));
1598 }
1599
1600
1601 /*************************************
1602  * merge/split by time routines
1603  *************************************/
1604
1605 /* called for each key in track hash table. if original track user_data[1] is close enough
1606  * to the passed one, add it to list in user_data[0]
1607  */
1608 static void find_nearby_track(gpointer key, gpointer value, gpointer user_data)
1609 {
1610   time_t t1, t2;
1611   VikTrackpoint *p1, *p2;
1612
1613   GList **nearby_tracks = ((gpointer *)user_data)[0];
1614   GList *orig_track = ((gpointer *)user_data)[1];
1615   guint thr = (guint)((gpointer *)user_data)[2];
1616
1617   t1 = VIK_TRACKPOINT(orig_track->data)->timestamp;
1618   t2 = VIK_TRACKPOINT(g_list_last(orig_track)->data)->timestamp;
1619
1620   if (VIK_TRACK(value)->trackpoints == orig_track) {
1621     return;
1622   }
1623
1624   p1 = VIK_TRACKPOINT(VIK_TRACK(value)->trackpoints->data);
1625   p2 = VIK_TRACKPOINT(g_list_last(VIK_TRACK(value)->trackpoints)->data);
1626
1627   if (!p1->has_timestamp || !p2->has_timestamp) {
1628     printf("no timestamp\n");
1629     return;
1630   }
1631
1632   /*  printf("Got track named %s, times %d, %d\n", (gchar *)key, p1->timestamp, p2->timestamp); */
1633   if (abs(t1 - p2->timestamp) < thr*60 ||
1634       /*  p1 p2      t1 t2 */
1635       abs(p1->timestamp - t2) < thr*60
1636       /*  t1 t2      p1 p2 */
1637       ) {
1638     *nearby_tracks = g_list_prepend(*nearby_tracks, key);
1639   }
1640 }
1641
1642 /* comparison function used to sort tracks; a and b are hash table keys */
1643 static gint track_compare(gconstpointer a, gconstpointer b, gpointer user_data)
1644 {
1645   GHashTable *tracks = user_data;
1646   time_t t1, t2;
1647
1648   t1 = VIK_TRACKPOINT(VIK_TRACK(g_hash_table_lookup(tracks, a))->trackpoints->data)->timestamp;
1649   t2 = VIK_TRACKPOINT(VIK_TRACK(g_hash_table_lookup(tracks, b))->trackpoints->data)->timestamp;
1650
1651   if (t1 < t2) return -1;
1652   if (t1 > t2) return 1;
1653   return 0;
1654 }
1655
1656 /* comparison function used to sort trackpoints */
1657 static gint trackpoint_compare(gconstpointer a, gconstpointer b)
1658 {
1659   time_t t1 = VIK_TRACKPOINT(a)->timestamp, t2 = VIK_TRACKPOINT(b)->timestamp;
1660
1661   if (t1 < t2) return -1;
1662   if (t1 > t2) return 1;
1663   return 0;
1664 }
1665
1666 /* merge by time routine */
1667 static void trw_layer_merge_by_timestamp ( gpointer pass_along[6] )
1668 {
1669   time_t t1, t2;
1670   GList *nearby_tracks = NULL;
1671   VikTrack *track;
1672   GList *trps;
1673   static  guint thr = 1;
1674   guint track_count = 0;
1675   gchar *orig_track_name = strdup(pass_along[3]);
1676
1677   if (!a_dialog_time_threshold(VIK_GTK_WINDOW_FROM_LAYER(pass_along[0]),
1678                                "Merge Threshold...",
1679                                "Merge when time between trackpoints less than:",
1680                                &thr)) {
1681     return;
1682   }
1683
1684   /* merge tracks until we can't */
1685   do {
1686     gpointer params[3];
1687
1688     track = (VikTrack *) g_hash_table_lookup ( VIK_TRW_LAYER(pass_along[0])->tracks, orig_track_name );
1689     trps = track->trackpoints;
1690     if ( !trps )
1691       return;
1692
1693
1694     if (nearby_tracks) {
1695       g_list_free(nearby_tracks);
1696       nearby_tracks = NULL;
1697     }
1698
1699     t1 = ((VikTrackpoint *)trps->data)->timestamp;
1700     t2 = ((VikTrackpoint *)g_list_last(trps)->data)->timestamp;
1701
1702     /*    printf("Original track times: %d and %d\n", t1, t2);  */
1703     params[0] = &nearby_tracks;
1704     params[1] = trps;
1705     params[2] = (gpointer)thr;
1706
1707     /* get a list of adjacent-in-time tracks */
1708     g_hash_table_foreach(VIK_TRW_LAYER(pass_along[0])->tracks, find_nearby_track, (gpointer)params);
1709
1710     /* add original track */
1711     nearby_tracks = g_list_prepend(nearby_tracks, orig_track_name);
1712
1713     /* sort by first trackpoint; assumes they don't overlap */
1714     nearby_tracks = g_list_sort_with_data(nearby_tracks, track_compare, VIK_TRW_LAYER(pass_along[0])->tracks);
1715
1716     /* merge them */
1717     {
1718 #define get_track(x) VIK_TRACK(g_hash_table_lookup(VIK_TRW_LAYER(pass_along[0])->tracks, (gchar *)((x)->data)))
1719 #define get_first_trackpoint(x) VIK_TRACKPOINT(get_track(x)->trackpoints->data)
1720 #define get_last_trackpoint(x) VIK_TRACKPOINT(g_list_last(get_track(x)->trackpoints)->data)
1721       GList *l = nearby_tracks;
1722       VikTrack *tr = vik_track_new();
1723       tr->visible = track->visible;
1724       track_count = 0;
1725       while (l) {
1726         /*
1727         time_t t1, t2;
1728         t1 = get_first_trackpoint(l)->timestamp;
1729         t2 = get_last_trackpoint(l)->timestamp;
1730         printf("     %20s: track %d - %d\n", (char *)l->data, (int)t1, (int)t2);
1731         */
1732
1733
1734         /* remove trackpoints from merged track, delete track */
1735         tr->trackpoints = g_list_concat(tr->trackpoints, get_track(l)->trackpoints);
1736         get_track(l)->trackpoints = NULL;
1737         trw_layer_delete_track(VIK_TRW_LAYER(pass_along[0]), l->data);
1738
1739         track_count ++;
1740         l = g_list_next(l);
1741       }
1742       tr->trackpoints = g_list_sort(tr->trackpoints, trackpoint_compare);
1743       vik_trw_layer_add_track(VIK_TRW_LAYER(pass_along[0]), strdup(orig_track_name), tr);
1744
1745 #undef get_first_trackpoint
1746 #undef get_last_trackpoint
1747 #undef get_track
1748     }
1749   } while (track_count > 1);
1750   g_list_free(nearby_tracks);
1751   free(orig_track_name);
1752   vik_layer_emit_update(VIK_LAYER(pass_along[0]));
1753 }
1754
1755 /* split by time routine */
1756 static void trw_layer_split_by_timestamp ( gpointer pass_along[6] )
1757 {
1758   VikTrack *track = (VikTrack *) g_hash_table_lookup ( VIK_TRW_LAYER(pass_along[0])->tracks, pass_along[3] );
1759   GList *trps = track->trackpoints;
1760   GList *iter;
1761   GList *newlists = NULL;
1762   GList *newtps = NULL;
1763   guint i;
1764   static guint thr = 1;
1765
1766   time_t ts, prev_ts;
1767
1768   if ( !trps )
1769     return;
1770
1771   if (!a_dialog_time_threshold(VIK_GTK_WINDOW_FROM_LAYER(pass_along[0]),
1772                                "Split Threshold...",
1773                                "Split when time between trackpoints exceeds:",
1774                                &thr)) {
1775     return;
1776   }
1777
1778   /* iterate through trackpoints, and copy them into new lists without touching original list */
1779   prev_ts = VIK_TRACKPOINT(trps->data)->timestamp;
1780   iter = trps;
1781
1782   while (iter) {
1783     ts = VIK_TRACKPOINT(iter->data)->timestamp;
1784     if (ts < prev_ts) {
1785       printf("panic: ts < prev_ts: this should never happen!\n");
1786       return;
1787     }
1788     if (ts - prev_ts > thr*60) {
1789       /* flush accumulated trackpoints into new list */
1790       newlists = g_list_prepend(newlists, g_list_reverse(newtps));
1791       newtps = NULL;
1792     }
1793
1794     /* accumulate trackpoint copies in newtps, in reverse order */
1795     newtps = g_list_prepend(newtps, vik_trackpoint_copy(VIK_TRACKPOINT(iter->data)));
1796     prev_ts = ts;
1797     iter = g_list_next(iter);
1798   }
1799   if (newtps) {
1800       newlists = g_list_prepend(newlists, g_list_reverse(newtps));
1801   }
1802
1803   /* put lists of trackpoints into tracks */
1804   iter = newlists;
1805   i = 1;
1806   while (iter) {
1807     gchar *new_tr_name;
1808     VikTrack *tr;
1809
1810     tr = vik_track_new();
1811     tr->visible = track->visible;
1812     tr->trackpoints = (GList *)(iter->data);
1813
1814     new_tr_name = g_strdup_printf("%s #%d", (gchar *) pass_along[3], i++);
1815     vik_trw_layer_add_track(VIK_TRW_LAYER(pass_along[0]), new_tr_name, tr);
1816     /*    fprintf(stderr, "adding track %s, times %d - %d\n", new_tr_name, VIK_TRACKPOINT(tr->trackpoints->data)->timestamp,
1817           VIK_TRACKPOINT(g_list_last(tr->trackpoints)->data)->timestamp);*/
1818
1819     iter = g_list_next(iter);
1820   }
1821   g_list_free(newlists);
1822   trw_layer_delete_track(VIK_TRW_LAYER(pass_along[0]), (gchar *)pass_along[3]);
1823   vik_layer_emit_update(VIK_LAYER(pass_along[0]));
1824 }
1825
1826 /* end of split/merge routines */
1827
1828
1829 static void trw_layer_goto_waypoint ( gpointer pass_along[5] )
1830 {
1831   VikWaypoint *wp = g_hash_table_lookup ( VIK_TRW_LAYER(pass_along[0])->waypoints, pass_along[3] );
1832   if ( wp )
1833     goto_coord ( VIK_LAYERS_PANEL(pass_along[1]), &(wp->coord) );
1834 }
1835
1836 static void trw_layer_waypoint_gc_webpage ( gpointer pass_along[5] )
1837 {
1838   gchar *webpage = g_strdup_printf("http://www.geocaching.com/seek/cache_details.aspx?wp=%s", (gchar *) pass_along[3] );
1839 #ifdef WINDOWS
1840   ShellExecute(NULL, NULL, (char *) webpage, NULL, ".\\", 0);
1841 #else /* WINDOWS */
1842   GError *err = NULL;
1843   gchar *cmd = g_strdup_printf ( "%s %s", UNIX_WEB_BROWSER, webpage );
1844   if ( ! g_spawn_command_line_async ( cmd, &err ) )
1845   {
1846     a_dialog_error_msg ( VIK_GTK_WINDOW_FROM_LAYER(VIK_LAYER(pass_along[0])), "Could not launch web browser." );
1847     g_error_free ( err );
1848   }
1849   g_free ( cmd );
1850 #endif /* WINDOWS */
1851   g_free ( webpage );
1852 }
1853
1854 const gchar *vik_trw_layer_sublayer_rename_request ( VikTrwLayer *l, const gchar *newname, gpointer vlp, gint subtype, gpointer sublayer, GtkTreeIter *iter )
1855 {
1856   if ( subtype == VIK_TRW_LAYER_SUBLAYER_WAYPOINT )
1857   {
1858     int i;
1859     gchar *rv;
1860     VikWaypoint *wp;
1861
1862     if ( strcasecmp ( newname, sublayer ) == 0 )
1863       return NULL;
1864
1865     if ( uppercase_exists_in_hash ( l->waypoints, newname ) )
1866     {
1867       a_dialog_error_msg ( VIK_GTK_WINDOW_FROM_LAYER(l), "Waypoint Already Exists" );
1868       return NULL;
1869     }
1870
1871     wp = vik_waypoint_copy ( VIK_WAYPOINT(g_hash_table_lookup ( l->waypoints, sublayer )) );
1872     g_hash_table_remove ( l->waypoints, sublayer );
1873
1874     iter = g_hash_table_lookup ( l->waypoints_iters, sublayer );
1875     g_hash_table_steal ( l->waypoints_iters, sublayer );
1876
1877     rv = g_strdup(newname);
1878     for ( i = strlen(rv) - 1; i >= 0; i-- )
1879       rv[i] = toupper(rv[i]);
1880
1881     vik_treeview_item_set_pointer ( VIK_LAYER(l)->vt, iter, rv );
1882
1883     g_hash_table_insert ( l->waypoints, rv, wp );
1884     g_hash_table_insert ( l->waypoints_iters, rv, iter );
1885
1886     /* it hasn't been updated yet so we pass new name */
1887 #ifdef VIK_CONFIG_ALPHABETIZED_TRW
1888     vik_treeview_sublayer_realphabetize ( VIK_LAYER(l)->vt, iter, rv );
1889 #endif
1890
1891     vik_layers_panel_emit_update ( VIK_LAYERS_PANEL(vlp) );
1892     return rv;
1893   }
1894   if ( subtype == VIK_TRW_LAYER_SUBLAYER_TRACK )
1895   {
1896     int i;
1897     gchar *rv;
1898     VikTrack *tr;
1899     GtkTreeIter *iter;
1900     gchar *orig_key;
1901
1902     if ( strcasecmp ( newname, sublayer ) == 0 )
1903       return NULL;
1904
1905     if ( uppercase_exists_in_hash ( l->tracks, newname ) )
1906     {
1907       a_dialog_error_msg ( VIK_GTK_WINDOW_FROM_LAYER(l), "Track Already Exists" );
1908       return NULL;
1909     }
1910
1911     g_hash_table_lookup_extended ( l->tracks, sublayer, (gpointer *)&orig_key, (gpointer *)&tr );
1912     g_hash_table_steal ( l->tracks, sublayer );
1913
1914     iter = g_hash_table_lookup ( l->tracks_iters, sublayer );
1915     g_hash_table_steal ( l->tracks_iters, sublayer );
1916
1917     rv = g_strdup(newname);
1918     for ( i = strlen(rv) - 1; i >= 0; i-- )
1919       rv[i] = toupper(rv[i]);
1920
1921     vik_treeview_item_set_pointer ( VIK_LAYER(l)->vt, iter, rv );
1922
1923     g_hash_table_insert ( l->tracks, rv, tr );
1924     g_hash_table_insert ( l->tracks_iters, rv, iter );
1925
1926     /* don't forget about current_tp_track_name, update that too */
1927     if ( l->current_tp_track_name && g_strcasecmp(orig_key,l->current_tp_track_name) == 0 )
1928     {
1929       l->current_tp_track_name = rv;
1930       if ( l->tpwin )
1931         vik_trw_layer_tpwin_set_track_name ( l->tpwin, rv );
1932     }
1933     else if ( l->last_tp_track_name && g_strcasecmp(orig_key,l->last_tp_track_name) == 0 )
1934       l->last_tp_track_name = rv;
1935
1936     g_free ( orig_key );
1937
1938 #ifdef VIK_CONFIG_ALPHABETIZED_TRW
1939     vik_treeview_sublayer_realphabetize ( VIK_LAYER(l)->vt, iter, rv );
1940 #endif
1941
1942     vik_layers_panel_emit_update ( VIK_LAYERS_PANEL(vlp) );
1943     return rv;
1944   }
1945   return NULL;
1946 }
1947
1948 static gboolean is_valid_geocache_name ( gchar *str )
1949 {
1950   gint len = strlen ( str );
1951   return len >= 3 && len <= 6 && str[0] == 'G' && str[1] == 'C' && isalnum(str[2]) && (len < 4 || isalnum(str[3])) && (len < 5 || isalnum(str[4])) && (len < 6 || isalnum(str[5]));
1952 }
1953
1954 /* vlp can be NULL if necessary - i.e. right-click from a tool -- but be careful, some functions may try to use it */
1955 gboolean vik_trw_layer_sublayer_add_menu_items ( VikTrwLayer *l, GtkMenu *menu, gpointer vlp, gint subtype, gpointer sublayer, GtkTreeIter *iter )
1956 {
1957   static GtkTreeIter staticiter;
1958   static gpointer pass_along[5];
1959   GtkWidget *item;
1960   gboolean rv = FALSE;
1961
1962   pass_along[0] = l;
1963   pass_along[1] = vlp;
1964   pass_along[2] = (gpointer) subtype;
1965   pass_along[3] = sublayer;
1966   staticiter = *iter; /* will exist after function has ended */
1967   pass_along[4] = &staticiter;
1968
1969   if ( subtype == VIK_TRW_LAYER_SUBLAYER_WAYPOINT || subtype == VIK_TRW_LAYER_SUBLAYER_TRACK )
1970   {
1971     rv = TRUE;
1972
1973     item = gtk_image_menu_item_new_from_stock ( GTK_STOCK_PROPERTIES, NULL );
1974     g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_properties_item), pass_along );
1975     gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
1976     gtk_widget_show ( item );
1977
1978     item = gtk_image_menu_item_new_from_stock ( GTK_STOCK_DELETE, NULL );
1979     g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_delete_item), pass_along );
1980     gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
1981     gtk_widget_show ( item );
1982
1983     if ( subtype == VIK_TRW_LAYER_SUBLAYER_WAYPOINT )
1984     {
1985       /* could be a right-click using the tool */
1986       if ( vlp != NULL ) {
1987         item = gtk_menu_item_new_with_label ( "Goto" );
1988         g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_goto_waypoint), pass_along );
1989         gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
1990         gtk_widget_show ( item );
1991       }
1992
1993       if ( is_valid_geocache_name ( (gchar *) sublayer ) )
1994       {
1995         item = gtk_menu_item_new_with_label ( "Visit Geocache Webpage" );
1996         g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_waypoint_gc_webpage), pass_along );
1997         gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
1998         gtk_widget_show ( item );
1999       }
2000
2001     }
2002   }
2003
2004   if ( subtype == VIK_TRW_LAYER_SUBLAYER_TRACK )
2005   {
2006     item = gtk_menu_item_new ();
2007     gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
2008     gtk_widget_show ( item );
2009
2010     item = gtk_menu_item_new_with_label ( "Goto Startpoint" );
2011     g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_goto_track_startpoint), pass_along );
2012     gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
2013     gtk_widget_show ( item );
2014
2015     item = gtk_menu_item_new_with_label ( "Goto \"Center\"" );
2016     g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_goto_track_center), pass_along );
2017     gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
2018     gtk_widget_show ( item );
2019
2020     item = gtk_menu_item_new_with_label ( "Goto Endpoint" );
2021     g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_goto_track_endpoint), pass_along );
2022     gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
2023     gtk_widget_show ( item );
2024
2025     item = gtk_menu_item_new_with_label ( "Merge By Time" );
2026     g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_merge_by_timestamp), pass_along );
2027     gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
2028     gtk_widget_show ( item );
2029
2030     item = gtk_menu_item_new_with_label ( "Split By Time" );
2031     g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_split_by_timestamp), pass_along );
2032     gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
2033     gtk_widget_show ( item );
2034   }
2035
2036   if ( vlp && (subtype == VIK_TRW_LAYER_SUBLAYER_WAYPOINTS || subtype == VIK_TRW_LAYER_SUBLAYER_WAYPOINT) )
2037   {
2038     item = gtk_menu_item_new ();
2039     gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
2040     gtk_widget_show ( item );
2041
2042     item = gtk_menu_item_new_with_label ( "New Waypoint" );
2043     g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_new_wp), pass_along );
2044     gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
2045     gtk_widget_show ( item );
2046   }
2047
2048   return rv;
2049 }
2050
2051 /* Params are: vvp, event, last match found or NULL */
2052 static void tool_show_picture_wp ( char *name, VikWaypoint *wp, gpointer params[2] )
2053 {
2054   if ( wp->image && wp->visible )
2055   {
2056     gint x, y, slackx, slacky;
2057     GdkEventButton *event = (GdkEventButton *) params[1];
2058
2059     vik_viewport_coord_to_screen ( VIK_VIEWPORT(params[0]), &(wp->coord), &x, &y );
2060     slackx = wp->image_width / 2;
2061     slacky = wp->image_height / 2;
2062     if (    x <= event->x + slackx && x >= event->x - slackx
2063          && y <= event->y + slacky && y >= event->y - slacky )
2064     {
2065       params[2] = wp->image; /* we've found a match. however continue searching
2066                               * since we want to find the last match -- that
2067                               * is, the match that was drawn last. */
2068     }
2069   }
2070 }
2071
2072 static gboolean tool_show_picture ( VikTrwLayer *vtl, GdkEventButton *event, VikViewport *vvp )
2073 {
2074   gpointer params[3] = { vvp, event, NULL };
2075   g_hash_table_foreach ( vtl->waypoints, (GHFunc) tool_show_picture_wp, params );
2076   if ( params[2] )
2077   {
2078     /* thanks to the Gaim people for showing me ShellExecute and g_spawn_command_line_async */
2079 #ifdef WINDOWS
2080     ShellExecute(NULL, NULL, (char *) params[2], NULL, ".\\", 0);
2081 #else /* WINDOWS */
2082     GError *err = NULL;
2083     gchar *quoted_file = g_shell_quote ( (gchar *) params[2] );
2084     gchar *cmd = g_strdup_printf ( "eog %s", quoted_file );
2085     g_free ( quoted_file );
2086     if ( ! g_spawn_command_line_async ( cmd, &err ) )
2087     {
2088       a_dialog_error_msg ( VIK_GTK_WINDOW_FROM_LAYER(vtl), "Could not launch eog to open file." );
2089       g_error_free ( err );
2090     }
2091     g_free ( cmd );
2092 #endif /* WINDOWS */
2093     return TRUE; /* found a match */
2094   }
2095   else
2096     return FALSE; /* go through other layers, searching for a match */
2097 }
2098
2099 static gboolean tool_new_waypoint ( VikTrwLayer *vtl, GdkEventButton *event, VikViewport *vvp )
2100 {
2101   VikCoord coord;
2102   vik_viewport_screen_to_coord ( vvp, event->x, event->y, &coord );
2103   if (vik_trw_layer_new_waypoint ( vtl, VIK_GTK_WINDOW_FROM_LAYER(vtl), &coord ) && VIK_LAYER(vtl)->visible)
2104     vik_layer_emit_update ( VIK_LAYER(vtl) );
2105   return TRUE;
2106 }
2107
2108 typedef struct {
2109   gint x, y;
2110   gint closest_x, closest_y;
2111   gchar *closest_track_name;
2112   VikTrackpoint *closest_tp;
2113   VikViewport *vvp;
2114   GList *closest_tpl;
2115 } TPSearchParams;
2116
2117 static void track_search_closest_tp ( gchar *name, VikTrack *t, TPSearchParams *params )
2118 {
2119   GList *tpl = t->trackpoints;
2120   VikTrackpoint *tp;
2121
2122   if ( !t->visible )
2123     return;
2124
2125   while (tpl)
2126   {
2127     gint x, y;
2128     tp = VIK_TRACKPOINT(tpl->data);
2129
2130     vik_viewport_coord_to_screen ( params->vvp, &(tp->coord), &x, &y );
2131
2132     if ( abs (x - params->x) <= TRACKPOINT_SIZE_APPROX && abs (y - params->y) <= TRACKPOINT_SIZE_APPROX &&
2133         ((!params->closest_tp) ||        /* was the old trackpoint we already found closer than this one? */
2134           abs(x - params->x)+abs(y - params->y) < abs(x - params->closest_x)+abs(y - params->closest_y)))
2135     {
2136       params->closest_track_name = name;
2137       params->closest_tp = tp;
2138       params->closest_tpl = tpl;
2139       params->closest_x = x;
2140       params->closest_y = y;
2141     }
2142     tpl = tpl->next;
2143   }
2144 }
2145
2146 /* to be called when last_tpl no long exists. */
2147 static void trw_layer_cancel_last_tp ( VikTrwLayer *vtl )
2148 {
2149   if ( vtl->tpwin ) /* can't join with a non-existant TP. */
2150     vik_trw_layer_tpwin_disable_join ( vtl->tpwin );
2151   vtl->last_tpl = NULL;
2152   vtl->last_tp_track_name = NULL;
2153 }
2154
2155 static void trw_layer_cancel_current_tp ( VikTrwLayer *vtl, gboolean destroy )
2156 {
2157   if ( vtl->tpwin )
2158   {
2159     if ( destroy)
2160     {
2161       gtk_widget_destroy ( GTK_WIDGET(vtl->tpwin) );
2162       vtl->tpwin = NULL;
2163     }
2164     else
2165       vik_trw_layer_tpwin_set_empty ( vtl->tpwin );
2166   }
2167   if ( vtl->current_tpl )
2168   {
2169     vtl->current_tpl = NULL;
2170     vtl->current_tp_track_name = NULL;
2171     vik_layer_emit_update(VIK_LAYER(vtl));
2172   }
2173 }
2174
2175 static void trw_layer_tpwin_response ( VikTrwLayer *vtl, gint response )
2176 {
2177   g_assert ( vtl->tpwin != NULL );
2178   if ( response == VIK_TRW_LAYER_TPWIN_CLOSE )
2179     trw_layer_cancel_current_tp ( vtl, TRUE );
2180   else if ( response == VIK_TRW_LAYER_TPWIN_SPLIT && vtl->current_tpl->next && vtl->current_tpl->prev )
2181   {
2182     gchar *name;
2183     if ( ( name = a_dialog_new_track ( GTK_WINDOW(vtl->tpwin), vtl->tracks ) ) )
2184     {
2185       VikTrack *tr = vik_track_new ();
2186       GList *newglist = g_list_alloc ();
2187       newglist->prev = NULL;
2188       newglist->next = vtl->current_tpl->next;
2189       newglist->data = vik_trackpoint_copy(VIK_TRACKPOINT(vtl->current_tpl->data));
2190       tr->trackpoints = newglist;
2191
2192       vtl->current_tpl->next->prev = newglist; /* end old track here */
2193       vtl->current_tpl->next = NULL;
2194
2195       vtl->current_tpl = newglist; /* change tp to first of new track. */
2196       vtl->current_tp_track_name = name;
2197
2198       vik_trw_layer_tpwin_set_tp ( vtl->tpwin, vtl->current_tpl, vtl->current_tp_track_name );
2199
2200       vik_trw_layer_add_track ( vtl, name, tr );
2201       vik_layer_emit_update(VIK_LAYER(vtl));
2202     }
2203   }
2204   else if ( response == VIK_TRW_LAYER_TPWIN_DELETE )
2205   {
2206     VikTrack *tr = g_hash_table_lookup ( vtl->tracks, vtl->current_tp_track_name );
2207     GList *new_tpl;
2208     g_assert(tr != NULL);
2209
2210     /* can't join with a non-existent trackpoint */
2211     vtl->last_tpl = NULL;
2212     vtl->last_tp_track_name = NULL;
2213
2214     if ( (new_tpl = vtl->current_tpl->next) || (new_tpl = vtl->current_tpl->prev) )
2215     {
2216       if ( VIK_TRACKPOINT(vtl->current_tpl->data)->newsegment && vtl->current_tpl->next )
2217         VIK_TRACKPOINT(vtl->current_tpl->next->data)->newsegment = TRUE; /* don't concat segments on del */
2218
2219       tr->trackpoints = g_list_remove_link ( tr->trackpoints, vtl->current_tpl ); /* this nulls current_tpl->prev and next */
2220
2221       /* at this point the old trackpoint exists, but the list links are correct (new), so it is safe to do this. */
2222       vik_trw_layer_tpwin_set_tp ( vtl->tpwin, new_tpl, vtl->current_tp_track_name );
2223
2224       trw_layer_cancel_last_tp ( vtl );
2225
2226       g_free ( vtl->current_tpl->data ); /* TODO: vik_trackpoint_free() */
2227       g_list_free_1 ( vtl->current_tpl );
2228       vtl->current_tpl = new_tpl;
2229       vik_layer_emit_update(VIK_LAYER(vtl));
2230     }
2231     else
2232     {
2233       tr->trackpoints = g_list_remove_link ( tr->trackpoints, vtl->current_tpl );
2234       g_free ( vtl->current_tpl->data ); /* TODO longone: vik_trackpoint_new() and vik_trackpoint_free() */
2235       g_list_free_1 ( vtl->current_tpl );
2236       trw_layer_cancel_current_tp ( vtl, FALSE );
2237     }
2238   }
2239   else if ( response == VIK_TRW_LAYER_TPWIN_FORWARD && vtl->current_tpl->next )
2240   {
2241     vtl->last_tpl = vtl->current_tpl;
2242     vik_trw_layer_tpwin_set_tp ( vtl->tpwin, vtl->current_tpl = vtl->current_tpl->next, vtl->current_tp_track_name );
2243     vik_layer_emit_update(VIK_LAYER(vtl)); /* TODO longone: either move or only update if tp is inside drawing window */
2244   }
2245   else if ( response == VIK_TRW_LAYER_TPWIN_BACK && vtl->current_tpl->prev )
2246   {
2247     vtl->last_tpl = vtl->current_tpl;
2248     vik_trw_layer_tpwin_set_tp ( vtl->tpwin, vtl->current_tpl = vtl->current_tpl->prev, vtl->current_tp_track_name );
2249     vik_layer_emit_update(VIK_LAYER(vtl));
2250   }
2251   else if ( response == VIK_TRW_LAYER_TPWIN_JOIN )
2252   {
2253     VikTrack *tr1 = g_hash_table_lookup ( vtl->tracks, vtl->last_tp_track_name );
2254     VikTrack *tr2 = g_hash_table_lookup ( vtl->tracks, vtl->current_tp_track_name );
2255
2256     VikTrack *tr_first = tr1, *tr_last = tr2;
2257
2258     gchar *tmp;
2259
2260     if ( (!vtl->last_tpl->next) && (!vtl->current_tpl->next) ) /* both endpoints */
2261       vik_track_reverse ( tr2 ); /* reverse the second, that way second track clicked will be later. */
2262     else if ( (!vtl->last_tpl->prev) && (!vtl->current_tpl->prev) )
2263       vik_track_reverse ( tr1 );
2264     else if ( (!vtl->last_tpl->prev) && (!vtl->current_tpl->next) ) /* clicked startpoint, then endpoint -- concat end to start */
2265     {
2266       tr_first = tr2;
2267       tr_last = tr1;
2268     }
2269     /* default -- clicked endpoint then startpoint -- connect endpoint to startpoint */
2270
2271     if ( tr_last->trackpoints ) /* deleting this part here joins them into 1 segmented track. useful but there's no place in the UI for this feature. segments should be deprecated anyway. */
2272       VIK_TRACKPOINT(tr_last->trackpoints->data)->newsegment = FALSE;
2273     tr1->trackpoints = g_list_concat ( tr_first->trackpoints, tr_last->trackpoints );
2274     tr2->trackpoints = NULL;
2275
2276     tmp = vtl->current_tp_track_name;
2277
2278     vtl->current_tp_track_name = vtl->last_tp_track_name; /* current_tp stays the same (believe it or not!) */
2279     vik_trw_layer_tpwin_set_tp ( vtl->tpwin, vtl->current_tpl, vtl->current_tp_track_name );
2280
2281     /* if we did this before, trw_layer_delete_track would have canceled the current tp because
2282      * it was the current track. canceling the current tp would have set vtl->current_tpl to NULL */
2283     trw_layer_delete_track ( vtl, tmp );
2284
2285     trw_layer_cancel_last_tp ( vtl ); /* same TP, can't join. */
2286     vik_layer_emit_update(VIK_LAYER(vtl));
2287   }
2288   else if ( response == VIK_TRW_LAYER_TPWIN_DATA_CHANGED )
2289     vik_layer_emit_update (VIK_LAYER(vtl));
2290 }
2291
2292 static void trw_layer_tpwin_init ( VikTrwLayer *vtl )
2293 {
2294   if ( ! vtl->tpwin )
2295   {
2296     vtl->tpwin = vik_trw_layer_tpwin_new ( VIK_GTK_WINDOW_FROM_LAYER(vtl) );
2297     g_signal_connect_swapped ( GTK_DIALOG(vtl->tpwin), "response", G_CALLBACK(trw_layer_tpwin_response), vtl );
2298     /* connect signals -- DELETE SIGNAL VERY IMPORTANT TO SET TO NULL */
2299     g_signal_connect_swapped ( vtl->tpwin, "delete-event", G_CALLBACK(trw_layer_cancel_current_tp), vtl );
2300     gtk_widget_show_all ( GTK_WIDGET(vtl->tpwin) );
2301   }
2302   if ( vtl->current_tpl )
2303     vik_trw_layer_tpwin_set_tp ( vtl->tpwin, vtl->current_tpl, vtl->current_tp_track_name );
2304   /* set layer name and TP data */
2305 }
2306
2307 static VikTrackpoint *closest_tp_in_five_pixel_interval ( VikTrwLayer *vtl, VikViewport *vvp, gint x, gint y )
2308 {
2309   TPSearchParams params;
2310   params.x = x;
2311   params.y = y;
2312   params.vvp = vvp;
2313   params.closest_track_name = NULL;
2314   params.closest_tp = NULL;
2315   g_hash_table_foreach ( vtl->tracks, (GHFunc) track_search_closest_tp, &params);
2316   return params.closest_tp;
2317 }
2318
2319 static gboolean tool_edit_trackpoint_release ( VikTrwLayer *vtl, GdkEventButton *event, VikViewport *vvp )
2320 {
2321   if ( vtl->moving_tp )
2322   {
2323     /* vtl->moving_tp_x, vtl->moving_tp_y, etc. */
2324     VikCoord new_coord;
2325     vtl->moving_tp = FALSE;
2326     vik_viewport_screen_to_coord ( vvp, event->x, event->y, &new_coord );
2327
2328     /* snap to TP */
2329     if ( event->state & GDK_CONTROL_MASK )
2330     {
2331       VikTrackpoint *tp = closest_tp_in_five_pixel_interval ( vtl, vvp, event->x, event->y );
2332       if ( tp && tp != vtl->current_tpl->data )
2333         new_coord = tp->coord;
2334     }
2335
2336     VIK_TRACKPOINT(vtl->current_tpl->data)->coord = new_coord;
2337
2338     /* diff dist is diff from orig */
2339     vik_trw_layer_tpwin_set_tp ( vtl->tpwin, vtl->current_tpl, vtl->current_tp_track_name );
2340     /* can't join with itself! */
2341     trw_layer_cancel_last_tp ( vtl );
2342
2343     vik_layer_emit_update ( VIK_LAYER(vtl) );
2344     return TRUE;
2345   }
2346   return FALSE;
2347 }
2348
2349 static gboolean tool_edit_trackpoint ( VikTrwLayer *vtl, GdkEventButton *event, VikViewport *vvp )
2350 {
2351   TPSearchParams params;
2352   /* OUTDATED DOCUMENTATION:
2353    find 5 pixel range on each side. then put these UTM, and a pointer
2354    to the winning track name (and maybe the winning track itself), and a
2355    pointer to the winning trackpoint, inside an array or struct. pass
2356    this along, do a foreach on the tracks which will do a foreach on the
2357    trackpoints. */
2358   params.vvp = vvp;
2359   params.x = event->x;
2360   params.y = event->y;
2361   params.closest_track_name = NULL;
2362   /* TODO: should get track listitem so we can break it up, make a new track, mess it up, all that. */
2363   params.closest_tp = NULL;
2364
2365   if ( vtl->current_tpl )
2366   {
2367     /* first check if it is within range of prev. tp. and if current_tp track is shown. (if it is, we are moving that trackpoint.) */
2368     VikTrackpoint *tp = VIK_TRACKPOINT(vtl->current_tpl->data);
2369     VikTrack *current_tr = VIK_TRACK(g_hash_table_lookup(vtl->tracks, vtl->current_tp_track_name));
2370     gint x, y;
2371     g_assert ( current_tr );
2372
2373     vik_viewport_coord_to_screen ( vvp, &(tp->coord), &x, &y );
2374
2375     if ( current_tr->visible &&
2376          abs(x - event->x) < TRACKPOINT_SIZE_APPROX &&
2377          abs(y - event->y) < TRACKPOINT_SIZE_APPROX )
2378     {
2379       vtl->moving_tp = TRUE;
2380       return TRUE;
2381     }
2382
2383     vtl->last_tpl = vtl->current_tpl;
2384     vtl->last_tp_track_name = vtl->current_tp_track_name;
2385   }
2386
2387   g_hash_table_foreach ( vtl->tracks, (GHFunc) track_search_closest_tp, &params);
2388
2389   if ( params.closest_tp )
2390   {
2391     vtl->current_tpl = params.closest_tpl;
2392     vtl->current_tp_track_name = params.closest_track_name;
2393     vik_treeview_select_iter ( VIK_LAYER(vtl)->vt, g_hash_table_lookup ( vtl->tracks_iters, vtl->current_tp_track_name ) );
2394     trw_layer_tpwin_init ( vtl );
2395     vik_layer_emit_update ( VIK_LAYER(vtl) );
2396     return TRUE;
2397   }
2398
2399
2400   /* these aren't the droids you're looking for */
2401   return FALSE;
2402 }
2403
2404 typedef struct {
2405   gint x, y;
2406   gint closest_x, closest_y;
2407   gchar *closest_wp_name;
2408   VikWaypoint *closest_wp;
2409   VikViewport *vvp;
2410 } WPSearchParams;
2411
2412 static void waypoint_search_closest_tp ( gchar *name, VikWaypoint *wp, WPSearchParams *params )
2413 {
2414   gint x, y;
2415   if ( !wp->visible )
2416     return;
2417
2418   vik_viewport_coord_to_screen ( params->vvp, &(wp->coord), &x, &y );
2419
2420   if ( abs (x - params->x) <= WAYPOINT_SIZE_APPROX && abs (y - params->y) <= WAYPOINT_SIZE_APPROX &&
2421       ((!params->closest_wp) ||        /* was the old waypoint we already found closer than this one? */
2422         abs(x - params->x)+abs(y - params->y) < abs(x - params->closest_x)+abs(y - params->closest_y)))
2423   {
2424     params->closest_wp_name = name;
2425     params->closest_wp = wp;
2426     params->closest_x = x;
2427     params->closest_y = y;
2428   }
2429 }
2430
2431 static gboolean tool_edit_waypoint_release ( VikTrwLayer *vtl, GdkEventButton *event, VikViewport *vvp )
2432 {
2433   if ( vtl->moving_wp )
2434   {
2435     VikCoord new_coord;
2436     vtl->moving_wp = FALSE;
2437     vik_viewport_screen_to_coord ( vvp, event->x, event->y, &new_coord );
2438
2439     /* snap to TP */
2440     if ( event->state & GDK_CONTROL_MASK )
2441     {
2442       VikTrackpoint *tp = closest_tp_in_five_pixel_interval ( vtl, vvp, event->x, event->y );
2443       if ( tp )
2444         new_coord = tp->coord;
2445     }
2446
2447     /* snap to WP */
2448     if ( event->state & GDK_SHIFT_MASK )
2449     {
2450       VikWaypoint *wp = closest_wp_in_five_pixel_interval ( vtl, vvp, event->x, event->y );
2451       if ( wp && wp != vtl->current_wp )
2452         new_coord = wp->coord;
2453     }
2454
2455     vtl->current_wp->coord = new_coord;
2456     vik_layer_emit_update ( VIK_LAYER(vtl) );
2457     return TRUE;
2458   }
2459   /* PUT IN RIGHT PLACE!!! */
2460   if ( vtl->waypoint_rightclick )
2461   {
2462     if ( vtl->wp_right_click_menu )
2463       gtk_object_sink ( GTK_OBJECT(vtl->wp_right_click_menu) );
2464     vtl->wp_right_click_menu = GTK_MENU ( gtk_menu_new () );
2465     vik_trw_layer_sublayer_add_menu_items ( vtl, vtl->wp_right_click_menu, NULL, VIK_TRW_LAYER_SUBLAYER_WAYPOINT, vtl->current_wp_name, g_hash_table_lookup ( vtl->waypoints_iters, vtl->current_wp_name  ) );
2466     gtk_menu_popup ( vtl->wp_right_click_menu, NULL, NULL, NULL, NULL, event->button, gtk_get_current_event_time() );
2467     vtl->waypoint_rightclick = FALSE;
2468   }
2469   return FALSE;
2470 }
2471
2472 static VikWaypoint *closest_wp_in_five_pixel_interval ( VikTrwLayer *vtl, VikViewport *vvp, gint x, gint y )
2473 {
2474   WPSearchParams params;
2475   params.x = x;
2476   params.y = y;
2477   params.vvp = vvp;
2478   params.closest_wp = NULL;
2479   params.closest_wp_name = NULL;
2480   g_hash_table_foreach ( vtl->waypoints, (GHFunc) waypoint_search_closest_tp, &params);
2481   return params.closest_wp;
2482 }
2483
2484 static gboolean tool_edit_waypoint ( VikTrwLayer *vtl, GdkEventButton *event, VikViewport *vvp )
2485 {
2486   WPSearchParams params;
2487
2488   if ( vtl->current_wp && vtl->current_wp->visible )
2489   {
2490     /* first check if current WP is within area (other may be 'closer', but we want to move the current) */
2491     gint x, y;
2492     vik_viewport_coord_to_screen ( vvp, &(vtl->current_wp->coord), &x, &y );
2493
2494     if ( abs(x - event->x) < WAYPOINT_SIZE_APPROX &&
2495          abs(y - event->y) < WAYPOINT_SIZE_APPROX )
2496     {
2497       if ( event->button == 3 )
2498         vtl->waypoint_rightclick = TRUE; /* remember that we're clicking; other layers will ignore release signal */
2499       else
2500         vtl->moving_wp = TRUE;
2501       return TRUE;
2502     }
2503   }
2504
2505   params.vvp = vvp;
2506   params.x = event->x;
2507   params.y = event->y;
2508   params.closest_wp_name = NULL;
2509   /* TODO: should get track listitem so we can break it up, make a new track, mess it up, all that. */
2510   params.closest_wp = NULL;
2511   g_hash_table_foreach ( vtl->waypoints, (GHFunc) waypoint_search_closest_tp, &params);
2512   if ( vtl->current_wp == params.closest_wp && vtl->current_wp != NULL )
2513   {
2514     vtl->moving_wp = TRUE;
2515   }
2516   else if ( params.closest_wp )
2517   {
2518     if ( event->button == 3 )
2519       vtl->waypoint_rightclick = TRUE; /* remember that we're clicking; other layers will ignore release signal */
2520     else
2521       vtl->waypoint_rightclick = FALSE;
2522
2523     vtl->current_wp = params.closest_wp;
2524     vtl->current_wp_name = params.closest_wp_name;
2525     vtl->moving_wp = FALSE;
2526
2527     if ( params.closest_wp )
2528       vik_treeview_select_iter ( VIK_LAYER(vtl)->vt, g_hash_table_lookup ( vtl->waypoints_iters, vtl->current_wp_name ) );
2529
2530     /* could make it so don't update if old WP is off screen and new is null but oh well */
2531     vik_layer_emit_update ( VIK_LAYER(vtl) );
2532     return TRUE;
2533   }
2534
2535   vtl->current_wp = NULL;
2536   vtl->current_wp_name = NULL;
2537   vtl->moving_wp = FALSE;
2538   vtl->waypoint_rightclick = FALSE;
2539   return FALSE;
2540 }
2541
2542 static gboolean tool_new_track ( VikTrwLayer *vtl, GdkEventButton *event, VikViewport *vvp )
2543 {
2544   VikTrackpoint *tp;
2545
2546   if ( event->button == 3 && vtl->current_track )
2547   {
2548     /* undo */
2549     if ( vtl->current_track->trackpoints )
2550     {
2551       GList *last = g_list_last(vtl->current_track->trackpoints);
2552       g_free ( last->data );
2553       vtl->current_track->trackpoints = g_list_remove_link ( vtl->current_track->trackpoints, last );
2554     }
2555     vik_layer_emit_update ( VIK_LAYER(vtl) );
2556     return TRUE;
2557   }
2558
2559   if ( event->type == GDK_2BUTTON_PRESS )
2560   {
2561     /* subtract last (duplicate from double click) tp then end */
2562     if ( vtl->current_track && vtl->current_track->trackpoints && vtl->ct_x1 == vtl->ct_x2 && vtl->ct_y1 == vtl->ct_y2 )
2563     {
2564       GList *last = g_list_last(vtl->current_track->trackpoints);
2565       g_free ( last->data );
2566       vtl->current_track->trackpoints = g_list_remove_link ( vtl->current_track->trackpoints, last );
2567       /* undo last, then end */
2568       vtl->current_track = NULL;
2569     }
2570     return TRUE;
2571   }
2572
2573   if ( ! vtl->current_track )
2574   {
2575     gchar *name;
2576     if ( ( name = a_dialog_new_track ( VIK_GTK_WINDOW_FROM_LAYER(vtl), vtl->tracks ) ) )
2577     {
2578       vtl->current_track = vik_track_new();
2579       vtl->current_track->visible = TRUE;
2580       vik_trw_layer_add_track ( vtl, name, vtl->current_track );
2581     }
2582     else
2583       return TRUE;
2584   }
2585   tp = vik_trackpoint_new();
2586   vik_viewport_screen_to_coord ( vvp, event->x, event->y, &(tp->coord) );
2587
2588   /* snap to other TP */
2589   if ( event->state & GDK_CONTROL_MASK )
2590   {
2591     VikTrackpoint *other_tp = closest_tp_in_five_pixel_interval ( vtl, vvp, event->x, event->y );
2592     if ( other_tp )
2593       tp->coord = other_tp->coord;
2594   }
2595
2596   tp->newsegment = FALSE;
2597   tp->has_timestamp = FALSE;
2598   tp->timestamp = 0;
2599   tp->altitude = VIK_DEFAULT_ALTITUDE;
2600   vtl->current_track->trackpoints = g_list_append ( vtl->current_track->trackpoints, tp );
2601
2602   vtl->ct_x1 = vtl->ct_x2;
2603   vtl->ct_y1 = vtl->ct_y2;
2604   vtl->ct_x2 = event->x;
2605   vtl->ct_y2 = event->y;
2606
2607   vik_layer_emit_update ( VIK_LAYER(vtl) );
2608   return TRUE;
2609 }
2610
2611 static void image_wp_make_list ( char *name, VikWaypoint *wp, GSList **pics )
2612 {
2613   if ( wp->image && ( ! a_thumbnails_exists ( wp->image ) ) )
2614     *pics = g_slist_append ( *pics, (gpointer) g_strdup ( wp->image ) );
2615 }
2616
2617 static void create_thumbnails_thread ( GSList *pics, gpointer threaddata )
2618 {
2619   guint total = g_slist_length(pics), done = 0;
2620   while ( pics )
2621   {
2622     a_thumbnails_create ( (gchar *) pics->data );
2623     a_background_thread_progress ( threaddata, ((gdouble) ++done) / total );
2624     pics = pics->next;
2625   }
2626 }
2627
2628 static void free_pics_slist ( GSList *pics )
2629 {
2630   while ( pics )
2631   {
2632     g_free ( pics->data );
2633     pics = g_slist_delete_link ( pics, pics );
2634   }
2635 }
2636
2637 static void trw_layer_verify_thumbnails ( VikTrwLayer *vtl, GtkWidget *vp )
2638 {
2639   if ( ! vtl->has_verified_thumbnails )
2640   {
2641     GSList *pics = NULL;
2642     g_hash_table_foreach ( vtl->waypoints, (GHFunc) image_wp_make_list, &pics );
2643     if ( pics )
2644     {
2645       gint len = g_slist_length ( pics );
2646       gchar *tmp = g_strdup_printf ( "Creating %d Image Thumbnails...", len );
2647       a_background_thread ( VIK_GTK_WINDOW_FROM_LAYER(vtl), tmp, (vik_thr_func) create_thumbnails_thread, pics, (vik_thr_free_func) free_pics_slist, NULL, len );
2648       g_free ( tmp );
2649     }
2650   }
2651 }
2652
2653 VikCoordMode vik_trw_layer_get_coord_mode ( VikTrwLayer *vtl )
2654 {
2655   return vtl->coord_mode;
2656 }
2657
2658
2659
2660 static void waypoint_convert ( const gchar *name, VikWaypoint *wp, VikCoordMode *dest_mode )
2661 {
2662   vik_coord_convert ( &(wp->coord), *dest_mode );
2663 }
2664
2665 static void track_convert ( const gchar *name, VikTrack *tr, VikCoordMode *dest_mode )
2666 {
2667   vik_track_convert ( tr, *dest_mode );
2668 }
2669
2670 static void trw_layer_change_coord_mode ( VikTrwLayer *vtl, VikCoordMode dest_mode )
2671 {
2672   if ( vtl->coord_mode != dest_mode )
2673   {
2674     vtl->coord_mode = dest_mode;
2675     g_hash_table_foreach ( vtl->waypoints, (GHFunc) waypoint_convert, &dest_mode );
2676     g_hash_table_foreach ( vtl->tracks, (GHFunc) track_convert, &dest_mode );
2677   }
2678 }