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 #ifdef HAVE_CONFIG_H
  28 #include "config.h"
  29 #endif
  30
  31 #include "viking.h"
  32 #include "vikmapslayer.h"
  33 #include "viktrwlayer_pixmap.h"
  34 #include "viktrwlayer_tpwin.h"
  35 #include "viktrwlayer_propwin.h"
  36 #include "garminsymbols.h"
  37 #include "thumbnails.h"
  38 #include "background.h"
  39 #include "gpx.h"
  40 #include "babel.h"
  41 #include "dem.h"
  42 #include "dems.h"
  43 #ifdef VIK_CONFIG_OPENSTREETMAP
  44 #include "osm-traces.h"
  45 #endif
  46
  47 #include "icons/icons.h"
  48
  49 #include <math.h>
  50 #include <string.h>
  51 #include <stdlib.h>
  52 #include <ctype.h>
  53
  54 #include <gdk/gdkkeysyms.h>
  55
  56 /* Relax some dependencies */
  57 #if ! GLIB_CHECK_VERSION(2,12,0)
  58 static gboolean return_true (gpointer a, gpointer b, gpointer c) { return TRUE; }
  59 static g_hash_table_remove_all (GHashTable *ght) { g_hash_table_foreach_remove ( ght, (GHRFunc) return_true, FALSE ); }
  60 #endif
  61
  62 #define GOOGLE_DIRECTIONS_STRING "(wget -O - \"http://maps.google.com/maps?q=%f,%f to %f,%f&output=js\" 2>/dev/null)"
  63 #define VIK_TRW_LAYER_TRACK_GC 13
  64 #define VIK_TRW_LAYER_TRACK_GC_RATES 10
  65 #define VIK_TRW_LAYER_TRACK_GC_MIN 0
  66 #define VIK_TRW_LAYER_TRACK_GC_MAX 11
  67 #define VIK_TRW_LAYER_TRACK_GC_BLACK 12
  68
  69 #define DRAWMODE_BY_TRACK 0
  70 #define DRAWMODE_BY_VELOCITY 1
  71 #define DRAWMODE_ALL_BLACK 2
  72
  73 #define POINTS 1
  74 #define LINES 2
  75
  76 /* this is how it knows when you click if you are clicking close to a trackpoint. */
  77 #define TRACKPOINT_SIZE_APPROX 5
  78 #define WAYPOINT_SIZE_APPROX 5
  79
  80 #define MIN_STOP_LENGTH 15
  81 #define MAX_STOP_LENGTH 86400
  82 #define DRAW_ELEVATION_FACTOR 30 /* height of elevation plotting, sort of relative to zoom level ("mpp" that isn't mpp necessarily) */
  83                                  /* this is multiplied by user-inputted value from 1-100. */
  84 enum {
  85 VIK_TRW_LAYER_SUBLAYER_TRACKS,
  86 VIK_TRW_LAYER_SUBLAYER_WAYPOINTS,
  87 VIK_TRW_LAYER_SUBLAYER_TRACK,
  88 VIK_TRW_LAYER_SUBLAYER_WAYPOINT
  89 };
  90
  91 enum { WP_SYMBOL_FILLED_SQUARE, WP_SYMBOL_SQUARE, WP_SYMBOL_CIRCLE, WP_SYMBOL_X, WP_NUM_SYMBOLS };
  92
  93 struct _VikTrwLayer {
  94   VikLayer vl;
  95   GHashTable *tracks;
  96   GHashTable *tracks_iters;
  97   GHashTable *waypoints_iters;
  98   GHashTable *waypoints;
  99   GtkTreeIter waypoints_iter, tracks_iter;
 100   gboolean tracks_visible, waypoints_visible;
 101   guint8 drawmode;
 102   guint8 drawpoints;
 103   guint8 drawelevation;
 104   guint8 elevation_factor;
 105   guint8 drawstops;
 106   guint32 stop_length;
 107   guint8 drawlines;
 108   guint8 line_thickness;
 109   guint8 bg_line_thickness;
 110
 111   guint8 wp_symbol;
 112   guint8 wp_size;
 113   gboolean wp_draw_symbols;
 114
 115   gdouble velocity_min, velocity_max;
 116   GArray *track_gc;
 117   guint16 track_gc_iter;
 118   GdkGC *current_track_gc;
 119   GdkGC *track_bg_gc;
 120   GdkGC *waypoint_gc;
 121   GdkGC *waypoint_text_gc;
 122   GdkGC *waypoint_bg_gc;
 123   GdkFont *waypoint_font;
 124   VikTrack *current_track;
 125   guint16 ct_x1, ct_y1, ct_x2, ct_y2;
 126   gboolean ct_sync_done;
 127
 128
 129   VikCoordMode coord_mode;
 130
 131   /* wp editing tool */
 132   VikWaypoint *current_wp;
 133   gchar *current_wp_name;
 134   gboolean moving_wp;
 135   gboolean waypoint_rightclick;
 136
 137   /* track editing tool */
 138   GList *current_tpl;
 139   gchar *current_tp_track_name;
 140   VikTrwLayerTpwin *tpwin;
 141
 142   /* weird hack for joining tracks */
 143   GList *last_tpl;
 144   gchar *last_tp_track_name;
 145
 146   /* track editing tool -- more specifically, moving tps */
 147   gboolean moving_tp;
 148
 149   /* magic scissors tool */
 150   gboolean magic_scissors_started;
 151   VikCoord magic_scissors_coord;
 152   gboolean magic_scissors_check_added_track;
 153   gchar *magic_scissors_added_track_name;
 154   VikTrack *magic_scissors_current_track;
 155   gboolean magic_scissors_append;
 156
 157   gboolean drawlabels;
 158   gboolean drawimages;
 159   guint8 image_alpha;
 160   GQueue *image_cache;
 161   guint8 image_size;
 162   guint16 image_cache_size;
 163
 164   /* for waypoint text */
 165   PangoLayout *wplabellayout;
 166
 167   gboolean has_verified_thumbnails;
 168
 169   GtkMenu *wp_right_click_menu;
 170
 171   /* menu */
 172   VikStdLayerMenuItem menu_selection;
 173
 174 };
 175
 176 /* A caached waypoint image. */
 177 typedef struct {
 178   GdkPixbuf *pixbuf;
 179   gchar *image; /* filename */
 180 } CachedPixbuf;
 181
 182 struct DrawingParams {
 183   VikViewport *vp;
 184   VikTrwLayer *vtl;
 185   gdouble xmpp, ympp;
 186   guint16 width, height;
 187   const VikCoord *center;
 188   gint track_gc_iter;
 189   gboolean one_zone, lat_lon;
 190   gdouble ce1, ce2, cn1, cn2;
 191 };
 192
 193 static void vik_trw_layer_set_menu_selection(VikTrwLayer *vtl, guint16);
 194 static guint16 vik_trw_layer_get_menu_selection(VikTrwLayer *vtl);
 195
 196 static void trw_layer_delete_item ( gpointer *pass_along );
 197 static void trw_layer_copy_item_cb( gpointer *pass_along);
 198 static void trw_layer_cut_item_cb( gpointer *pass_along);
 199
 200 static void trw_layer_find_maxmin_waypoints ( const gchar *name, const VikWaypoint *w, struct LatLon maxmin[2] );
 201 static void trw_layer_find_maxmin_tracks ( const gchar *name, GList **t, struct LatLon maxmin[2] );
 202
 203 static void trw_layer_new_track_gcs ( VikTrwLayer *vtl, VikViewport *vp );
 204 static void trw_layer_free_track_gcs ( VikTrwLayer *vtl );
 205
 206 static gint calculate_velocity ( VikTrwLayer *vtl, VikTrackpoint *tp1, VikTrackpoint *tp2 );
 207 static void trw_layer_draw_track_cb ( const gchar *name, VikTrack *track, struct DrawingParams *dp );
 208 static void trw_layer_draw_waypoint ( const gchar *name, VikWaypoint *wp, struct DrawingParams *dp );
 209
 210 static void goto_coord ( VikLayersPanel *vlp, const VikCoord *coord );
 211 static void trw_layer_goto_track_startpoint ( gpointer pass_along[5] );
 212 static void trw_layer_goto_track_endpoint ( gpointer pass_along[6] );
 213 static void trw_layer_merge_by_timestamp ( gpointer pass_along[6] );
 214 static void trw_layer_split_by_timestamp ( gpointer pass_along[6] );
 215 static void trw_layer_download_map_along_track_cb(gpointer pass_along[6]);
 216 static void trw_layer_centerize ( gpointer layer_and_vlp[2] );
 217 static void trw_layer_export ( gpointer layer_and_vlp[2], guint file_type );
 218 static void trw_layer_goto_wp ( gpointer layer_and_vlp[2] );
 219 static void trw_layer_new_wp ( gpointer lav[2] );
 220
 221 /* pop-up items */
 222 static void trw_layer_properties_item ( gpointer pass_along[5] );
 223 static void trw_layer_goto_waypoint ( gpointer pass_along[5] );
 224 static void trw_layer_waypoint_gc_webpage ( gpointer pass_along[5] );
 225
 226 static void trw_layer_realize_waypoint ( gchar *name, VikWaypoint *wp, gpointer pass_along[4] );
 227 static void trw_layer_realize_track ( gchar *name, VikTrack *track, gpointer pass_along[4] );
 228 static void init_drawing_params ( struct DrawingParams *dp, VikViewport *vp );
 229
 230
 231 static void trw_layer_marshall( VikTrwLayer *vtl, guint8 **data, gint *len );
 232 static VikTrwLayer *trw_layer_unmarshall( gpointer data, gint len, VikViewport *vvp );
 233
 234 static gboolean trw_layer_set_param ( VikTrwLayer *vtl, guint16 id, VikLayerParamData data, VikViewport *vp );
 235 static VikLayerParamData trw_layer_get_param ( VikTrwLayer *vtl, guint16 id );
 236
 237 static void trw_layer_del_item ( VikTrwLayer *vtl, gint subtype, gpointer sublayer );
 238 static void trw_layer_copy_item ( VikTrwLayer *vtl, gint subtype, gpointer sublayer, guint8 **item, guint *len );
 239 static gboolean trw_layer_paste_item ( VikTrwLayer *vtl, gint subtype, guint8 *item, guint len );
 240 static void trw_layer_free_copied_item ( gint subtype, gpointer item );
 241 static void trw_layer_drag_drop_request ( VikTrwLayer *vtl_src, VikTrwLayer *vtl_dest, GtkTreeIter *src_item_iter, GtkTreePath *dest_path );
 242
 243 static void trw_layer_cancel_tps_of_track ( VikTrwLayer *vtl, const gchar *trk_name );
 244 static void trw_layer_cancel_last_tp ( VikTrwLayer *vtl );
 245 static void trw_layer_cancel_current_tp ( VikTrwLayer *vtl, gboolean destroy );
 246 static void trw_layer_tpwin_response ( VikTrwLayer *vtl, gint response );
 247 static void trw_layer_tpwin_init ( VikTrwLayer *vtl );
 248
 249 static gpointer tool_edit_trackpoint_create ( VikWindow *vw, VikViewport *vvp);
 250 static gboolean tool_edit_trackpoint_click ( VikTrwLayer *vtl, GdkEventButton *event, gpointer data );
 251 static gboolean tool_edit_trackpoint_move ( VikTrwLayer *vtl, GdkEventButton *event, gpointer data );
 252 static gboolean tool_edit_trackpoint_release ( VikTrwLayer *vtl, GdkEventButton *event, gpointer data );
 253 static gpointer tool_show_picture_create ( VikWindow *vw, VikViewport *vvp);
 254 static gboolean tool_show_picture_click ( VikTrwLayer *vtl, GdkEventButton *event, VikViewport *vvp );
 255 static gpointer tool_edit_waypoint_create ( VikWindow *vw, VikViewport *vvp);
 256 static gboolean tool_edit_waypoint_click ( VikTrwLayer *vtl, GdkEventButton *event, gpointer data );
 257 static gboolean tool_edit_waypoint_move ( VikTrwLayer *vtl, GdkEventButton *event, gpointer data );
 258 static gboolean tool_edit_waypoint_release ( VikTrwLayer *vtl, GdkEventButton *event, gpointer data );
 259 static gpointer tool_begin_track_create ( VikWindow *vw, VikViewport *vvp);
 260 static gboolean tool_begin_track_click ( VikTrwLayer *vtl, GdkEventButton *event, VikViewport *vvp );
 261 static gpointer tool_new_track_create ( VikWindow *vw, VikViewport *vvp);
 262 static gboolean tool_new_track_click ( VikTrwLayer *vtl, GdkEventButton *event, VikViewport *vvp );
 263 static VikLayerToolFuncStatus tool_new_track_move ( VikTrwLayer *vtl, GdkEventButton *event, VikViewport *vvp );
 264 static gboolean tool_new_track_key_press ( VikTrwLayer *vtl, GdkEventKey *event, VikViewport *vvp );
 265 static gpointer tool_new_waypoint_create ( VikWindow *vw, VikViewport *vvp);
 266 static gboolean tool_new_waypoint_click ( VikTrwLayer *vtl, GdkEventButton *event, VikViewport *vvp );
 267 static gpointer tool_magic_scissors_create ( VikWindow *vw, VikViewport *vvp);
 268 static gboolean tool_magic_scissors_click ( VikTrwLayer *vtl, GdkEventButton *event, VikViewport *vvp );
 269
 270
 271 static gboolean uppercase_exists_in_hash ( GHashTable *hash, const gchar *str );
 272
 273 static void cached_pixbuf_free ( CachedPixbuf *cp );
 274 static gint cached_pixbuf_cmp ( CachedPixbuf *cp, const gchar *name );
 275 static void trw_layer_verify_thumbnails ( VikTrwLayer *vtl, GtkWidget *vp );
 276
 277 static VikTrackpoint *closest_tp_in_five_pixel_interval ( VikTrwLayer *vtl, VikViewport *vvp, gint x, gint y );
 278 static VikWaypoint *closest_wp_in_five_pixel_interval ( VikTrwLayer *vtl, VikViewport *vvp, gint x, gint y );
 279
 280 static void trw_layer_change_coord_mode ( VikTrwLayer *vtl, VikCoordMode dest_mode );
 281
 282 static gchar *get_new_unique_sublayer_name (VikTrwLayer *vtl, gint sublayer_type, const gchar *name);
 283 static void waypoint_convert ( const gchar *name, VikWaypoint *wp, VikCoordMode *dest_mode );
 284 static void track_convert ( const gchar *name, VikTrack *tr, VikCoordMode *dest_mode );
 285
 286 static VikToolInterface trw_layer_tools[] = {
 287   { "Create Waypoint", (VikToolConstructorFunc) tool_new_waypoint_create,    NULL, NULL, NULL,
 288     (VikToolMouseFunc) tool_new_waypoint_click,    NULL, NULL, (VikToolKeyFunc) NULL, &cursor_addwp },
 289
 290   { "Create Track",    (VikToolConstructorFunc) tool_new_track_create,       NULL, NULL, NULL,
 291     (VikToolMouseFunc) tool_new_track_click, (VikToolMouseFunc) tool_new_track_move, NULL,
 292     (VikToolKeyFunc) tool_new_track_key_press, &cursor_addtr },
 293
 294   { "Begin Track",    (VikToolConstructorFunc) tool_begin_track_create,       NULL, NULL, NULL,
 295     (VikToolMouseFunc) tool_begin_track_click,       NULL, NULL, (VikToolKeyFunc) NULL, &cursor_begintr },
 296
 297   { "Edit Waypoint",   (VikToolConstructorFunc) tool_edit_waypoint_create,   NULL, NULL, NULL,
 298     (VikToolMouseFunc) tool_edit_waypoint_click,
 299     (VikToolMouseFunc) tool_edit_waypoint_move,
 300     (VikToolMouseFunc) tool_edit_waypoint_release, (VikToolKeyFunc) NULL, &cursor_edwp },
 301
 302   { "Edit Trackpoint", (VikToolConstructorFunc) tool_edit_trackpoint_create, NULL, NULL, NULL,
 303     (VikToolMouseFunc) tool_edit_trackpoint_click,
 304     (VikToolMouseFunc) tool_edit_trackpoint_move,
 305     (VikToolMouseFunc) tool_edit_trackpoint_release, (VikToolKeyFunc) NULL, &cursor_edtr },
 306
 307   { "Show Picture",    (VikToolConstructorFunc) tool_show_picture_create,    NULL, NULL, NULL,
 308     (VikToolMouseFunc) tool_show_picture_click,    NULL, NULL, (VikToolKeyFunc) NULL, &cursor_showpic },
 309
 310   { "Magic Scissors",  (VikToolConstructorFunc) tool_magic_scissors_create,  NULL, NULL, NULL,
 311     (VikToolMouseFunc) tool_magic_scissors_click, NULL, NULL, (VikToolKeyFunc) NULL, &cursor_iscissors },
 312 };
 313 enum { TOOL_CREATE_WAYPOINT=0, TOOL_CREATE_TRACK, TOOL_BEGIN_TRACK, TOOL_EDIT_WAYPOINT, TOOL_EDIT_TRACKPOINT, TOOL_SHOW_PICTURE, NUM_TOOLS };
 314
 315 /****** PARAMETERS ******/
 316
 317 static gchar *params_groups[] = { "Waypoints", "Tracks", "Waypoint Images" };
 318 enum { GROUP_WAYPOINTS, GROUP_TRACKS, GROUP_IMAGES };
 319
 320 static gchar *params_drawmodes[] = { "Draw by Track", "Draw by Velocity", "All Tracks Black", 0 };
 321 static gchar *params_wpsymbols[] = { "Filled Square", "Square", "Circle", "X", 0 };
 322
 323
 324 static VikLayerParamScale params_scales[] = {
 325  /* min  max    step digits */
 326  {  1,   10,    1,   0 }, /* line_thickness */
 327  {  0.0, 99.0,  1,   2 }, /* velocity_min */
 328  {  1.0, 100.0, 1.0, 2 }, /* velocity_max */
 329                 /* 5 * step == how much to turn */
 330  {  16,   128,  3.2, 0 }, /* image_size */
 331  {   0,   255,  5,   0 }, /* image alpha */
 332  {   5,   500,  5,   0 }, /* image cache_size */
 333  {   0,   8,    1,   0 }, /* image cache_size */
 334  {   1,  64,    1,   0 }, /* wpsize */
 335  {   MIN_STOP_LENGTH, MAX_STOP_LENGTH, 1,   0 }, /* stop_length */
 336  {   1, 100, 1,   0 }, /* stop_length */
 337 };
 338
 339 VikLayerParam trw_layer_params[] = {
 340   { "tracks_visible", VIK_LAYER_PARAM_BOOLEAN, VIK_LAYER_NOT_IN_PROPERTIES },
 341   { "waypoints_visible", VIK_LAYER_PARAM_BOOLEAN, VIK_LAYER_NOT_IN_PROPERTIES },
 342
 343   { "drawmode", VIK_LAYER_PARAM_UINT, GROUP_TRACKS, "Track Drawing Mode:", VIK_LAYER_WIDGET_RADIOGROUP, NULL },
 344   { "drawlines", VIK_LAYER_PARAM_BOOLEAN, GROUP_TRACKS, "Draw Track Lines", VIK_LAYER_WIDGET_CHECKBUTTON },
 345   { "drawpoints", VIK_LAYER_PARAM_BOOLEAN, GROUP_TRACKS, "Draw Trackpoints", VIK_LAYER_WIDGET_CHECKBUTTON },
 346   { "drawelevation", VIK_LAYER_PARAM_BOOLEAN, GROUP_TRACKS, "Draw Elevation", VIK_LAYER_WIDGET_CHECKBUTTON },
 347   { "elevation_factor", VIK_LAYER_PARAM_UINT, GROUP_TRACKS, "Draw Elevation Height %:", VIK_LAYER_WIDGET_HSCALE, params_scales + 9 },
 348
 349   { "drawstops", VIK_LAYER_PARAM_BOOLEAN, GROUP_TRACKS, "Draw Stops", VIK_LAYER_WIDGET_CHECKBUTTON },
 350   { "stop_length", VIK_LAYER_PARAM_UINT, GROUP_TRACKS, "Min Stop Length (seconds):", VIK_LAYER_WIDGET_SPINBUTTON, params_scales + 8 },
 351
 352   { "line_thickness", VIK_LAYER_PARAM_UINT, GROUP_TRACKS, "Track Thickness:", VIK_LAYER_WIDGET_SPINBUTTON, params_scales + 0 },
 353   { "bg_line_thickness", VIK_LAYER_PARAM_UINT, GROUP_TRACKS, "Track BG Thickness:", VIK_LAYER_WIDGET_SPINBUTTON, params_scales + 6 },
 354   { "trackbgcolor", VIK_LAYER_PARAM_COLOR, GROUP_TRACKS, "Track Background Color", VIK_LAYER_WIDGET_COLOR, 0 },
 355   { "velocity_min", VIK_LAYER_PARAM_DOUBLE, GROUP_TRACKS, "Min Track Velocity:", VIK_LAYER_WIDGET_SPINBUTTON, params_scales + 1 },
 356   { "velocity_max", VIK_LAYER_PARAM_DOUBLE, GROUP_TRACKS, "Max Track Velocity:", VIK_LAYER_WIDGET_SPINBUTTON, params_scales + 2 },
 357
 358   { "drawlabels", VIK_LAYER_PARAM_BOOLEAN, GROUP_WAYPOINTS, "Draw Labels", VIK_LAYER_WIDGET_CHECKBUTTON },
 359   { "wpcolor", VIK_LAYER_PARAM_COLOR, GROUP_WAYPOINTS, "Waypoint Color:", VIK_LAYER_WIDGET_COLOR, 0 },
 360   { "wptextcolor", VIK_LAYER_PARAM_COLOR, GROUP_WAYPOINTS, "Waypoint Text:", VIK_LAYER_WIDGET_COLOR, 0 },
 361   { "wpbgcolor", VIK_LAYER_PARAM_COLOR, GROUP_WAYPOINTS, "Background:", VIK_LAYER_WIDGET_COLOR, 0 },
 362   { "wpbgand", VIK_LAYER_PARAM_BOOLEAN, GROUP_WAYPOINTS, "Fake BG Color Translucency:", VIK_LAYER_WIDGET_CHECKBUTTON, 0 },
 363   { "wpsymbol", VIK_LAYER_PARAM_UINT, GROUP_WAYPOINTS, "Waypoint marker:", VIK_LAYER_WIDGET_RADIOGROUP, NULL },
 364   { "wpsize", VIK_LAYER_PARAM_UINT, GROUP_WAYPOINTS, "Waypoint size:", VIK_LAYER_WIDGET_SPINBUTTON, params_scales + 7 },
 365   { "wpsyms", VIK_LAYER_PARAM_BOOLEAN, GROUP_WAYPOINTS, "Draw Waypoint Symbols:", VIK_LAYER_WIDGET_CHECKBUTTON },
 366
 367   { "drawimages", VIK_LAYER_PARAM_BOOLEAN, GROUP_IMAGES, "Draw Waypoint Images", VIK_LAYER_WIDGET_CHECKBUTTON },
 368   { "image_size", VIK_LAYER_PARAM_UINT, GROUP_IMAGES, "Image Size (pixels):", VIK_LAYER_WIDGET_HSCALE, params_scales + 3 },
 369   { "image_alpha", VIK_LAYER_PARAM_UINT, GROUP_IMAGES, "Image Alpha:", VIK_LAYER_WIDGET_HSCALE, params_scales + 4 },
 370   { "image_cache_size", VIK_LAYER_PARAM_UINT, GROUP_IMAGES, "Image Memory Cache Size:", VIK_LAYER_WIDGET_HSCALE, params_scales + 5 },
 371 };
 372
 373 enum { PARAM_TV, PARAM_WV, PARAM_DM, PARAM_DL, PARAM_DP, PARAM_DE, PARAM_EF, PARAM_DS, PARAM_SL, 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_WPSYMS, PARAM_DI, PARAM_IS, PARAM_IA, PARAM_ICS, NUM_PARAMS };
 374
 375 /*** TO ADD A PARAM:
 376  *** 1) Add to trw_layer_params and enumeration
 377  *** 2) Handle in get_param & set_param (presumably adding on to VikTrwLayer struct)
 378  ***/
 379
 380 /****** END PARAMETERS ******/
 381
 382 VikLayerInterface vik_trw_layer_interface = {
 383   "TrackWaypoint",
 384   &trwlayer_pixbuf,
 385
 386   trw_layer_tools,
 387   sizeof(trw_layer_tools) / sizeof(VikToolInterface),
 388
 389   trw_layer_params,
 390   NUM_PARAMS,
 391   params_groups, /* params_groups */
 392   sizeof(params_groups)/sizeof(params_groups[0]),    /* number of groups */
 393
 394   VIK_MENU_ITEM_ALL,
 395
 396   (VikLayerFuncCreate)                  vik_trw_layer_create,
 397   (VikLayerFuncRealize)                 vik_trw_layer_realize,
 398   (VikLayerFuncPostRead)                trw_layer_verify_thumbnails,
 399   (VikLayerFuncFree)                    vik_trw_layer_free,
 400
 401   (VikLayerFuncProperties)              NULL,
 402   (VikLayerFuncDraw)                    vik_trw_layer_draw,
 403   (VikLayerFuncChangeCoordMode)         trw_layer_change_coord_mode,
 404
 405   (VikLayerFuncSetMenuItemsSelection)   vik_trw_layer_set_menu_selection,
 406   (VikLayerFuncGetMenuItemsSelection)   vik_trw_layer_get_menu_selection,
 407
 408   (VikLayerFuncAddMenuItems)            vik_trw_layer_add_menu_items,
 409   (VikLayerFuncSublayerAddMenuItems)    vik_trw_layer_sublayer_add_menu_items,
 410
 411   (VikLayerFuncSublayerRenameRequest)   vik_trw_layer_sublayer_rename_request,
 412   (VikLayerFuncSublayerToggleVisible)   vik_trw_layer_sublayer_toggle_visible,
 413
 414   (VikLayerFuncMarshall)                trw_layer_marshall,
 415   (VikLayerFuncUnmarshall)              trw_layer_unmarshall,
 416
 417   (VikLayerFuncSetParam)                trw_layer_set_param,
 418   (VikLayerFuncGetParam)                trw_layer_get_param,
 419
 420   (VikLayerFuncReadFileData)            a_gpspoint_read_file,
 421   (VikLayerFuncWriteFileData)           a_gpspoint_write_file,
 422
 423   (VikLayerFuncDeleteItem)              trw_layer_del_item,
 424   (VikLayerFuncCopyItem)                trw_layer_copy_item,
 425   (VikLayerFuncPasteItem)               trw_layer_paste_item,
 426   (VikLayerFuncFreeCopiedItem)          trw_layer_free_copied_item,
 427
 428   (VikLayerFuncDragDropRequest)         trw_layer_drag_drop_request,
 429 };
 430
 431 /* for copy & paste (I think?) */
 432 typedef struct {
 433   guint len;
 434   guint8 data[0];
 435   //  gchar *name;
 436   //  VikWaypoint *wp;
 437 } FlatItem;
 438
 439 GType vik_trw_layer_get_type ()
 440 {
 441   static GType vtl_type = 0;
 442
 443   if (!vtl_type)
 444   {
 445     static const GTypeInfo vtl_info =
 446     {
 447       sizeof (VikTrwLayerClass),
 448       NULL, /* base_init */
 449       NULL, /* base_finalize */
 450       NULL, /* class init */
 451       NULL, /* class_finalize */
 452       NULL, /* class_data */
 453       sizeof (VikTrwLayer),
 454       0,
 455       NULL /* instance init */
 456     };
 457     vtl_type = g_type_register_static ( VIK_LAYER_TYPE, "VikTrwLayer", &vtl_info, 0 );
 458   }
 459
 460   return vtl_type;
 461 }
 462
 463 static void trw_layer_del_item ( VikTrwLayer *vtl, gint subtype, gpointer sublayer )
 464 {
 465   static gpointer pass_along[5];
 466   if (!sublayer) {
 467     return;
 468   }
 469
 470   pass_along[0] = vtl;
 471   pass_along[1] = NULL;
 472   pass_along[2] = (gpointer) subtype;
 473   pass_along[3] = sublayer;
 474   pass_along[4] = NULL;
 475
 476   trw_layer_delete_item ( pass_along );
 477 }
 478
 479 static void trw_layer_copy_item_cb( gpointer pass_along[5])
 480 {
 481   VikTrwLayer *vtl = VIK_TRW_LAYER(pass_along[0]);
 482   gint subtype = (gint)pass_along[2];
 483   gpointer * sublayer = pass_along[3];
 484   guint8 *data = NULL;
 485   guint len;
 486
 487   trw_layer_copy_item( vtl, subtype, sublayer, &data, &len);
 488
 489   if (data) {
 490     a_clipboard_copy( VIK_CLIPBOARD_DATA_SUBLAYER, VIK_LAYER_TRW,
 491         subtype, len, data);
 492   }
 493 }
 494
 495 static void trw_layer_cut_item_cb( gpointer pass_along[5])
 496 {
 497   trw_layer_copy_item_cb(pass_along);
 498   trw_layer_delete_item(pass_along);
 499 }
 500
 501 static void trw_layer_copy_item ( VikTrwLayer *vtl, gint subtype, gpointer sublayer, guint8 **item, guint *len )
 502 {
 503   FlatItem *fi;
 504   guint8 *id;
 505   guint il;
 506
 507   if (!sublayer) {
 508     *item = NULL;
 509     return;
 510   }
 511
 512   if ( subtype == VIK_TRW_LAYER_SUBLAYER_WAYPOINT )
 513   {
 514     vik_waypoint_marshall ( g_hash_table_lookup ( vtl->waypoints, sublayer ), &id, &il );
 515   } else {
 516     vik_track_marshall ( g_hash_table_lookup ( vtl->tracks, sublayer ), &id, &il );
 517   }
 518
 519   *len = sizeof(FlatItem) + strlen(sublayer) + 1 + il;
 520   fi = g_malloc ( *len );
 521   fi->len = strlen(sublayer) + 1;
 522   memcpy(fi->data, sublayer, fi->len);
 523   memcpy(fi->data + fi->len, id, il);
 524   g_free(id);
 525   *item = (guint8 *)fi;
 526 }
 527
 528 static gboolean trw_layer_paste_item ( VikTrwLayer *vtl, gint subtype, guint8 *item, guint len )
 529 {
 530   FlatItem *fi = (FlatItem *) item;
 531
 532   if ( subtype == VIK_TRW_LAYER_SUBLAYER_WAYPOINT && fi )
 533   {
 534     VikWaypoint *w;
 535     gchar *name;
 536
 537     name = get_new_unique_sublayer_name(vtl, VIK_TRW_LAYER_SUBLAYER_WAYPOINT, (gchar *)fi->data);
 538     w = vik_waypoint_unmarshall(fi->data + fi->len, len - sizeof(*fi) - fi->len);
 539     vik_trw_layer_add_waypoint ( vtl, name, w );
 540     waypoint_convert(name, w, &vtl->coord_mode);
 541     return TRUE;
 542   }
 543   if ( subtype == VIK_TRW_LAYER_SUBLAYER_TRACK && fi )
 544   {
 545     VikTrack *t;
 546     gchar *name;
 547     name = get_new_unique_sublayer_name(vtl, VIK_TRW_LAYER_SUBLAYER_TRACK, (gchar *)fi->data);
 548     t = vik_track_unmarshall(fi->data + fi->len, len - sizeof(*fi) - fi->len);
 549     vik_trw_layer_add_track ( vtl, name, t );
 550     track_convert(name, t, &vtl->coord_mode);
 551     return TRUE;
 552   }
 553   return FALSE;
 554 }
 555
 556 static void trw_layer_free_copied_item ( gint subtype, gpointer item )
 557 {
 558   if (item) {
 559     g_free(item);
 560   }
 561 }
 562
 563 static gboolean trw_layer_set_param ( VikTrwLayer *vtl, guint16 id, VikLayerParamData data, VikViewport *vp )
 564 {
 565   switch ( id )
 566   {
 567     case PARAM_TV: vtl->tracks_visible = data.b; break;
 568     case PARAM_WV: vtl->waypoints_visible = data.b; break;
 569     case PARAM_DM: vtl->drawmode = data.u; break;
 570     case PARAM_DP: vtl->drawpoints = data.b; break;
 571     case PARAM_DE: vtl->drawelevation = data.b; break;
 572     case PARAM_DS: vtl->drawstops = data.b; break;
 573     case PARAM_DL: vtl->drawlines = data.b; break;
 574     case PARAM_SL: if ( data.u >= MIN_STOP_LENGTH && data.u <= MAX_STOP_LENGTH )
 575                      vtl->stop_length = data.u;
 576                    break;
 577     case PARAM_EF: if ( data.u >= 1 && data.u <= 100 )
 578                      vtl->elevation_factor = data.u;
 579                    break;
 580     case PARAM_LT: if ( data.u > 0 && data.u < 15 && data.u != vtl->line_thickness )
 581                    {
 582                      vtl->line_thickness = data.u;
 583                      trw_layer_new_track_gcs ( vtl, vp );
 584                    }
 585                    break;
 586     case PARAM_BLT: if ( data.u > 0 && data.u <= 8 && data.u != vtl->bg_line_thickness )
 587                    {
 588                      vtl->bg_line_thickness = data.u;
 589                      trw_layer_new_track_gcs ( vtl, vp );
 590                    }
 591                    break;
 592     case PARAM_VMIN: vtl->velocity_min = data.d; break;
 593     case PARAM_VMAX: vtl->velocity_max = data.d; break;
 594     case PARAM_TBGC: gdk_gc_set_rgb_fg_color(vtl->track_bg_gc, &(data.c)); break;
 595     case PARAM_DLA: vtl->drawlabels = data.b; break;
 596     case PARAM_DI: vtl->drawimages = data.b; break;
 597     case PARAM_IS: if ( data.u != vtl->image_size )
 598       {
 599         vtl->image_size = data.u;
 600         g_list_foreach ( vtl->image_cache->head, (GFunc) cached_pixbuf_free, NULL );
 601         g_queue_free ( vtl->image_cache );
 602         vtl->image_cache = g_queue_new ();
 603       }
 604       break;
 605     case PARAM_IA: vtl->image_alpha = data.u; break;
 606     case PARAM_ICS: vtl->image_cache_size = data.u;
 607       while ( vtl->image_cache->length > vtl->image_cache_size ) /* if shrinking cache_size, free pixbuf ASAP */
 608           cached_pixbuf_free ( g_queue_pop_tail ( vtl->image_cache ) );
 609       break;
 610     case PARAM_WPC: gdk_gc_set_rgb_fg_color(vtl->waypoint_gc, &(data.c)); break;
 611     case PARAM_WPTC: gdk_gc_set_rgb_fg_color(vtl->waypoint_text_gc, &(data.c)); break;
 612     case PARAM_WPBC: gdk_gc_set_rgb_fg_color(vtl->waypoint_bg_gc, &(data.c)); break;
 613     case PARAM_WPBA: gdk_gc_set_function(vtl->waypoint_bg_gc, data.b ? GDK_AND : GDK_COPY ); break;
 614     case PARAM_WPSYM: if ( data.u < WP_NUM_SYMBOLS ) vtl->wp_symbol = data.u; break;
 615     case PARAM_WPSIZE: if ( data.u > 0 && data.u <= 64 ) vtl->wp_size = data.u; break;
 616     case PARAM_WPSYMS: vtl->wp_draw_symbols = data.b; break;
 617   }
 618   return TRUE;
 619 }
 620
 621 static VikLayerParamData trw_layer_get_param ( VikTrwLayer *vtl, guint16 id )
 622 {
 623   VikLayerParamData rv;
 624   switch ( id )
 625   {
 626     case PARAM_TV: rv.b = vtl->tracks_visible; break;
 627     case PARAM_WV: rv.b = vtl->waypoints_visible; break;
 628     case PARAM_DM: rv.u = vtl->drawmode; break;
 629     case PARAM_DP: rv.b = vtl->drawpoints; break;
 630     case PARAM_DE: rv.b = vtl->drawelevation; break;
 631     case PARAM_EF: rv.u = vtl->elevation_factor; break;
 632     case PARAM_DS: rv.b = vtl->drawstops; break;
 633     case PARAM_SL: rv.u = vtl->stop_length; break;
 634     case PARAM_DL: rv.b = vtl->drawlines; break;
 635     case PARAM_LT: rv.u = vtl->line_thickness; break;
 636     case PARAM_BLT: rv.u = vtl->bg_line_thickness; break;
 637     case PARAM_VMIN: rv.d = vtl->velocity_min; break;
 638     case PARAM_VMAX: rv.d = vtl->velocity_max; break;
 639     case PARAM_DLA: rv.b = vtl->drawlabels; break;
 640     case PARAM_DI: rv.b = vtl->drawimages; break;
 641     case PARAM_TBGC: vik_gc_get_fg_color(vtl->track_bg_gc, &(rv.c)); break;
 642     case PARAM_IS: rv.u = vtl->image_size; break;
 643     case PARAM_IA: rv.u = vtl->image_alpha; break;
 644     case PARAM_ICS: rv.u = vtl->image_cache_size; break;
 645     case PARAM_WPC: vik_gc_get_fg_color(vtl->waypoint_gc, &(rv.c)); break;
 646     case PARAM_WPTC: vik_gc_get_fg_color(vtl->waypoint_text_gc, &(rv.c)); break;
 647     case PARAM_WPBC: vik_gc_get_fg_color(vtl->waypoint_bg_gc, &(rv.c)); break;
 648     case PARAM_WPBA: rv.b = (vik_gc_get_function(vtl->waypoint_bg_gc)==GDK_AND); break;
 649     case PARAM_WPSYM: rv.u = vtl->wp_symbol; break;
 650     case PARAM_WPSIZE: rv.u = vtl->wp_size; break;
 651     case PARAM_WPSYMS: rv.b = vtl->wp_draw_symbols; break;
 652   }
 653   return rv;
 654 }
 655
 656 static void trw_layer_marshall( VikTrwLayer *vtl, guint8 **data, gint *len )
 657 {
 658   guint8 *pd, *dd;
 659   gint pl, dl;
 660   gchar *tmpname;
 661   FILE *f;
 662
 663   *data = NULL;
 664
 665   if ((f = fdopen(g_file_open_tmp (NULL, &tmpname, NULL), "r+"))) {
 666     a_gpx_write_file(vtl, f);
 667     vik_layer_marshall_params(VIK_LAYER(vtl), &pd, &pl);
 668     fclose(f);
 669     g_file_get_contents(tmpname, (void *)&dd, (void *)&dl, NULL);
 670     *len = sizeof(pl) + pl + dl;
 671     *data = g_malloc(*len);
 672     memcpy(*data, &pl, sizeof(pl));
 673     memcpy(*data + sizeof(pl), pd, pl);
 674     memcpy(*data + sizeof(pl) + pl, dd, dl);
 675
 676     g_free(pd);
 677     g_free(dd);
 678     remove(tmpname);
 679     g_free(tmpname);
 680   }
 681 }
 682
 683 static VikTrwLayer *trw_layer_unmarshall( gpointer data, gint len, VikViewport *vvp )
 684 {
 685   VikTrwLayer *rv = VIK_TRW_LAYER(vik_layer_create ( VIK_LAYER_TRW, vvp, NULL, FALSE ));
 686   guint pl;
 687   gchar *tmpname;
 688   FILE *f;
 689
 690
 691   memcpy(&pl, data, sizeof(pl));
 692   data += sizeof(pl);
 693   vik_layer_unmarshall_params ( VIK_LAYER(rv), data, pl, vvp );
 694   data += pl;
 695
 696   if (!(f = fdopen(g_file_open_tmp (NULL, &tmpname, NULL), "r+"))) {
 697     g_critical("couldn't open temp file\n");
 698     exit(1);
 699   }
 700   fwrite(data, len - pl - sizeof(pl), 1, f);
 701   rewind(f);
 702   a_gpx_read_file(rv, f);
 703   fclose(f);
 704   remove(tmpname);
 705   g_free(tmpname);
 706   return rv;
 707 }
 708
 709 static GList * a_array_to_glist(gpointer data[])
 710 {
 711   GList *gl = NULL;
 712   gpointer * p;
 713   for (p = data; *p; p++)
 714     gl = g_list_prepend(gl, *p);
 715   return(g_list_reverse(gl));
 716 }
 717
 718 VikTrwLayer *vik_trw_layer_new ( gint drawmode )
 719 {
 720   if (trw_layer_params[PARAM_DM].widget_data == NULL)
 721     trw_layer_params[PARAM_DM].widget_data = a_array_to_glist(params_drawmodes);
 722   if (trw_layer_params[PARAM_WPSYM].widget_data == NULL)
 723     trw_layer_params[PARAM_WPSYM].widget_data = a_array_to_glist(params_wpsymbols);
 724
 725   VikTrwLayer *rv = VIK_TRW_LAYER ( g_object_new ( VIK_TRW_LAYER_TYPE, NULL ) );
 726   vik_layer_init ( VIK_LAYER(rv), VIK_LAYER_TRW );
 727
 728   rv->waypoints = g_hash_table_new_full ( g_str_hash, g_str_equal, g_free, (GDestroyNotify) vik_waypoint_free );
 729   rv->tracks = g_hash_table_new_full ( g_str_hash, g_str_equal, g_free, (GDestroyNotify) vik_track_free );
 730   rv->tracks_iters = g_hash_table_new_full ( g_str_hash, g_str_equal, NULL, g_free );
 731   rv->waypoints_iters = g_hash_table_new_full ( g_str_hash, g_str_equal, NULL, g_free );
 732
 733   /* TODO: constants at top */
 734   rv->waypoints_visible = rv->tracks_visible = TRUE;
 735   rv->drawmode = drawmode;
 736   rv->drawpoints = TRUE;
 737   rv->drawstops = FALSE;
 738   rv->drawelevation = FALSE;
 739   rv->elevation_factor = 30;
 740   rv->stop_length = 60;
 741   rv->drawlines = TRUE;
 742   rv->wplabellayout = NULL;
 743   rv->wp_right_click_menu = NULL;
 744   rv->waypoint_gc = NULL;
 745   rv->waypoint_text_gc = NULL;
 746   rv->waypoint_bg_gc = NULL;
 747   rv->track_gc = NULL;
 748   rv->velocity_max = 5.0;
 749   rv->velocity_min = 0.0;
 750   rv->line_thickness = 1;
 751   rv->bg_line_thickness = 0;
 752   rv->current_wp = NULL;
 753   rv->current_wp_name = NULL;
 754   rv->current_track = NULL;
 755   rv->current_tpl = NULL;
 756   rv->current_tp_track_name = NULL;
 757   rv->moving_tp = FALSE;
 758   rv->moving_wp = FALSE;
 759
 760   rv->ct_sync_done = TRUE;
 761
 762   rv->magic_scissors_started = FALSE;
 763   rv->magic_scissors_check_added_track = FALSE;
 764   rv->magic_scissors_added_track_name = NULL;
 765   rv->magic_scissors_current_track = NULL;
 766   rv->magic_scissors_append = FALSE;
 767
 768   rv->waypoint_rightclick = FALSE;
 769   rv->last_tpl = NULL;
 770   rv->last_tp_track_name = NULL;
 771   rv->tpwin = NULL;
 772   rv->image_cache = g_queue_new();
 773   rv->image_size = 64;
 774   rv->image_alpha = 255;
 775   rv->image_cache_size = 300;
 776   rv->drawimages = TRUE;
 777   rv->drawlabels = TRUE;
 778   return rv;
 779 }
 780
 781
 782 void vik_trw_layer_free ( VikTrwLayer *trwlayer )
 783 {
 784   g_hash_table_destroy(trwlayer->waypoints);
 785   g_hash_table_destroy(trwlayer->tracks);
 786
 787   /* ODC: replace with GArray */
 788   trw_layer_free_track_gcs ( trwlayer );
 789
 790   if ( trwlayer->wp_right_click_menu )
 791     gtk_object_sink ( GTK_OBJECT(trwlayer->wp_right_click_menu) );
 792
 793   if ( trwlayer->wplabellayout != NULL)
 794     g_object_unref ( G_OBJECT ( trwlayer->wplabellayout ) );
 795
 796   if ( trwlayer->waypoint_gc != NULL )
 797     g_object_unref ( G_OBJECT ( trwlayer->waypoint_gc ) );
 798
 799   if ( trwlayer->waypoint_text_gc != NULL )
 800     g_object_unref ( G_OBJECT ( trwlayer->waypoint_text_gc ) );
 801
 802   if ( trwlayer->waypoint_bg_gc != NULL )
 803     g_object_unref ( G_OBJECT ( trwlayer->waypoint_bg_gc ) );
 804
 805   if ( trwlayer->waypoint_font != NULL )
 806     gdk_font_unref ( trwlayer->waypoint_font );
 807
 808   if ( trwlayer->tpwin != NULL )
 809     gtk_widget_destroy ( GTK_WIDGET(trwlayer->tpwin) );
 810
 811   g_list_foreach ( trwlayer->image_cache->head, (GFunc) cached_pixbuf_free, NULL );
 812   g_queue_free ( trwlayer->image_cache );
 813 }
 814
 815 static void init_drawing_params ( struct DrawingParams *dp, VikViewport *vp )
 816 {
 817   dp->vp = vp;
 818   dp->xmpp = vik_viewport_get_xmpp ( vp );
 819   dp->ympp = vik_viewport_get_ympp ( vp );
 820   dp->width = vik_viewport_get_width ( vp );
 821   dp->height = vik_viewport_get_height ( vp );
 822   dp->center = vik_viewport_get_center ( vp );
 823   dp->one_zone = vik_viewport_is_one_zone ( vp ); /* false if some other projection besides UTM */
 824   dp->lat_lon = vik_viewport_get_coord_mode ( vp ) == VIK_COORD_LATLON;
 825
 826   if ( dp->one_zone )
 827   {
 828     gint w2, h2;
 829     w2 = dp->xmpp * (dp->width / 2) + 1600 / dp->xmpp;
 830     h2 = dp->ympp * (dp->height / 2) + 1600 / dp->ympp;
 831     /* leniency -- for tracks. Obviously for waypoints this SHOULD be a lot smaller */
 832
 833     dp->ce1 = dp->center->east_west-w2;
 834     dp->ce2 = dp->center->east_west+w2;
 835     dp->cn1 = dp->center->north_south-h2;
 836     dp->cn2 = dp->center->north_south+h2;
 837   } else if ( dp->lat_lon ) {
 838     VikCoord upperleft, bottomright;
 839     /* quick & dirty calculation; really want to check all corners due to lat/lon smaller at top in northern hemisphere */
 840     /* this also DOESN'T WORK if you are crossing 180/-180 lon. I don't plan to in the near future...  */
 841     vik_viewport_screen_to_coord ( vp, -500, -500, &upperleft );
 842     vik_viewport_screen_to_coord ( vp, dp->width+500, dp->height+500, &bottomright );
 843     dp->ce1 = upperleft.east_west;
 844     dp->ce2 = bottomright.east_west;
 845     dp->cn1 = bottomright.north_south;
 846     dp->cn2 = upperleft.north_south;
 847   }
 848
 849   dp->track_gc_iter = 0;
 850 }
 851
 852 static gint calculate_velocity ( VikTrwLayer *vtl, VikTrackpoint *tp1, VikTrackpoint *tp2 )
 853 {
 854   static gdouble rv = 0;
 855   if ( tp1->has_timestamp && tp2->has_timestamp )
 856   {
 857     rv = ( vik_coord_diff ( &(tp1->coord), &(tp2->coord) )
 858            / (tp1->timestamp - tp2->timestamp) ) - vtl->velocity_min;
 859
 860     if ( rv < 0 )
 861       return VIK_TRW_LAYER_TRACK_GC_MIN;
 862     else if ( vtl->velocity_min >= vtl->velocity_max )
 863       return VIK_TRW_LAYER_TRACK_GC_MAX;
 864
 865     rv *= (VIK_TRW_LAYER_TRACK_GC_RATES / (vtl->velocity_max - vtl->velocity_min));
 866
 867     if ( rv >= VIK_TRW_LAYER_TRACK_GC_MAX )
 868       return VIK_TRW_LAYER_TRACK_GC_MAX;
 869     return (gint) rv;
 870  }
 871  else
 872    return VIK_TRW_LAYER_TRACK_GC_BLACK;
 873 }
 874
 875 void draw_utm_skip_insignia ( VikViewport *vvp, GdkGC *gc, gint x, gint y )
 876 {
 877   vik_viewport_draw_line ( vvp, gc, x+5, y, x-5, y );
 878   vik_viewport_draw_line ( vvp, gc, x, y+5, x, y-5 );
 879   vik_viewport_draw_line ( vvp, gc, x+5, y+5, x-5, y-5 );
 880   vik_viewport_draw_line ( vvp, gc, x+5, y-5, x-5, y+5 );
 881 }
 882
 883 static void trw_layer_draw_track ( const gchar *name, VikTrack *track, struct DrawingParams *dp, gboolean drawing_white_background )
 884 {
 885   /* TODO: this function is a mess, get rid of any redundancy */
 886   GList *list = track->trackpoints;
 887   GdkGC *main_gc;
 888   gboolean useoldvals = TRUE;
 889
 890   gboolean drawpoints;
 891   gboolean drawstops;
 892   gboolean drawelevation;
 893   gdouble min_alt, max_alt, alt_diff = 0;
 894
 895   const guint8 tp_size_reg = 2;
 896   const guint8 tp_size_cur = 4;
 897   guint8 tp_size;
 898
 899   if ( dp->vtl->drawelevation )
 900   {
 901     /* assume if it has elevation at the beginning, it has it throughout. not ness a true good assumption */
 902     if ( ( drawelevation = vik_track_get_minmax_alt ( track, &min_alt, &max_alt ) ) )
 903       alt_diff = max_alt - min_alt;
 904   }
 905
 906   if ( ! track->visible )
 907     return;
 908
 909   /* admittedly this is not an efficient way to do it because we go through the whole GC thing all over... */
 910   if ( dp->vtl->bg_line_thickness && !drawing_white_background )
 911     trw_layer_draw_track ( name, track, dp, TRUE );
 912
 913   if ( drawing_white_background )
 914     drawpoints = drawstops = FALSE;
 915   else {
 916     drawpoints = dp->vtl->drawpoints;
 917     drawstops = dp->vtl->drawstops;
 918   }
 919
 920   if ( track == dp->vtl->current_track )
 921     main_gc = dp->vtl->current_track_gc;
 922   else
 923     main_gc = g_array_index(dp->vtl->track_gc, GdkGC *, dp->track_gc_iter);
 924
 925   if (list) {
 926     int x, y, oldx, oldy;
 927     VikTrackpoint *tp = VIK_TRACKPOINT(list->data);
 928
 929     tp_size = (list == dp->vtl->current_tpl) ? tp_size_cur : tp_size_reg;
 930
 931     vik_viewport_coord_to_screen ( dp->vp, &(tp->coord), &x, &y );
 932
 933     if ( (drawpoints) && dp->track_gc_iter < VIK_TRW_LAYER_TRACK_GC )
 934     {
 935       GdkPoint trian[3] = { { x, y-(3*tp_size) }, { x-(2*tp_size), y+(2*tp_size) }, {x+(2*tp_size), y+(2*tp_size)} };
 936       vik_viewport_draw_polygon ( dp->vp, main_gc, TRUE, trian, 3 );
 937     }
 938
 939     oldx = x;
 940     oldy = y;
 941
 942     if ( dp->vtl->drawmode == DRAWMODE_ALL_BLACK )
 943       dp->track_gc_iter = VIK_TRW_LAYER_TRACK_GC_MAX + 1;
 944
 945     while ((list = g_list_next(list)))
 946     {
 947       tp = VIK_TRACKPOINT(list->data);
 948       tp_size = (list == dp->vtl->current_tpl) ? tp_size_cur : tp_size_reg;
 949
 950       /* check some stuff -- but only if we're in UTM and there's only ONE ZONE; or lat lon */
 951       if ( (!dp->one_zone && !dp->lat_lon) ||     /* UTM & zones; do everything */
 952              ( ((!dp->one_zone) || tp->coord.utm_zone == dp->center->utm_zone) &&   /* only check zones if UTM & one_zone */
 953              tp->coord.east_west < dp->ce2 && tp->coord.east_west > dp->ce1 &&  /* both UTM and lat lon */
 954              tp->coord.north_south > dp->cn1 && tp->coord.north_south < dp->cn2 ) )
 955       {
 956         vik_viewport_coord_to_screen ( dp->vp, &(tp->coord), &x, &y );
 957
 958         if ( drawpoints && ! drawing_white_background )
 959         {
 960           if ( list->next ) {
 961             vik_viewport_draw_rectangle ( dp->vp, main_gc, TRUE, x-tp_size, y-tp_size, 2*tp_size, 2*tp_size );
 962
 963             vik_viewport_draw_rectangle ( dp->vp, main_gc, TRUE, x-tp_size, y-tp_size, 2*tp_size, 2*tp_size );
 964
 965             /* stops */
 966             if ( drawstops && VIK_TRACKPOINT(list->next->data)->timestamp - VIK_TRACKPOINT(list->data)->timestamp > dp->vtl->stop_length )
 967               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 );
 968           }
 969           else
 970             vik_viewport_draw_arc ( dp->vp, main_gc, TRUE, x-(2*tp_size), y-(2*tp_size), 4*tp_size, 4*tp_size, 0, 360*64 );
 971         }
 972
 973         if ((!tp->newsegment) && (dp->vtl->drawlines))
 974         {
 975           VikTrackpoint *tp2 = VIK_TRACKPOINT(list->prev->data);
 976
 977           /* UTM only: zone check */
 978           if ( drawpoints && dp->vtl->coord_mode == VIK_COORD_UTM && tp->coord.utm_zone != dp->center->utm_zone )
 979             draw_utm_skip_insignia (  dp->vp, main_gc, x, y);
 980
 981           if ( dp->vtl->drawmode == DRAWMODE_BY_VELOCITY )
 982             dp->track_gc_iter = calculate_velocity ( dp->vtl, tp, tp2 );
 983
 984           if (!useoldvals)
 985             vik_viewport_coord_to_screen ( dp->vp, &(tp2->coord), &oldx, &oldy );
 986
 987           if ( drawing_white_background ) {
 988             vik_viewport_draw_line ( dp->vp, dp->vtl->track_bg_gc, oldx, oldy, x, y);
 989           }
 990           else {
 991
 992             vik_viewport_draw_line ( dp->vp, main_gc, oldx, oldy, x, y);
 993             if ( dp->vtl->drawelevation && list && list->next && VIK_TRACKPOINT(list->next->data)->altitude != VIK_DEFAULT_ALTITUDE ) {
 994               GdkPoint tmp[4];
 995               #define FIXALTITUDE(what) ((VIK_TRACKPOINT((what))->altitude-min_alt)/alt_diff*DRAW_ELEVATION_FACTOR*dp->vtl->elevation_factor/dp->xmpp)
 996               if ( list && list->next && VIK_TRACKPOINT(list->next->data)->altitude != VIK_DEFAULT_ALTITUDE ) {
 997                 tmp[0].x = oldx;
 998                 tmp[0].y = oldy;
 999                 tmp[1].x = oldx;
1000                 tmp[1].y = oldy-FIXALTITUDE(list->data);
1001                 tmp[2].x = x;
1002                 tmp[2].y = y-FIXALTITUDE(list->next->data);
1003                 tmp[3].x = x;
1004                 tmp[3].y = y;
1005
1006                 GdkGC *tmp_gc;
1007                 if ( ((oldx - x) > 0 && (oldy - y) > 0) || ((oldx - x) < 0 && (oldy - y) < 0))
1008                   tmp_gc = GTK_WIDGET(dp->vp)->style->light_gc[3];
1009                 else
1010                   tmp_gc = GTK_WIDGET(dp->vp)->style->dark_gc[0];
1011                 vik_viewport_draw_polygon ( dp->vp, tmp_gc, TRUE, tmp, 4);
1012               }
1013               vik_viewport_draw_line ( dp->vp, main_gc, oldx, oldy-FIXALTITUDE(list->data), x, y-FIXALTITUDE(list->next->data));
1014             }
1015           }
1016         }
1017
1018         oldx = x;
1019         oldy = y;
1020         useoldvals = TRUE;
1021       }
1022       else {
1023         if (useoldvals && dp->vtl->drawlines && (!tp->newsegment))
1024         {
1025           VikTrackpoint *tp2 = VIK_TRACKPOINT(list->prev->data);
1026           if ( dp->vtl->coord_mode != VIK_COORD_UTM || tp->coord.utm_zone == dp->center->utm_zone )
1027           {
1028             vik_viewport_coord_to_screen ( dp->vp, &(tp->coord), &x, &y );
1029             if ( dp->vtl->drawmode == DRAWMODE_BY_VELOCITY )
1030               dp->track_gc_iter = calculate_velocity ( dp->vtl, tp, tp2 );
1031
1032             if ( drawing_white_background )
1033               vik_viewport_draw_line ( dp->vp, dp->vtl->track_bg_gc, oldx, oldy, x, y);
1034             else
1035               vik_viewport_draw_line ( dp->vp, main_gc, oldx, oldy, x, y);
1036           }
1037           else
1038           {
1039             vik_viewport_coord_to_screen ( dp->vp, &(tp2->coord), &x, &y );
1040             draw_utm_skip_insignia ( dp->vp, main_gc, x, y );
1041           }
1042         }
1043         useoldvals = FALSE;
1044       }
1045     }
1046   }
1047   if ( dp->vtl->drawmode == DRAWMODE_BY_TRACK )
1048     if ( ++(dp->track_gc_iter) >= VIK_TRW_LAYER_TRACK_GC )
1049       dp->track_gc_iter = 0;
1050 }
1051
1052 /* the only reason this exists is so that trw_layer_draw_track can first call itself to draw the white track background */
1053 static void trw_layer_draw_track_cb ( const gchar *name, VikTrack *track, struct DrawingParams *dp )
1054 {
1055   trw_layer_draw_track ( name, track, dp, FALSE );
1056 }
1057
1058 static void cached_pixbuf_free ( CachedPixbuf *cp )
1059 {
1060   g_object_unref ( G_OBJECT(cp->pixbuf) );
1061   g_free ( cp->image );
1062 }
1063
1064 static gint cached_pixbuf_cmp ( CachedPixbuf *cp, const gchar *name )
1065 {
1066   return strcmp ( cp->image, name );
1067 }
1068
1069 static void trw_layer_draw_waypoint ( const gchar *name, VikWaypoint *wp, struct DrawingParams *dp )
1070 {
1071   if ( wp->visible )
1072   if ( (!dp->one_zone) || ( wp->coord.utm_zone == dp->center->utm_zone &&
1073              wp->coord.east_west < dp->ce2 && wp->coord.east_west > dp->ce1 &&
1074              wp->coord.north_south > dp->cn1 && wp->coord.north_south < dp->cn2 ) )
1075   {
1076     gint x, y;
1077     GdkPixbuf *sym;
1078     vik_viewport_coord_to_screen ( dp->vp, &(wp->coord), &x, &y );
1079
1080     /* if in shrunken_cache, get that. If not, get and add to shrunken_cache */
1081
1082     if ( wp->image && dp->vtl->drawimages )
1083     {
1084       GdkPixbuf *pixbuf = NULL;
1085       GList *l;
1086
1087       if ( dp->vtl->image_alpha == 0)
1088         return;
1089
1090       l = g_list_find_custom ( dp->vtl->image_cache->head, wp->image, (GCompareFunc) cached_pixbuf_cmp );
1091       if ( l )
1092         pixbuf = ((CachedPixbuf *) l->data)->pixbuf;
1093       else
1094       {
1095         gchar *image = wp->image;
1096         GdkPixbuf *regularthumb = a_thumbnails_get ( wp->image );
1097         if ( ! regularthumb )
1098         {
1099           regularthumb = a_thumbnails_get_default (); /* cache one 'not yet loaded' for all thumbs not loaded */
1100           image = "\x12\x00"; /* this shouldn't occur naturally. */
1101         }
1102         if ( regularthumb )
1103         {
1104           CachedPixbuf *cp = NULL;
1105           cp = g_malloc ( sizeof ( CachedPixbuf ) );
1106           if ( dp->vtl->image_size == 128 )
1107             cp->pixbuf = regularthumb;
1108           else
1109           {
1110             cp->pixbuf = a_thumbnails_scale_pixbuf(regularthumb, dp->vtl->image_size, dp->vtl->image_size);
1111             g_assert ( cp->pixbuf );
1112             g_object_unref ( G_OBJECT(regularthumb) );
1113           }
1114           cp->image = g_strdup ( image );
1115
1116           /* needed so 'click picture' tool knows how big the pic is; we don't
1117            * store it in cp because they may have been freed already. */
1118           wp->image_width = gdk_pixbuf_get_width ( cp->pixbuf );
1119           wp->image_height = gdk_pixbuf_get_height ( cp->pixbuf );
1120
1121           g_queue_push_head ( dp->vtl->image_cache, cp );
1122           if ( dp->vtl->image_cache->length > dp->vtl->image_cache_size )
1123             cached_pixbuf_free ( g_queue_pop_tail ( dp->vtl->image_cache ) );
1124
1125           pixbuf = cp->pixbuf;
1126         }
1127         else
1128         {
1129           pixbuf = a_thumbnails_get_default (); /* thumbnail not yet loaded */
1130         }
1131       }
1132       if ( pixbuf )
1133       {
1134         gint w, h;
1135         w = gdk_pixbuf_get_width ( pixbuf );
1136         h = gdk_pixbuf_get_height ( pixbuf );
1137
1138         if ( x+(w/2) > 0 && y+(h/2) > 0 && x-(w/2) < dp->width && y-(h/2) < dp->height ) /* always draw within boundaries */
1139         {
1140           if ( dp->vtl->image_alpha == 255 )
1141             vik_viewport_draw_pixbuf ( dp->vp, pixbuf, 0, 0, x - (w/2), y - (h/2), w, h );
1142           else
1143             vik_viewport_draw_pixbuf_with_alpha ( dp->vp, pixbuf, dp->vtl->image_alpha, 0, 0, x - (w/2), y - (h/2), w, h );
1144         }
1145         return; /* if failed to draw picture, default to drawing regular waypoint (below) */
1146       }
1147     }
1148
1149     /* DRAW ACTUAL DOT */
1150     if ( dp->vtl->wp_draw_symbols && wp->symbol && (sym = a_get_wp_sym(wp->symbol)) ) {
1151       vik_viewport_draw_pixbuf ( dp->vp, sym, 0, 0, x - gdk_pixbuf_get_width(sym)/2, y - gdk_pixbuf_get_height(sym)/2, -1, -1 );
1152     }
1153     else if ( wp == dp->vtl->current_wp ) {
1154       switch ( dp->vtl->wp_symbol ) {
1155         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;
1156         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;
1157         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;
1158         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 );
1159                           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 );
1160       }
1161     }
1162     else {
1163       switch ( dp->vtl->wp_symbol ) {
1164         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;
1165         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;
1166         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;
1167         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 );
1168                           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;
1169       }
1170     }
1171
1172     if ( dp->vtl->drawlabels )
1173     {
1174       /* thanks to the GPSDrive people (Fritz Ganter et al.) for hints on this part ... yah, I'm too lazy to study documentation */
1175       gint width, height;
1176       pango_layout_set_text ( dp->vtl->wplabellayout, name, -1 );
1177       pango_layout_get_pixel_size ( dp->vtl->wplabellayout, &width, &height );
1178       vik_viewport_draw_rectangle ( dp->vp, dp->vtl->waypoint_bg_gc, TRUE, x + dp->vtl->wp_size - 1, y-1,width+1,height-1);
1179       vik_viewport_draw_layout ( dp->vp, dp->vtl->waypoint_text_gc, x + dp->vtl->wp_size, y, dp->vtl->wplabellayout );
1180     }
1181   }
1182 }
1183
1184 void vik_trw_layer_draw ( VikTrwLayer *l, gpointer data )
1185 {
1186   static struct DrawingParams dp;
1187   g_assert ( l != NULL );
1188
1189   init_drawing_params ( &dp, VIK_VIEWPORT(data) );
1190   dp.vtl = l;
1191
1192   if ( l->tracks_visible )
1193     g_hash_table_foreach ( l->tracks, (GHFunc) trw_layer_draw_track_cb, &dp );
1194
1195   if (l->waypoints_visible)
1196     g_hash_table_foreach ( l->waypoints, (GHFunc) trw_layer_draw_waypoint, &dp );
1197 }
1198
1199 static void trw_layer_free_track_gcs ( VikTrwLayer *vtl )
1200 {
1201   int i;
1202   if ( vtl->track_bg_gc )
1203   {
1204     g_object_unref ( vtl->track_bg_gc );
1205     vtl->track_bg_gc = NULL;
1206   }
1207   if ( vtl->current_track_gc )
1208   {
1209     g_object_unref ( vtl->current_track_gc );
1210     vtl->current_track_gc = NULL;
1211   }
1212
1213   if ( ! vtl->track_gc )
1214     return;
1215   for ( i = vtl->track_gc->len - 1; i >= 0; i-- )
1216     g_object_unref ( g_array_index ( vtl->track_gc, GObject *, i ) );
1217   g_array_free ( vtl->track_gc, TRUE );
1218   vtl->track_gc = NULL;
1219 }
1220
1221 static void trw_layer_new_track_gcs ( VikTrwLayer *vtl, VikViewport *vp )
1222 {
1223   GdkGC *gc[ VIK_TRW_LAYER_TRACK_GC ];
1224   gint width = vtl->line_thickness;
1225
1226   if ( vtl->track_gc )
1227     trw_layer_free_track_gcs ( vtl );
1228
1229   if ( vtl->track_bg_gc )
1230     g_object_unref ( vtl->track_bg_gc );
1231   vtl->track_bg_gc = vik_viewport_new_gc ( vp, "#FFFFFF", width + vtl->bg_line_thickness );
1232
1233   if ( vtl->current_track_gc )
1234     g_object_unref ( vtl->current_track_gc );
1235   vtl->current_track_gc = vik_viewport_new_gc ( vp, "#FF0000", 2 );
1236   gdk_gc_set_line_attributes ( vtl->current_track_gc, 2, GDK_LINE_ON_OFF_DASH, GDK_CAP_ROUND, GDK_JOIN_ROUND );
1237
1238   vtl->track_gc = g_array_sized_new ( FALSE, FALSE, sizeof ( GdkGC * ), VIK_TRW_LAYER_TRACK_GC );
1239
1240   gc[0] = vik_viewport_new_gc ( vp, "#2d870a", width ); /* below range */
1241
1242   gc[1] = vik_viewport_new_gc ( vp, "#0a8742", width );
1243   gc[2] = vik_viewport_new_gc ( vp, "#0a8783", width );
1244   gc[3] = vik_viewport_new_gc ( vp, "#0a4d87", width );
1245   gc[4] = vik_viewport_new_gc ( vp, "#05469f", width );
1246   gc[5] = vik_viewport_new_gc ( vp, "#1b059f", width );
1247   gc[6] = vik_viewport_new_gc ( vp, "#2d059f", width );
1248   gc[7] = vik_viewport_new_gc ( vp, "#4a059f", width );
1249   gc[8] = vik_viewport_new_gc ( vp, "#84059f", width );
1250   gc[9] = vik_viewport_new_gc ( vp, "#96059f", width );
1251   gc[10] = vik_viewport_new_gc ( vp, "#f22ef2", width );
1252
1253   gc[11] = vik_viewport_new_gc ( vp, "#ff0000", width ); /* above range */
1254
1255   gc[12] = vik_viewport_new_gc ( vp, "#000000", width ); /* black / no speed data */
1256
1257   g_array_append_vals ( vtl->track_gc, gc, VIK_TRW_LAYER_TRACK_GC );
1258 }
1259
1260 VikTrwLayer *vik_trw_layer_create ( VikViewport *vp )
1261 {
1262   VikTrwLayer *rv = vik_trw_layer_new ( 0 );
1263   PangoFontDescription *pfd;
1264   rv->wplabellayout = gtk_widget_create_pango_layout (GTK_WIDGET(vp), NULL);
1265   pfd = pango_font_description_from_string (WAYPOINT_FONT);
1266   pango_layout_set_font_description (rv->wplabellayout, pfd);
1267   /* freeing PangoFontDescription, cause it has been copied by prev. call */
1268   pango_font_description_free (pfd);
1269
1270   vik_layer_rename ( VIK_LAYER(rv), vik_trw_layer_interface.name );
1271
1272   trw_layer_new_track_gcs ( rv, vp );
1273
1274   rv->waypoint_gc = vik_viewport_new_gc ( vp, "#000000", 2 );
1275   rv->waypoint_text_gc = vik_viewport_new_gc ( vp, "#FFFFFF", 1 );
1276   rv->waypoint_bg_gc = vik_viewport_new_gc ( vp, "#8383C4", 1 );
1277   gdk_gc_set_function ( rv->waypoint_bg_gc, GDK_AND );
1278
1279   rv->waypoint_font = gdk_font_load ( "-*-helvetica-bold-r-normal-*-*-100-*-*-p-*-iso8859-1" );
1280
1281   rv->has_verified_thumbnails = FALSE;
1282   rv->wp_symbol = WP_SYMBOL_FILLED_SQUARE;
1283   rv->wp_size = 4;
1284   rv->wp_draw_symbols = TRUE;
1285
1286   rv->coord_mode = vik_viewport_get_coord_mode ( vp );
1287
1288   rv->menu_selection = vik_layer_get_interface(VIK_LAYER(rv)->type)->menu_items_selection;
1289
1290   return rv;
1291 }
1292
1293 static void trw_layer_realize_track ( gchar *name, VikTrack *track, gpointer pass_along[4] )
1294 {
1295   GtkTreeIter *new_iter = g_malloc(sizeof(GtkTreeIter));
1296
1297 #ifdef VIK_CONFIG_ALPHABETIZED_TRW
1298   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 );
1299 #else
1300   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 );
1301 #endif
1302
1303   *new_iter = *((GtkTreeIter *) pass_along[1]);
1304   g_hash_table_insert ( VIK_TRW_LAYER(pass_along[2])->tracks_iters, name, new_iter );
1305
1306   if ( ! track->visible )
1307     vik_treeview_item_set_visible ( (VikTreeview *) pass_along[3], (GtkTreeIter *) pass_along[1], FALSE );
1308 }
1309
1310 static void trw_layer_realize_waypoint ( gchar *name, VikWaypoint *wp, gpointer pass_along[4] )
1311 {
1312   GtkTreeIter *new_iter = g_malloc(sizeof(GtkTreeIter));
1313 #ifdef VIK_CONFIG_ALPHABETIZED_TRW
1314   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 );
1315 #else
1316   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 );
1317 #endif
1318
1319   *new_iter = *((GtkTreeIter *) pass_along[1]);
1320   g_hash_table_insert ( VIK_TRW_LAYER(pass_along[2])->waypoints_iters, name, new_iter );
1321
1322   if ( ! wp->visible )
1323     vik_treeview_item_set_visible ( (VikTreeview *) pass_along[3], (GtkTreeIter *) pass_along[1], FALSE );
1324 }
1325
1326
1327 void vik_trw_layer_realize ( VikTrwLayer *vtl, VikTreeview *vt, GtkTreeIter *layer_iter )
1328 {
1329   GtkTreeIter iter2;
1330   gpointer pass_along[5] = { &(vtl->tracks_iter), &iter2, vtl, vt, (gpointer) VIK_TRW_LAYER_SUBLAYER_TRACK };
1331
1332 #ifdef VIK_CONFIG_ALPHABETIZED_TRW
1333   vik_treeview_add_sublayer_alphabetized ( (VikTreeview *) vt, layer_iter, &(vtl->tracks_iter), "Tracks", vtl, NULL, VIK_TRW_LAYER_SUBLAYER_TRACKS, NULL, TRUE, FALSE );
1334 #else
1335   vik_treeview_add_sublayer ( (VikTreeview *) vt, layer_iter, &(vtl->tracks_iter), "Tracks", vtl, NULL, VIK_TRW_LAYER_SUBLAYER_TRACKS, NULL, TRUE, FALSE );
1336 #endif
1337   if ( ! vtl->tracks_visible )
1338     vik_treeview_item_set_visible ( (VikTreeview *) vt, &(vtl->tracks_iter), FALSE );
1339
1340   g_hash_table_foreach ( vtl->tracks, (GHFunc) trw_layer_realize_track, pass_along );
1341
1342 #ifdef VIK_CONFIG_ALPHABETIZED_TRW
1343   vik_treeview_add_sublayer_alphabetized ( (VikTreeview *) vt, layer_iter, &(vtl->waypoints_iter), "Waypoints", vtl, NULL, VIK_TRW_LAYER_SUBLAYER_WAYPOINTS, NULL, TRUE, FALSE );
1344 #else
1345   vik_treeview_add_sublayer ( (VikTreeview *) vt, layer_iter, &(vtl->waypoints_iter), "Waypoints", vtl, NULL, VIK_TRW_LAYER_SUBLAYER_WAYPOINTS, NULL, TRUE, FALSE );
1346 #endif
1347
1348   if ( ! vtl->waypoints_visible )
1349     vik_treeview_item_set_visible ( (VikTreeview *) vt, &(vtl->waypoints_iter), FALSE );
1350
1351   pass_along[0] = &(vtl->waypoints_iter);
1352   pass_along[4] = (gpointer) VIK_TRW_LAYER_SUBLAYER_WAYPOINT;
1353
1354   g_hash_table_foreach ( vtl->waypoints, (GHFunc) trw_layer_realize_waypoint, pass_along );
1355
1356 }
1357
1358 gboolean vik_trw_layer_sublayer_toggle_visible ( VikTrwLayer *l, gint subtype, gpointer sublayer )
1359 {
1360   switch ( subtype )
1361   {
1362     case VIK_TRW_LAYER_SUBLAYER_TRACKS: return (l->tracks_visible ^= 1);
1363     case VIK_TRW_LAYER_SUBLAYER_WAYPOINTS: return (l->waypoints_visible ^= 1);
1364     case VIK_TRW_LAYER_SUBLAYER_TRACK:
1365     {
1366       VikTrack *t = g_hash_table_lookup ( l->tracks, sublayer );
1367       if (t)
1368         return (t->visible ^= 1);
1369       else
1370         return TRUE;
1371     }
1372     case VIK_TRW_LAYER_SUBLAYER_WAYPOINT:
1373     {
1374       VikWaypoint *t = g_hash_table_lookup ( l->waypoints, sublayer );
1375       if (t)
1376         return (t->visible ^= 1);
1377       else
1378         return TRUE;
1379     }
1380   }
1381   return TRUE;
1382 }
1383
1384 GHashTable *vik_trw_layer_get_tracks ( VikTrwLayer *l )
1385 {
1386   return l->tracks;
1387 }
1388
1389 GHashTable *vik_trw_layer_get_waypoints ( VikTrwLayer *l )
1390 {
1391   return l->waypoints;
1392 }
1393
1394 static void trw_layer_find_maxmin_waypoints ( const gchar *name, const VikWaypoint *w, struct LatLon maxmin[2] )
1395 {
1396   static VikCoord fixme;
1397   vik_coord_copy_convert ( &(w->coord), VIK_COORD_LATLON, &fixme );
1398   if ( VIK_LATLON(&fixme)->lat > maxmin[0].lat || maxmin[0].lat == 0.0 )
1399     maxmin[0].lat = VIK_LATLON(&fixme)->lat;
1400   if ( VIK_LATLON(&fixme)->lat < maxmin[1].lat || maxmin[1].lat == 0.0 )
1401     maxmin[1].lat = VIK_LATLON(&fixme)->lat;
1402   if ( VIK_LATLON(&fixme)->lon > maxmin[0].lon || maxmin[0].lon == 0.0 )
1403     maxmin[0].lon = VIK_LATLON(&fixme)->lon;
1404   if ( VIK_LATLON(&fixme)->lon < maxmin[1].lon || maxmin[1].lon == 0.0 )
1405     maxmin[1].lon = VIK_LATLON(&fixme)->lon;
1406 }
1407
1408 static void trw_layer_find_maxmin_tracks ( const gchar *name, GList **t, struct LatLon maxmin[2] )
1409 {
1410   GList *tr = *t;
1411   static VikCoord fixme;
1412
1413   while ( tr )
1414   {
1415     vik_coord_copy_convert ( &(VIK_TRACKPOINT(tr->data)->coord), VIK_COORD_LATLON, &fixme );
1416     if ( VIK_LATLON(&fixme)->lat > maxmin[0].lat || maxmin[0].lat == 0.0 )
1417       maxmin[0].lat = VIK_LATLON(&fixme)->lat;
1418     if ( VIK_LATLON(&fixme)->lat < maxmin[1].lat || maxmin[1].lat == 0.0 )
1419       maxmin[1].lat = VIK_LATLON(&fixme)->lat;
1420     if ( VIK_LATLON(&fixme)->lon > maxmin[0].lon || maxmin[0].lon == 0.0 )
1421       maxmin[0].lon = VIK_LATLON(&fixme)->lon;
1422     if ( VIK_LATLON(&fixme)->lon < maxmin[1].lon || maxmin[1].lon == 0.0 )
1423       maxmin[1].lon = VIK_LATLON(&fixme)->lon;
1424     tr = tr->next;
1425   }
1426 }
1427
1428
1429 gboolean vik_trw_layer_find_center ( VikTrwLayer *vtl, VikCoord *dest )
1430 {
1431   /* 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... */
1432   struct LatLon maxmin[2] = { {0.0,0.0}, {0.0,0.0} };
1433   g_hash_table_foreach ( vtl->waypoints, (GHFunc) trw_layer_find_maxmin_waypoints, maxmin );
1434   g_hash_table_foreach ( vtl->tracks, (GHFunc) trw_layer_find_maxmin_tracks, maxmin );
1435   if (maxmin[0].lat == 0.0 && maxmin[0].lon == 0.0 && maxmin[1].lat == 0.0 && maxmin[1].lon == 0.0)
1436     return FALSE;
1437   else
1438   {
1439     struct LatLon average = { (maxmin[0].lat+maxmin[1].lat)/2, (maxmin[0].lon+maxmin[1].lon)/2 };
1440     vik_coord_load_from_latlon ( dest, vtl->coord_mode, &average );
1441     return TRUE;
1442   }
1443 }
1444
1445 static void trw_layer_centerize ( gpointer layer_and_vlp[2] )
1446 {
1447   VikCoord coord;
1448   if ( vik_trw_layer_find_center ( VIK_TRW_LAYER(layer_and_vlp[0]), &coord ) )
1449     goto_coord ( VIK_LAYERS_PANEL(layer_and_vlp[1]), &coord );
1450   else
1451     a_dialog_info_msg ( VIK_GTK_WINDOW_FROM_LAYER(layer_and_vlp[0]), "This layer has no waypoints or trackpoints." );
1452 }
1453
1454 static void trw_layer_export ( gpointer layer_and_vlp[2], guint file_type )
1455 {
1456   GtkWidget *file_selector;
1457   const gchar *fn;
1458   gboolean failed = FALSE;
1459   file_selector = gtk_file_selection_new ("Export Layer");
1460   gtk_file_selection_set_filename (GTK_FILE_SELECTION(file_selector), vik_layer_get_name(VIK_LAYER(layer_and_vlp[0])));
1461
1462   while ( gtk_dialog_run ( GTK_DIALOG(file_selector) ) == GTK_RESPONSE_OK )
1463   {
1464     fn = gtk_file_selection_get_filename (GTK_FILE_SELECTION(file_selector) );
1465     if ( access ( fn, F_OK ) != 0 )
1466     {
1467       gtk_widget_hide ( file_selector );
1468       failed = ! a_file_export ( VIK_TRW_LAYER(layer_and_vlp[0]), fn, file_type );
1469       break;
1470     }
1471     else
1472     {
1473       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 ) ) )
1474       {
1475         gtk_widget_hide ( file_selector );
1476         failed = ! a_file_export ( VIK_TRW_LAYER(layer_and_vlp[0]), fn, file_type );
1477         break;
1478       }
1479     }
1480   }
1481   gtk_widget_destroy ( file_selector );
1482   if ( failed )
1483     a_dialog_error_msg ( VIK_GTK_WINDOW_FROM_LAYER(layer_and_vlp[0]), "The filename you requested could not be opened for writing." );
1484 }
1485
1486 static void trw_layer_export_gpspoint ( gpointer layer_and_vlp[2] )
1487 {
1488   trw_layer_export ( layer_and_vlp, FILE_TYPE_GPSPOINT );
1489 }
1490
1491 static void trw_layer_export_gpsmapper ( gpointer layer_and_vlp[2] )
1492 {
1493   trw_layer_export ( layer_and_vlp, FILE_TYPE_GPSMAPPER );
1494 }
1495
1496 static void trw_layer_export_gpx ( gpointer layer_and_vlp[2] )
1497 {
1498   trw_layer_export ( layer_and_vlp, FILE_TYPE_GPX );
1499 }
1500
1501 static void trw_layer_goto_wp ( gpointer layer_and_vlp[2] )
1502 {
1503   GHashTable *wps = vik_trw_layer_get_waypoints ( VIK_TRW_LAYER(layer_and_vlp[0]) );
1504   GtkWidget *dia = gtk_dialog_new_with_buttons ("Create",
1505                                                  VIK_GTK_WINDOW_FROM_LAYER(layer_and_vlp[0]),
1506                                                  GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
1507                                                  GTK_STOCK_CANCEL,
1508                                                  GTK_RESPONSE_REJECT,
1509                                                  GTK_STOCK_OK,
1510                                                  GTK_RESPONSE_ACCEPT,
1511                                                  NULL);
1512
1513   GtkWidget *label, *entry;
1514   label = gtk_label_new("Waypoint Name:");
1515   entry = gtk_entry_new();
1516
1517   gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dia)->vbox), label, FALSE, FALSE, 0);
1518   gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dia)->vbox), entry, FALSE, FALSE, 0);
1519   gtk_widget_show_all ( label );
1520   gtk_widget_show_all ( entry );
1521
1522   while ( gtk_dialog_run ( GTK_DIALOG(dia) ) == GTK_RESPONSE_ACCEPT )
1523   {
1524     VikWaypoint *wp;
1525     gchar *upname = g_strdup(gtk_entry_get_text(GTK_ENTRY(entry)));
1526     int i;
1527
1528     for ( i = strlen(upname)-1; i >= 0; i-- )
1529       upname[i] = toupper(upname[i]);
1530
1531     wp = g_hash_table_lookup ( wps, upname );
1532
1533     if (!wp)
1534       a_dialog_error_msg ( VIK_GTK_WINDOW_FROM_LAYER(layer_and_vlp[0]), "Waypoint not found in this layer." );
1535     else
1536     {
1537       vik_viewport_set_center_coord ( vik_layers_panel_get_viewport(VIK_LAYERS_PANEL(layer_and_vlp[1])), &(wp->coord) );
1538       vik_layers_panel_emit_update ( VIK_LAYERS_PANEL(layer_and_vlp[1]) );
1539       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 ) );
1540       break;
1541     }
1542
1543     g_free ( upname );
1544
1545   }
1546   gtk_widget_destroy ( dia );
1547 }
1548
1549 gboolean vik_trw_layer_new_waypoint ( VikTrwLayer *vtl, GtkWindow *w, const VikCoord *def_coord )
1550 {
1551   gchar *name;
1552   VikWaypoint *wp = vik_waypoint_new();
1553   wp->coord = *def_coord;
1554   wp->altitude = VIK_DEFAULT_ALTITUDE;
1555
1556   if ( a_dialog_new_waypoint ( w, &name, wp, vik_trw_layer_get_waypoints ( vtl ), vtl->coord_mode ) )
1557   {
1558     wp->visible = TRUE;
1559     vik_trw_layer_add_waypoint ( vtl, name, wp );
1560     return TRUE;
1561   }
1562   vik_waypoint_free(wp);
1563   return FALSE;
1564 }
1565
1566 static void trw_layer_new_wp ( gpointer lav[2] )
1567 {
1568   VikTrwLayer *vtl = VIK_TRW_LAYER(lav[0]);
1569   VikLayersPanel *vlp = VIK_LAYERS_PANEL(lav[1]);
1570   /* TODO longone: okay, if layer above (aggregate) is invisible but vtl->visible is true, this redraws for no reason.
1571      instead return true if you want to update. */
1572   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 )
1573     vik_layers_panel_emit_update ( vlp );
1574 }
1575
1576 void vik_trw_layer_add_menu_items ( VikTrwLayer *vtl, GtkMenu *menu, gpointer vlp )
1577 {
1578   static gpointer pass_along[2];
1579   GtkWidget *item;
1580   GtkWidget *export_submenu;
1581   pass_along[0] = vtl;
1582   pass_along[1] = vlp;
1583
1584   item = gtk_menu_item_new();
1585   gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
1586   gtk_widget_show ( item );
1587
1588   item = gtk_menu_item_new_with_label ( "Goto Center of Layer" );
1589   g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_centerize), pass_along );
1590   gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
1591   gtk_widget_show ( item );
1592
1593   item = gtk_menu_item_new_with_label ( "Goto Waypoint" );
1594   g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_goto_wp), pass_along );
1595   gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
1596   gtk_widget_show ( item );
1597
1598   export_submenu = gtk_menu_new ();
1599   item = gtk_menu_item_new_with_label ( "Export layer" );
1600   gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
1601   gtk_widget_show ( item );
1602   gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), export_submenu );
1603
1604   item = gtk_menu_item_new_with_label ( "Export as GPSPoint" );
1605   g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_export_gpspoint), pass_along );
1606   gtk_menu_shell_append (GTK_MENU_SHELL (export_submenu), item);
1607   gtk_widget_show ( item );
1608
1609   item = gtk_menu_item_new_with_label ( "Export as GPSMapper" );
1610   g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_export_gpsmapper), pass_along );
1611   gtk_menu_shell_append (GTK_MENU_SHELL (export_submenu), item);
1612   gtk_widget_show ( item );
1613
1614   item = gtk_menu_item_new_with_label ( "Export as GPX" );
1615   g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_export_gpx), pass_along );
1616   gtk_menu_shell_append (GTK_MENU_SHELL (export_submenu), item);
1617   gtk_widget_show ( item );
1618
1619   item = gtk_menu_item_new_with_label ( "New Waypoint" );
1620   g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_new_wp), pass_along );
1621   gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
1622   gtk_widget_show ( item );
1623
1624 #ifdef VIK_CONFIG_OPENSTREETMAP
1625   item = gtk_menu_item_new_with_label ( "Upload to OSM" );
1626   g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(osm_traces_upload_cb), pass_along );
1627   gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
1628   gtk_widget_show ( item );
1629 #endif
1630 }
1631
1632 void vik_trw_layer_add_waypoint ( VikTrwLayer *vtl, gchar *name, VikWaypoint *wp )
1633 {
1634   if ( VIK_LAYER(vtl)->realized )
1635   {
1636     VikWaypoint *oldwp = VIK_WAYPOINT ( g_hash_table_lookup ( vtl->waypoints, name ) );
1637     if ( oldwp )
1638       wp->visible = oldwp->visible; /* same visibility so we don't have to update viktreeview */
1639     else
1640     {
1641       GtkTreeIter *iter = g_malloc(sizeof(GtkTreeIter));
1642 #ifdef VIK_CONFIG_ALPHABETIZED_TRW
1643       vik_treeview_add_sublayer_alphabetized ( VIK_LAYER(vtl)->vt, &(vtl->waypoints_iter), iter, name, vtl, name, VIK_TRW_LAYER_SUBLAYER_WAYPOINT, NULL, TRUE, TRUE );
1644 #else
1645       vik_treeview_add_sublayer ( VIK_LAYER(vtl)->vt, &(vtl->waypoints_iter), iter, name, vtl, name, VIK_TRW_LAYER_SUBLAYER_WAYPOINT, NULL, TRUE, TRUE );
1646 #endif
1647       vik_treeview_select_iter ( VIK_LAYER(vtl)->vt, iter );
1648       g_hash_table_insert ( vtl->waypoints_iters, name, iter );
1649       wp->visible = TRUE;
1650     }
1651   }
1652   else
1653     wp->visible = TRUE;
1654
1655   g_hash_table_insert ( vtl->waypoints, name, wp );
1656
1657 }
1658
1659 void vik_trw_layer_add_track ( VikTrwLayer *vtl, gchar *name, VikTrack *t )
1660 {
1661   if ( VIK_LAYER(vtl)->realized )
1662   {
1663     VikTrack *oldt = VIK_TRACK ( g_hash_table_lookup ( vtl->tracks, name ) );
1664     if ( oldt )
1665       t->visible = oldt->visible; /* same visibility so we don't have to update viktreeview */
1666     else
1667     {
1668       GtkTreeIter *iter = g_malloc(sizeof(GtkTreeIter));
1669 #ifdef VIK_CONFIG_ALPHABETIZED_TRW
1670       vik_treeview_add_sublayer_alphabetized ( VIK_LAYER(vtl)->vt, &(vtl->tracks_iter), iter, name, vtl, name, VIK_TRW_LAYER_SUBLAYER_TRACK, NULL, TRUE, TRUE );
1671 #else
1672       vik_treeview_add_sublayer ( VIK_LAYER(vtl)->vt, &(vtl->tracks_iter), iter, name, vtl, name, VIK_TRW_LAYER_SUBLAYER_TRACK, NULL, TRUE, TRUE );
1673 #endif
1674       vik_treeview_select_iter ( VIK_LAYER(vtl)->vt, iter );
1675       g_hash_table_insert ( vtl->tracks_iters, name, iter );
1676       /* t->visible = TRUE; */
1677     }
1678   }
1679   else
1680     ; /* t->visible = TRUE; // this is now used by file input functions */
1681
1682   g_hash_table_insert ( vtl->tracks, name, t );
1683
1684 }
1685
1686 static gboolean uppercase_exists_in_hash ( GHashTable *hash, const gchar *str )
1687 {
1688   gchar *upp = g_strdup ( str );
1689   gboolean rv;
1690   char *tmp = upp;
1691   while  ( *tmp )
1692   {
1693     *tmp = toupper(*tmp);
1694     tmp++;
1695   }
1696   rv = g_hash_table_lookup ( hash, upp ) ? TRUE : FALSE;
1697   g_free (upp);
1698   return rv;
1699 }
1700
1701 /* to be called whenever a track has been deleted or may have been changed. */
1702 static void trw_layer_cancel_tps_of_track ( VikTrwLayer *vtl, const gchar *trk_name )
1703 {
1704   if (vtl->current_tp_track_name && g_strcasecmp(trk_name, vtl->current_tp_track_name) == 0)
1705     trw_layer_cancel_current_tp ( vtl, FALSE );
1706   else if (vtl->last_tp_track_name && g_strcasecmp(trk_name, vtl->last_tp_track_name) == 0)
1707     trw_layer_cancel_last_tp ( vtl );
1708 }
1709
1710 static gchar *get_new_unique_sublayer_name (VikTrwLayer *vtl, gint sublayer_type, const gchar *name)
1711 {
1712  gint i = 2;
1713  gchar *newname = g_strdup(name);
1714  while ((sublayer_type == VIK_TRW_LAYER_SUBLAYER_TRACK) ?
1715          (void *)vik_trw_layer_get_track(vtl, newname) : (void *)vik_trw_layer_get_waypoint(vtl, newname)) {
1716     gchar *new_newname = g_strdup_printf("%s#%d", name, i);
1717     g_free(newname);
1718     newname = new_newname;
1719     i++;
1720   }
1721   return newname;
1722 }
1723
1724 void vik_trw_layer_filein_add_waypoint ( VikTrwLayer *vtl, gchar *name, VikWaypoint *wp )
1725 {
1726   vik_trw_layer_add_waypoint ( vtl,
1727                         get_new_unique_sublayer_name(vtl, VIK_TRW_LAYER_SUBLAYER_WAYPOINT, name),
1728                         wp );
1729 }
1730 void vik_trw_layer_filein_add_track ( VikTrwLayer *vtl, gchar *name, VikTrack *tr )
1731 {
1732   if ( vtl->magic_scissors_append && vtl->magic_scissors_current_track ) {
1733     vik_track_remove_dup_points ( tr ); /* make "double point" track work to undo */
1734     vik_track_steal_and_append_trackpoints ( vtl->magic_scissors_current_track, tr );
1735     vik_track_free ( tr );
1736     vtl->magic_scissors_append = FALSE; /* this means we have added it */
1737   } else {
1738     gchar *new_name = get_new_unique_sublayer_name(vtl, VIK_TRW_LAYER_SUBLAYER_TRACK, name);
1739     vik_trw_layer_add_track ( vtl, new_name, tr );
1740
1741     if ( vtl->magic_scissors_check_added_track ) {
1742       vik_track_remove_dup_points ( tr ); /* make "double point" track work to undo */
1743       if ( vtl->magic_scissors_added_track_name ) /* for google routes */
1744         g_free ( vtl->magic_scissors_added_track_name );
1745       vtl->magic_scissors_added_track_name = g_strdup(new_name);
1746     }
1747   }
1748 }
1749
1750 static void trw_layer_enum_item ( const gchar *name, GList **tr, GList **l )
1751 {
1752   *l = g_list_append(*l, (gpointer)name);
1753 }
1754
1755 static void trw_layer_move_item ( VikTrwLayer *vtl_src, VikTrwLayer *vtl_dest, gchar *name, gint type )
1756 {
1757   gchar *newname = get_new_unique_sublayer_name(vtl_dest, type, name);
1758   if (type == VIK_TRW_LAYER_SUBLAYER_TRACK) {
1759     VikTrack *t;
1760     t = vik_track_copy(vik_trw_layer_get_track(vtl_src, name));
1761     vik_trw_layer_delete_track(vtl_src, name);
1762     vik_trw_layer_add_track(vtl_dest, newname, t);
1763   }
1764   if (type==VIK_TRW_LAYER_SUBLAYER_WAYPOINT) {
1765     VikWaypoint *w;
1766     w = vik_waypoint_copy(vik_trw_layer_get_waypoint(vtl_src, name));
1767     vik_trw_layer_delete_waypoint(vtl_src, name);
1768     vik_trw_layer_add_waypoint(vtl_dest, newname, w);
1769   }
1770 }
1771
1772 static void trw_layer_drag_drop_request ( VikTrwLayer *vtl_src, VikTrwLayer *vtl_dest, GtkTreeIter *src_item_iter, GtkTreePath *dest_path )
1773 {
1774   VikTreeview *vt = VIK_LAYER(vtl_src)->vt;
1775   gint type = vik_treeview_item_get_data(vt, src_item_iter);
1776
1777   if (!vik_treeview_item_get_pointer(vt, src_item_iter)) {
1778     GList *items = NULL;
1779     GList *iter;
1780
1781     if (type==VIK_TRW_LAYER_SUBLAYER_TRACKS) {
1782       g_hash_table_foreach ( vtl_src->tracks, (GHFunc)trw_layer_enum_item, &items);
1783     }
1784     if (type==VIK_TRW_LAYER_SUBLAYER_WAYPOINTS) {
1785       g_hash_table_foreach ( vtl_src->waypoints, (GHFunc)trw_layer_enum_item, &items);
1786     }
1787
1788     iter = items;
1789     while (iter) {
1790       if (type==VIK_TRW_LAYER_SUBLAYER_TRACKS) {
1791         trw_layer_move_item ( vtl_src, vtl_dest, iter->data, VIK_TRW_LAYER_SUBLAYER_TRACK);
1792       } else {
1793         trw_layer_move_item ( vtl_src, vtl_dest, iter->data, VIK_TRW_LAYER_SUBLAYER_WAYPOINT);
1794       }
1795       iter = iter->next;
1796     }
1797     if (items)
1798       g_list_free(items);
1799   } else {
1800     gchar *name = vik_treeview_item_get_pointer(vt, src_item_iter);
1801     trw_layer_move_item(vtl_src, vtl_dest, name, type);
1802   }
1803 }
1804
1805
1806 gboolean vik_trw_layer_delete_track ( VikTrwLayer *vtl, const gchar *trk_name )
1807 {
1808   VikTrack *t = g_hash_table_lookup ( vtl->tracks, trk_name );
1809   gboolean was_visible = FALSE;
1810   if ( t )
1811   {
1812     GtkTreeIter *it;
1813     was_visible = t->visible;
1814     if ( t == vtl->current_track )
1815       vtl->current_track = NULL;
1816     if ( t == vtl->magic_scissors_current_track )
1817       vtl->magic_scissors_current_track = NULL;
1818
1819     /* could be current_tp, so we have to check */
1820     trw_layer_cancel_tps_of_track ( vtl, trk_name );
1821
1822     g_assert ( ( it = g_hash_table_lookup ( vtl->tracks_iters, trk_name ) ) );
1823     vik_treeview_item_delete ( VIK_LAYER(vtl)->vt, it );
1824     g_hash_table_remove ( vtl->tracks_iters, trk_name );
1825
1826     /* do this last because trk_name may be pointing to actual orig key */
1827     g_hash_table_remove ( vtl->tracks, trk_name );
1828   }
1829   return was_visible;
1830 }
1831
1832 gboolean vik_trw_layer_delete_waypoint ( VikTrwLayer *vtl, const gchar *wp_name )
1833 {
1834   gboolean was_visible = FALSE;
1835   VikWaypoint *wp;
1836
1837   wp = g_hash_table_lookup ( vtl->waypoints, wp_name );
1838   if ( wp ) {
1839     GtkTreeIter *it;
1840
1841     if ( wp == vtl->current_wp ) {
1842       vtl->current_wp = NULL;
1843       vtl->current_wp_name = NULL;
1844       vtl->moving_wp = FALSE;
1845     }
1846
1847     was_visible = wp->visible;
1848     g_assert ( ( it = g_hash_table_lookup ( vtl->waypoints_iters, (gchar *) wp_name ) ) );
1849     vik_treeview_item_delete ( VIK_LAYER(vtl)->vt, it );
1850     g_hash_table_remove ( vtl->waypoints_iters, (gchar *) wp_name );
1851     g_hash_table_remove ( vtl->waypoints, wp_name ); /* last because this frees name */
1852   }
1853
1854   return was_visible;
1855 }
1856
1857 static void remove_item_from_treeview(const gchar *name, GtkTreeIter *it, VikTreeview * vt)
1858 {
1859     vik_treeview_item_delete (vt, it );
1860 }
1861
1862 void vik_trw_layer_delete_all_tracks ( VikTrwLayer *vtl )
1863 {
1864
1865   vtl->current_track = NULL;
1866   vtl->magic_scissors_current_track = NULL;
1867   if (vtl->current_tp_track_name)
1868     trw_layer_cancel_current_tp(vtl, FALSE);
1869   if (vtl->last_tp_track_name)
1870     trw_layer_cancel_last_tp ( vtl );
1871
1872   g_hash_table_foreach(vtl->tracks_iters, (GHFunc) remove_item_from_treeview, VIK_LAYER(vtl)->vt);
1873   g_hash_table_remove_all(vtl->tracks_iters);
1874   g_hash_table_remove_all(vtl->tracks);
1875
1876   /* TODO: only update if the layer is visible (ticked) */
1877   vik_layer_emit_update ( VIK_LAYER(vtl) );
1878 }
1879
1880 void vik_trw_layer_delete_all_waypoints ( VikTrwLayer *vtl )
1881 {
1882   vtl->current_wp = NULL;
1883   vtl->current_wp_name = NULL;
1884   vtl->moving_wp = FALSE;
1885
1886   g_hash_table_foreach(vtl->waypoints_iters, (GHFunc) remove_item_from_treeview, VIK_LAYER(vtl)->vt);
1887   g_hash_table_remove_all(vtl->waypoints_iters);
1888   g_hash_table_remove_all(vtl->waypoints);
1889
1890   /* TODO: only update if the layer is visible (ticked) */
1891   vik_layer_emit_update ( VIK_LAYER(vtl) );
1892 }
1893
1894 static void trw_layer_delete_item ( gpointer pass_along[5] )
1895 {
1896   VikTrwLayer *vtl = VIK_TRW_LAYER(pass_along[0]);
1897   gboolean was_visible = FALSE;
1898   if ( (gint) pass_along[2] == VIK_TRW_LAYER_SUBLAYER_WAYPOINT )
1899   {
1900     was_visible = vik_trw_layer_delete_waypoint ( vtl, (gchar *) pass_along[3] );
1901   }
1902   else
1903   {
1904     was_visible = vik_trw_layer_delete_track ( vtl, (gchar *) pass_along[3] );
1905   }
1906   if ( was_visible )
1907     vik_layer_emit_update ( VIK_LAYER(vtl) );
1908 }
1909
1910
1911 static void trw_layer_properties_item ( gpointer pass_along[5] )
1912 {
1913   VikTrwLayer *vtl = VIK_TRW_LAYER(pass_along[0]);
1914   if ( (gint) pass_along[2] == VIK_TRW_LAYER_SUBLAYER_WAYPOINT )
1915   {
1916     VikWaypoint *wp = g_hash_table_lookup ( vtl->waypoints, pass_along[3] );
1917     if ( wp )
1918     {
1919       if ( a_dialog_new_waypoint ( VIK_GTK_WINDOW_FROM_LAYER(vtl), NULL, wp, NULL, vtl->coord_mode ) )
1920
1921       if ( VIK_LAYER(vtl)->visible )
1922         vik_layer_emit_update ( VIK_LAYER(vtl) );
1923     }
1924   }
1925   else
1926   {
1927     VikTrack *tr = g_hash_table_lookup ( vtl->tracks, pass_along[3] );
1928     if ( tr )
1929     {
1930       gint resp = vik_trw_layer_propwin_run ( VIK_GTK_WINDOW_FROM_LAYER(vtl), tr, pass_along[1] /* vlp */ );
1931       if ( resp == VIK_TRW_LAYER_PROPWIN_DEL_DUP )
1932       {
1933         vik_track_remove_dup_points(tr);
1934         /* above operation could have deleted current_tp or last_tp */
1935         trw_layer_cancel_tps_of_track ( vtl, (gchar *) pass_along[3] );
1936         vik_layer_emit_update ( VIK_LAYER(vtl) );
1937       }
1938       if ( resp == VIK_TRW_LAYER_PROPWIN_REVERSE )
1939       {
1940         vik_track_reverse(tr);
1941         vik_layer_emit_update ( VIK_LAYER(vtl) );
1942       }
1943       else if ( resp == VIK_TRW_LAYER_PROPWIN_SPLIT )
1944       {
1945         /* get new tracks, add them, resolve naming conflicts (free if cancel), and delete old. old can still exist on clipboard. */
1946         guint ntracks;
1947         VikTrack **tracks = vik_track_split_into_segments(tr, &ntracks);
1948         gchar *new_tr_name;
1949         guint i;
1950         for ( i = 0; i < ntracks; i++ )
1951         {
1952           g_assert ( tracks[i] );
1953           new_tr_name = g_strdup_printf("%s #%d", (gchar *) pass_along[3], i+1);
1954           /* if ( (wp_exists) && (! overwrite) ) */
1955           /* don't need to upper case new_tr_name because old tr name was uppercase */
1956           if ( g_hash_table_lookup ( vtl->tracks, new_tr_name ) &&
1957              ( ! a_dialog_overwrite ( VIK_GTK_WINDOW_FROM_LAYER(vtl), "The track \"%s\" exists, do you wish to overwrite it?", new_tr_name ) ) )
1958           {
1959             gchar *new_new_tr_name = a_dialog_new_track ( VIK_GTK_WINDOW_FROM_LAYER(vtl), vtl->tracks );
1960             g_free ( new_tr_name );
1961             if (new_new_tr_name)
1962               new_tr_name = new_new_tr_name;
1963             else
1964             {
1965               new_tr_name = NULL;
1966               vik_track_free ( tracks[i] );
1967             }
1968           }
1969           if ( new_tr_name )
1970             vik_trw_layer_add_track ( vtl, new_tr_name, tracks[i] );
1971         }
1972         if ( tracks )
1973         {
1974           g_free ( tracks );
1975           vik_trw_layer_delete_track ( vtl, (gchar *) pass_along[3] );
1976           vik_layer_emit_update ( VIK_LAYER(vtl) ); /* chase thru the hoops */
1977         }
1978       }
1979     }
1980   }
1981 }
1982
1983 static void goto_coord ( VikLayersPanel *vlp, const VikCoord *coord )
1984 {
1985   vik_viewport_set_center_coord ( vik_layers_panel_get_viewport(vlp), coord );
1986   vik_layers_panel_emit_update ( vlp );
1987 }
1988
1989 static void trw_layer_goto_track_startpoint ( gpointer pass_along[5] )
1990 {
1991   GList *trps = ((VikTrack *) g_hash_table_lookup ( VIK_TRW_LAYER(pass_along[0])->tracks, pass_along[3] ))->trackpoints;
1992   if ( trps && trps->data )
1993     goto_coord ( VIK_LAYERS_PANEL(pass_along[1]), &(((VikTrackpoint *) trps->data)->coord));
1994 }
1995
1996 static void trw_layer_goto_track_center ( gpointer pass_along[5] )
1997 {
1998   /* FIXME: get this into viktrack.c, and should be ->trackpoints right? */
1999   GList **trps = g_hash_table_lookup ( VIK_TRW_LAYER(pass_along[0])->tracks, pass_along[3] );
2000   if ( trps && *trps )
2001   {
2002     struct LatLon average, maxmin[2] = { {0,0}, {0,0} };
2003     VikCoord coord;
2004     trw_layer_find_maxmin_tracks ( NULL, trps, maxmin );
2005     average.lat = (maxmin[0].lat+maxmin[1].lat)/2;
2006     average.lon = (maxmin[0].lon+maxmin[1].lon)/2;
2007     vik_coord_load_from_latlon ( &coord, VIK_TRW_LAYER(pass_along[0])->coord_mode, &average );
2008     goto_coord ( VIK_LAYERS_PANEL(pass_along[1]), &coord);
2009   }
2010 }
2011
2012 static void trw_layer_extend_track_end ( gpointer pass_along[6] )
2013 {
2014   VikTrwLayer *vtl = VIK_TRW_LAYER(pass_along[0]);
2015   VikTrack *track = g_hash_table_lookup ( VIK_TRW_LAYER(pass_along[0])->tracks, pass_along[3] );
2016
2017   vtl->current_track = track;
2018   vik_window_enable_layer_tool ( VIK_WINDOW(VIK_GTK_WINDOW_FROM_LAYER(vtl)), VIK_LAYER_TRW, TOOL_CREATE_TRACK );
2019
2020   if ( track->trackpoints )
2021     goto_coord ( VIK_LAYERS_PANEL(pass_along[1]), &(((VikTrackpoint *)g_list_last(track->trackpoints)->data)->coord) );
2022 }
2023
2024 static void trw_layer_apply_dem_data ( gpointer pass_along[6] )
2025 {
2026   /* TODO: check & warn if no DEM data, or no applicable DEM data. */
2027   /* Also warn if overwrite old elevation data */
2028   VikTrack *track = (VikTrack *) g_hash_table_lookup ( VIK_TRW_LAYER(pass_along[0])->tracks, pass_along[3] );
2029
2030   vik_track_apply_dem_data ( track );
2031 }
2032
2033 static void trw_layer_goto_track_endpoint ( gpointer pass_along[6] )
2034 {
2035   GList *trps = ((VikTrack *) g_hash_table_lookup ( VIK_TRW_LAYER(pass_along[0])->tracks, pass_along[3] ))->trackpoints;
2036   if ( !trps )
2037     return;
2038   trps = g_list_last(trps);
2039   goto_coord ( VIK_LAYERS_PANEL(pass_along[1]), &(((VikTrackpoint *) trps->data)->coord));
2040 }
2041
2042
2043 /*************************************
2044  * merge/split by time routines
2045  *************************************/
2046
2047 /* called for each key in track hash table. if original track user_data[1] is close enough
2048  * to the passed one, add it to list in user_data[0]
2049  */
2050 static void find_nearby_track(gpointer key, gpointer value, gpointer user_data)
2051 {
2052   time_t t1, t2;
2053   VikTrackpoint *p1, *p2;
2054
2055   GList **nearby_tracks = ((gpointer *)user_data)[0];
2056   GList *orig_track = ((gpointer *)user_data)[1];
2057   guint thr = (guint)((gpointer *)user_data)[2];
2058
2059   t1 = VIK_TRACKPOINT(orig_track->data)->timestamp;
2060   t2 = VIK_TRACKPOINT(g_list_last(orig_track)->data)->timestamp;
2061
2062   if (VIK_TRACK(value)->trackpoints == orig_track) {
2063     return;
2064   }
2065
2066   p1 = VIK_TRACKPOINT(VIK_TRACK(value)->trackpoints->data);
2067   p2 = VIK_TRACKPOINT(g_list_last(VIK_TRACK(value)->trackpoints)->data);
2068
2069   if (!p1->has_timestamp || !p2->has_timestamp) {
2070     g_print("no timestamp\n");
2071     return;
2072   }
2073
2074   /*  g_print("Got track named %s, times %d, %d\n", (gchar *)key, p1->timestamp, p2->timestamp); */
2075   if (abs(t1 - p2->timestamp) < thr*60 ||
2076       /*  p1 p2      t1 t2 */
2077       abs(p1->timestamp - t2) < thr*60
2078       /*  t1 t2      p1 p2 */
2079       ) {
2080     *nearby_tracks = g_list_prepend(*nearby_tracks, key);
2081   }
2082 }
2083
2084 /* comparison function used to sort tracks; a and b are hash table keys */
2085 static gint track_compare(gconstpointer a, gconstpointer b, gpointer user_data)
2086 {
2087   GHashTable *tracks = user_data;
2088   time_t t1, t2;
2089
2090   t1 = VIK_TRACKPOINT(VIK_TRACK(g_hash_table_lookup(tracks, a))->trackpoints->data)->timestamp;
2091   t2 = VIK_TRACKPOINT(VIK_TRACK(g_hash_table_lookup(tracks, b))->trackpoints->data)->timestamp;
2092
2093   if (t1 < t2) return -1;
2094   if (t1 > t2) return 1;
2095   return 0;
2096 }
2097
2098 /* comparison function used to sort trackpoints */
2099 static gint trackpoint_compare(gconstpointer a, gconstpointer b)
2100 {
2101   time_t t1 = VIK_TRACKPOINT(a)->timestamp, t2 = VIK_TRACKPOINT(b)->timestamp;
2102
2103   if (t1 < t2) return -1;
2104   if (t1 > t2) return 1;
2105   return 0;
2106 }
2107
2108 /* merge by time routine */
2109 static void trw_layer_merge_by_timestamp ( gpointer pass_along[6] )
2110 {
2111   time_t t1, t2;
2112   GList *nearby_tracks = NULL;
2113   VikTrack *track;
2114   GList *trps;
2115   static  guint thr = 1;
2116   guint track_count = 0;
2117   gchar *orig_track_name = strdup(pass_along[3]);
2118
2119   if (!a_dialog_time_threshold(VIK_GTK_WINDOW_FROM_LAYER(pass_along[0]),
2120                                "Merge Threshold...",
2121                                "Merge when time between trackpoints less than:",
2122                                &thr)) {
2123     return;
2124   }
2125
2126   /* merge tracks until we can't */
2127   do {
2128     gpointer params[3];
2129
2130     track = (VikTrack *) g_hash_table_lookup ( VIK_TRW_LAYER(pass_along[0])->tracks, orig_track_name );
2131     trps = track->trackpoints;
2132     if ( !trps )
2133       return;
2134
2135
2136     if (nearby_tracks) {
2137       g_list_free(nearby_tracks);
2138       nearby_tracks = NULL;
2139     }
2140
2141     t1 = ((VikTrackpoint *)trps->data)->timestamp;
2142     t2 = ((VikTrackpoint *)g_list_last(trps)->data)->timestamp;
2143
2144     /*    g_print("Original track times: %d and %d\n", t1, t2);  */
2145     params[0] = &nearby_tracks;
2146     params[1] = trps;
2147     params[2] = (gpointer)thr;
2148
2149     /* get a list of adjacent-in-time tracks */
2150     g_hash_table_foreach(VIK_TRW_LAYER(pass_along[0])->tracks, find_nearby_track, (gpointer)params);
2151
2152     /* add original track */
2153     nearby_tracks = g_list_prepend(nearby_tracks, orig_track_name);
2154
2155     /* sort by first trackpoint; assumes they don't overlap */
2156     nearby_tracks = g_list_sort_with_data(nearby_tracks, track_compare, VIK_TRW_LAYER(pass_along[0])->tracks);
2157
2158     /* merge them */
2159     {
2160 #define get_track(x) VIK_TRACK(g_hash_table_lookup(VIK_TRW_LAYER(pass_along[0])->tracks, (gchar *)((x)->data)))
2161 #define get_first_trackpoint(x) VIK_TRACKPOINT(get_track(x)->trackpoints->data)
2162 #define get_last_trackpoint(x) VIK_TRACKPOINT(g_list_last(get_track(x)->trackpoints)->data)
2163       GList *l = nearby_tracks;
2164       VikTrack *tr = vik_track_new();
2165       tr->visible = track->visible;
2166       track_count = 0;
2167       while (l) {
2168         /*
2169         time_t t1, t2;
2170         t1 = get_first_trackpoint(l)->timestamp;
2171         t2 = get_last_trackpoint(l)->timestamp;
2172         g_print("     %20s: track %d - %d\n", (char *)l->data, (int)t1, (int)t2);
2173         */
2174
2175
2176         /* remove trackpoints from merged track, delete track */
2177         tr->trackpoints = g_list_concat(tr->trackpoints, get_track(l)->trackpoints);
2178         get_track(l)->trackpoints = NULL;
2179         vik_trw_layer_delete_track(VIK_TRW_LAYER(pass_along[0]), l->data);
2180
2181         track_count ++;
2182         l = g_list_next(l);
2183       }
2184       tr->trackpoints = g_list_sort(tr->trackpoints, trackpoint_compare);
2185       vik_trw_layer_add_track(VIK_TRW_LAYER(pass_along[0]), strdup(orig_track_name), tr);
2186
2187 #undef get_first_trackpoint
2188 #undef get_last_trackpoint
2189 #undef get_track
2190     }
2191   } while (track_count > 1);
2192   g_list_free(nearby_tracks);
2193   free(orig_track_name);
2194   vik_layer_emit_update(VIK_LAYER(pass_along[0]));
2195 }
2196
2197 /* split by time routine */
2198 static void trw_layer_split_by_timestamp ( gpointer pass_along[6] )
2199 {
2200   VikTrack *track = (VikTrack *) g_hash_table_lookup ( VIK_TRW_LAYER(pass_along[0])->tracks, pass_along[3] );
2201   GList *trps = track->trackpoints;
2202   GList *iter;
2203   GList *newlists = NULL;
2204   GList *newtps = NULL;
2205   guint i;
2206   static guint thr = 1;
2207
2208   time_t ts, prev_ts;
2209
2210   if ( !trps )
2211     return;
2212
2213   if (!a_dialog_time_threshold(VIK_GTK_WINDOW_FROM_LAYER(pass_along[0]),
2214                                "Split Threshold...",
2215                                "Split when time between trackpoints exceeds:",
2216                                &thr)) {
2217     return;
2218   }
2219
2220   /* iterate through trackpoints, and copy them into new lists without touching original list */
2221   prev_ts = VIK_TRACKPOINT(trps->data)->timestamp;
2222   iter = trps;
2223
2224   while (iter) {
2225     ts = VIK_TRACKPOINT(iter->data)->timestamp;
2226     if (ts < prev_ts) {
2227       g_print("panic: ts < prev_ts: this should never happen!\n");
2228       return;
2229     }
2230     if (ts - prev_ts > thr*60) {
2231       /* flush accumulated trackpoints into new list */
2232       newlists = g_list_prepend(newlists, g_list_reverse(newtps));
2233       newtps = NULL;
2234     }
2235
2236     /* accumulate trackpoint copies in newtps, in reverse order */
2237     newtps = g_list_prepend(newtps, vik_trackpoint_copy(VIK_TRACKPOINT(iter->data)));
2238     prev_ts = ts;
2239     iter = g_list_next(iter);
2240   }
2241   if (newtps) {
2242       newlists = g_list_prepend(newlists, g_list_reverse(newtps));
2243   }
2244
2245   /* put lists of trackpoints into tracks */
2246   iter = newlists;
2247   i = 1;
2248   while (iter) {
2249     gchar *new_tr_name;
2250     VikTrack *tr;
2251
2252     tr = vik_track_new();
2253     tr->visible = track->visible;
2254     tr->trackpoints = (GList *)(iter->data);
2255
2256     new_tr_name = g_strdup_printf("%s #%d", (gchar *) pass_along[3], i++);
2257     vik_trw_layer_add_track(VIK_TRW_LAYER(pass_along[0]), new_tr_name, tr);
2258     /*    g_print("adding track %s, times %d - %d\n", new_tr_name, VIK_TRACKPOINT(tr->trackpoints->data)->timestamp,
2259           VIK_TRACKPOINT(g_list_last(tr->trackpoints)->data)->timestamp);*/
2260
2261     iter = g_list_next(iter);
2262   }
2263   g_list_free(newlists);
2264   vik_trw_layer_delete_track(VIK_TRW_LAYER(pass_along[0]), (gchar *)pass_along[3]);
2265   vik_layer_emit_update(VIK_LAYER(pass_along[0]));
2266 }
2267
2268 /* end of split/merge routines */
2269
2270
2271 static void trw_layer_goto_waypoint ( gpointer pass_along[5] )
2272 {
2273   VikWaypoint *wp = g_hash_table_lookup ( VIK_TRW_LAYER(pass_along[0])->waypoints, pass_along[3] );
2274   if ( wp )
2275     goto_coord ( VIK_LAYERS_PANEL(pass_along[1]), &(wp->coord) );
2276 }
2277
2278 static void trw_layer_waypoint_gc_webpage ( gpointer pass_along[5] )
2279 {
2280   gchar *webpage = g_strdup_printf("http://www.geocaching.com/seek/cache_details.aspx?wp=%s", (gchar *) pass_along[3] );
2281 #ifdef WINDOWS
2282   ShellExecute(NULL, NULL, (char *) webpage, NULL, ".\\", 0);
2283 #else /* WINDOWS */
2284   GError *err = NULL;
2285   gchar *cmd = g_strdup_printf ( "%s %s", UNIX_WEB_BROWSER, webpage );
2286   if ( ! g_spawn_command_line_async ( cmd, &err ) )
2287   {
2288     a_dialog_error_msg ( VIK_GTK_WINDOW_FROM_LAYER(VIK_LAYER(pass_along[0])), "Could not launch web browser." );
2289     g_error_free ( err );
2290   }
2291   g_free ( cmd );
2292 #endif /* WINDOWS */
2293   g_free ( webpage );
2294 }
2295
2296 const gchar *vik_trw_layer_sublayer_rename_request ( VikTrwLayer *l, const gchar *newname, gpointer vlp, gint subtype, gpointer sublayer, GtkTreeIter *iter )
2297 {
2298   if ( subtype == VIK_TRW_LAYER_SUBLAYER_WAYPOINT )
2299   {
2300     int i;
2301     gchar *rv;
2302     VikWaypoint *wp;
2303
2304     if ( strcasecmp ( newname, sublayer ) == 0 )
2305       return NULL;
2306
2307     if ( uppercase_exists_in_hash ( l->waypoints, newname ) )
2308     {
2309       a_dialog_error_msg ( VIK_GTK_WINDOW_FROM_LAYER(l), "Waypoint Already Exists" );
2310       return NULL;
2311     }
2312
2313     iter = g_hash_table_lookup ( l->waypoints_iters, sublayer );
2314     g_hash_table_steal ( l->waypoints_iters, sublayer );
2315
2316     wp = vik_waypoint_copy ( VIK_WAYPOINT(g_hash_table_lookup ( l->waypoints, sublayer )) );
2317     g_hash_table_remove ( l->waypoints, sublayer );
2318
2319     rv = g_strdup(newname);
2320     for ( i = strlen(rv) - 1; i >= 0; i-- )
2321       rv[i] = toupper(rv[i]);
2322
2323     vik_treeview_item_set_pointer ( VIK_LAYER(l)->vt, iter, rv );
2324
2325     g_hash_table_insert ( l->waypoints, rv, wp );
2326     g_hash_table_insert ( l->waypoints_iters, rv, iter );
2327
2328     /* it hasn't been updated yet so we pass new name */
2329 #ifdef VIK_CONFIG_ALPHABETIZED_TRW
2330     vik_treeview_sublayer_realphabetize ( VIK_LAYER(l)->vt, iter, rv );
2331 #endif
2332
2333     vik_layers_panel_emit_update ( VIK_LAYERS_PANEL(vlp) );
2334     return rv;
2335   }
2336   if ( subtype == VIK_TRW_LAYER_SUBLAYER_TRACK )
2337   {
2338     int i;
2339     gchar *rv;
2340     VikTrack *tr;
2341     GtkTreeIter *iter;
2342     gchar *orig_key;
2343
2344     if ( strcasecmp ( newname, sublayer ) == 0 )
2345       return NULL;
2346
2347     if ( uppercase_exists_in_hash ( l->tracks, newname ) )
2348     {
2349       a_dialog_error_msg ( VIK_GTK_WINDOW_FROM_LAYER(l), "Track Already Exists" );
2350       return NULL;
2351     }
2352
2353     g_hash_table_lookup_extended ( l->tracks, sublayer, (void *)&orig_key, (void *)&tr );
2354     g_hash_table_steal ( l->tracks, sublayer );
2355
2356     iter = g_hash_table_lookup ( l->tracks_iters, sublayer );
2357     g_hash_table_steal ( l->tracks_iters, sublayer );
2358
2359     rv = g_strdup(newname);
2360     for ( i = strlen(rv) - 1; i >= 0; i-- )
2361       rv[i] = toupper(rv[i]);
2362
2363     vik_treeview_item_set_pointer ( VIK_LAYER(l)->vt, iter, rv );
2364
2365     g_hash_table_insert ( l->tracks, rv, tr );
2366     g_hash_table_insert ( l->tracks_iters, rv, iter );
2367
2368     /* don't forget about current_tp_track_name, update that too */
2369     if ( l->current_tp_track_name && g_strcasecmp(orig_key,l->current_tp_track_name) == 0 )
2370     {
2371       l->current_tp_track_name = rv;
2372       if ( l->tpwin )
2373         vik_trw_layer_tpwin_set_track_name ( l->tpwin, rv );
2374     }
2375     else if ( l->last_tp_track_name && g_strcasecmp(orig_key,l->last_tp_track_name) == 0 )
2376       l->last_tp_track_name = rv;
2377
2378     g_free ( orig_key );
2379
2380 #ifdef VIK_CONFIG_ALPHABETIZED_TRW
2381     vik_treeview_sublayer_realphabetize ( VIK_LAYER(l)->vt, iter, rv );
2382 #endif
2383
2384     vik_layers_panel_emit_update ( VIK_LAYERS_PANEL(vlp) );
2385     return rv;
2386   }
2387   return NULL;
2388 }
2389
2390 static gboolean is_valid_geocache_name ( gchar *str )
2391 {
2392   gint len = strlen ( str );
2393   return len >= 3 && len <= 7 && str[0] == 'G' && str[1] == 'C' && isalnum(str[2]) && (len < 4 || isalnum(str[3])) && (len < 5 || isalnum(str[4])) && (len < 6 || isalnum(str[5])) && (len < 7 || isalnum(str[6]));
2394 }
2395
2396 static gboolean is_valid_google_route ( VikTrwLayer *vtl, const gchar *track_name )
2397 {
2398   VikTrack *tr = g_hash_table_lookup ( vtl->tracks, track_name );
2399   return ( tr && tr->comment && strlen(tr->comment) > 7 && !strncmp(tr->comment, "from:", 5) );
2400 }
2401
2402 static void trw_layer_track_google_route_webpage( gpointer *pass_along )
2403 {
2404   gchar *track_name = (gchar *) pass_along[3];
2405   VikTrack *tr = g_hash_table_lookup ( VIK_TRW_LAYER(pass_along[0])->tracks, track_name );
2406   if ( tr ) {
2407     gchar *escaped = uri_escape ( tr->comment );
2408     gchar *webpage = g_strdup_printf("http://maps.google.com/maps?f=q&hl=en&q=%s", escaped );
2409     GError *err = NULL;
2410     gchar *cmd = g_strdup_printf ( "%s %s", UNIX_WEB_BROWSER, webpage );
2411
2412     if ( ! g_spawn_command_line_async ( cmd, &err ) )
2413     {
2414       a_dialog_error_msg ( VIK_GTK_WINDOW_FROM_LAYER(VIK_LAYER(pass_along[0])), "Could not launch web browser." );
2415       g_error_free ( err );
2416     }
2417     g_free ( escaped );
2418     g_free ( cmd );
2419     g_free ( webpage );
2420   }
2421 }
2422
2423 /* vlp can be NULL if necessary - i.e. right-click from a tool -- but be careful, some functions may try to use it */
2424 gboolean vik_trw_layer_sublayer_add_menu_items ( VikTrwLayer *l, GtkMenu *menu, gpointer vlp, gint subtype, gpointer sublayer, GtkTreeIter *iter )
2425 {
2426   static GtkTreeIter staticiter;
2427   static gpointer pass_along[5];
2428   GtkWidget *item;
2429   gboolean rv = FALSE;
2430
2431   pass_along[0] = l;
2432   pass_along[1] = vlp;
2433   pass_along[2] = (gpointer) subtype;
2434   pass_along[3] = sublayer;
2435   staticiter = *iter; /* will exist after function has ended */
2436   pass_along[4] = &staticiter;
2437
2438   if ( subtype == VIK_TRW_LAYER_SUBLAYER_WAYPOINT || subtype == VIK_TRW_LAYER_SUBLAYER_TRACK )
2439   {
2440     rv = TRUE;
2441
2442     item = gtk_image_menu_item_new_from_stock ( GTK_STOCK_PROPERTIES, NULL );
2443     g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_properties_item), pass_along );
2444     gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
2445     gtk_widget_show ( item );
2446
2447     item = gtk_image_menu_item_new_from_stock ( GTK_STOCK_CUT, NULL );
2448     g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_cut_item_cb), pass_along );
2449     gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
2450     gtk_widget_show ( item );
2451
2452     item = gtk_image_menu_item_new_from_stock ( GTK_STOCK_COPY, NULL );
2453     g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_copy_item_cb), pass_along );
2454     gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
2455     gtk_widget_show ( item );
2456
2457     item = gtk_image_menu_item_new_from_stock ( GTK_STOCK_DELETE, NULL );
2458     g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_delete_item), pass_along );
2459     gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
2460     gtk_widget_show ( item );
2461
2462     if ( subtype == VIK_TRW_LAYER_SUBLAYER_WAYPOINT )
2463     {
2464       /* could be a right-click using the tool */
2465       if ( vlp != NULL ) {
2466         item = gtk_menu_item_new_with_label ( "Goto" );
2467         g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_goto_waypoint), pass_along );
2468         gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
2469         gtk_widget_show ( item );
2470       }
2471
2472       if ( is_valid_geocache_name ( (gchar *) sublayer ) )
2473       {
2474         item = gtk_menu_item_new_with_label ( "Visit Geocache Webpage" );
2475         g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_waypoint_gc_webpage), pass_along );
2476         gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
2477         gtk_widget_show ( item );
2478       }
2479
2480     }
2481   }
2482
2483   if ( subtype == VIK_TRW_LAYER_SUBLAYER_TRACK )
2484   {
2485     item = gtk_menu_item_new ();
2486     gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
2487     gtk_widget_show ( item );
2488
2489     item = gtk_menu_item_new_with_label ( "Goto Startpoint" );
2490     g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_goto_track_startpoint), pass_along );
2491     gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
2492     gtk_widget_show ( item );
2493
2494     item = gtk_menu_item_new_with_label ( "Goto \"Center\"" );
2495     g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_goto_track_center), pass_along );
2496     gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
2497     gtk_widget_show ( item );
2498
2499     item = gtk_menu_item_new_with_label ( "Goto Endpoint" );
2500     g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_goto_track_endpoint), pass_along );
2501     gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
2502     gtk_widget_show ( item );
2503
2504     item = gtk_menu_item_new_with_label ( "Merge By Time" );
2505     g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_merge_by_timestamp), pass_along );
2506     gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
2507     gtk_widget_show ( item );
2508
2509     item = gtk_menu_item_new_with_label ( "Split By Time" );
2510     g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_split_by_timestamp), pass_along );
2511     gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
2512     gtk_widget_show ( item );
2513
2514     item = gtk_menu_item_new_with_label ( "Download maps along track..." );
2515     g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_download_map_along_track_cb), pass_along );
2516     gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
2517     gtk_widget_show ( item );
2518
2519     item = gtk_menu_item_new_with_label ( "Apply DEM Data" );
2520     g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_apply_dem_data), pass_along );
2521     gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
2522     gtk_widget_show ( item );
2523
2524     item = gtk_menu_item_new_with_label ( "Extend track end" );
2525     g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_extend_track_end), pass_along );
2526     gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
2527     gtk_widget_show ( item );
2528
2529 #ifdef VIK_CONFIG_OPENSTREETMAP
2530     item = gtk_menu_item_new_with_label ( "Upload to OSM" );
2531     g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(osm_traces_upload_track_cb), pass_along );
2532     gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
2533     gtk_widget_show ( item );
2534 #endif
2535
2536     if ( is_valid_google_route ( l, (gchar *) sublayer ) )
2537     {
2538       item = gtk_menu_item_new_with_label ( "View Google Directions" );
2539       g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_track_google_route_webpage), pass_along );
2540       gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
2541       gtk_widget_show ( item );
2542     }
2543
2544   }
2545
2546   if ( vlp && (subtype == VIK_TRW_LAYER_SUBLAYER_WAYPOINTS || subtype == VIK_TRW_LAYER_SUBLAYER_WAYPOINT) )
2547   {
2548     item = gtk_menu_item_new ();
2549     gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
2550     gtk_widget_show ( item );
2551
2552     item = gtk_menu_item_new_with_label ( "New Waypoint" );
2553     g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_new_wp), pass_along );
2554     gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
2555     gtk_widget_show ( item );
2556   }
2557
2558   return rv;
2559 }
2560
2561
2562 /* to be called when last_tpl no long exists. */
2563 static void trw_layer_cancel_last_tp ( VikTrwLayer *vtl )
2564 {
2565   if ( vtl->tpwin ) /* can't join with a non-existant TP. */
2566     vik_trw_layer_tpwin_disable_join ( vtl->tpwin );
2567   vtl->last_tpl = NULL;
2568   vtl->last_tp_track_name = NULL;
2569 }
2570
2571 static void trw_layer_cancel_current_tp ( VikTrwLayer *vtl, gboolean destroy )
2572 {
2573   if ( vtl->tpwin )
2574   {
2575     if ( destroy)
2576     {
2577       gtk_widget_destroy ( GTK_WIDGET(vtl->tpwin) );
2578       vtl->tpwin = NULL;
2579     }
2580     else
2581       vik_trw_layer_tpwin_set_empty ( vtl->tpwin );
2582   }
2583   if ( vtl->current_tpl )
2584   {
2585     vtl->current_tpl = NULL;
2586     vtl->current_tp_track_name = NULL;
2587     vik_layer_emit_update(VIK_LAYER(vtl));
2588   }
2589 }
2590
2591 static void trw_layer_tpwin_response ( VikTrwLayer *vtl, gint response )
2592 {
2593   g_assert ( vtl->tpwin != NULL );
2594   if ( response == VIK_TRW_LAYER_TPWIN_CLOSE )
2595     trw_layer_cancel_current_tp ( vtl, TRUE );
2596   else if ( response == VIK_TRW_LAYER_TPWIN_SPLIT && vtl->current_tpl->next && vtl->current_tpl->prev )
2597   {
2598     gchar *name;
2599     if ( ( name = a_dialog_new_track ( GTK_WINDOW(vtl->tpwin), vtl->tracks ) ) )
2600     {
2601       VikTrack *tr = vik_track_new ();
2602       GList *newglist = g_list_alloc ();
2603       newglist->prev = NULL;
2604       newglist->next = vtl->current_tpl->next;
2605       newglist->data = vik_trackpoint_copy(VIK_TRACKPOINT(vtl->current_tpl->data));
2606       tr->trackpoints = newglist;
2607
2608       vtl->current_tpl->next->prev = newglist; /* end old track here */
2609       vtl->current_tpl->next = NULL;
2610
2611       vtl->current_tpl = newglist; /* change tp to first of new track. */
2612       vtl->current_tp_track_name = name;
2613
2614       vik_trw_layer_tpwin_set_tp ( vtl->tpwin, vtl->current_tpl, vtl->current_tp_track_name );
2615
2616       vik_trw_layer_add_track ( vtl, name, tr );
2617       vik_layer_emit_update(VIK_LAYER(vtl));
2618     }
2619   }
2620   else if ( response == VIK_TRW_LAYER_TPWIN_DELETE )
2621   {
2622     VikTrack *tr = g_hash_table_lookup ( vtl->tracks, vtl->current_tp_track_name );
2623     GList *new_tpl;
2624     g_assert(tr != NULL);
2625
2626     /* can't join with a non-existent trackpoint */
2627     vtl->last_tpl = NULL;
2628     vtl->last_tp_track_name = NULL;
2629
2630     if ( (new_tpl = vtl->current_tpl->next) || (new_tpl = vtl->current_tpl->prev) )
2631     {
2632       if ( VIK_TRACKPOINT(vtl->current_tpl->data)->newsegment && vtl->current_tpl->next )
2633         VIK_TRACKPOINT(vtl->current_tpl->next->data)->newsegment = TRUE; /* don't concat segments on del */
2634
2635       tr->trackpoints = g_list_remove_link ( tr->trackpoints, vtl->current_tpl ); /* this nulls current_tpl->prev and next */
2636
2637       /* at this point the old trackpoint exists, but the list links are correct (new), so it is safe to do this. */
2638       vik_trw_layer_tpwin_set_tp ( vtl->tpwin, new_tpl, vtl->current_tp_track_name );
2639
2640       trw_layer_cancel_last_tp ( vtl );
2641
2642       g_free ( vtl->current_tpl->data ); /* TODO: vik_trackpoint_free() */
2643       g_list_free_1 ( vtl->current_tpl );
2644       vtl->current_tpl = new_tpl;
2645       vik_layer_emit_update(VIK_LAYER(vtl));
2646     }
2647     else
2648     {
2649       tr->trackpoints = g_list_remove_link ( tr->trackpoints, vtl->current_tpl );
2650       g_free ( vtl->current_tpl->data ); /* TODO longone: vik_trackpoint_new() and vik_trackpoint_free() */
2651       g_list_free_1 ( vtl->current_tpl );
2652       trw_layer_cancel_current_tp ( vtl, FALSE );
2653     }
2654   }
2655   else if ( response == VIK_TRW_LAYER_TPWIN_FORWARD && vtl->current_tpl->next )
2656   {
2657     vtl->last_tpl = vtl->current_tpl;
2658     vik_trw_layer_tpwin_set_tp ( vtl->tpwin, vtl->current_tpl = vtl->current_tpl->next, vtl->current_tp_track_name );
2659     vik_layer_emit_update(VIK_LAYER(vtl)); /* TODO longone: either move or only update if tp is inside drawing window */
2660   }
2661   else if ( response == VIK_TRW_LAYER_TPWIN_BACK && vtl->current_tpl->prev )
2662   {
2663     vtl->last_tpl = vtl->current_tpl;
2664     vik_trw_layer_tpwin_set_tp ( vtl->tpwin, vtl->current_tpl = vtl->current_tpl->prev, vtl->current_tp_track_name );
2665     vik_layer_emit_update(VIK_LAYER(vtl));
2666   }
2667   else if ( response == VIK_TRW_LAYER_TPWIN_JOIN )
2668   {
2669     VikTrack *tr1 = g_hash_table_lookup ( vtl->tracks, vtl->last_tp_track_name );
2670     VikTrack *tr2 = g_hash_table_lookup ( vtl->tracks, vtl->current_tp_track_name );
2671
2672     VikTrack *tr_first = tr1, *tr_last = tr2;
2673
2674     gchar *tmp;
2675
2676     if ( (!vtl->last_tpl->next) && (!vtl->current_tpl->next) ) /* both endpoints */
2677       vik_track_reverse ( tr2 ); /* reverse the second, that way second track clicked will be later. */
2678     else if ( (!vtl->last_tpl->prev) && (!vtl->current_tpl->prev) )
2679       vik_track_reverse ( tr1 );
2680     else if ( (!vtl->last_tpl->prev) && (!vtl->current_tpl->next) ) /* clicked startpoint, then endpoint -- concat end to start */
2681     {
2682       tr_first = tr2;
2683       tr_last = tr1;
2684     }
2685     /* default -- clicked endpoint then startpoint -- connect endpoint to startpoint */
2686
2687     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. */
2688       VIK_TRACKPOINT(tr_last->trackpoints->data)->newsegment = FALSE;
2689     tr1->trackpoints = g_list_concat ( tr_first->trackpoints, tr_last->trackpoints );
2690     tr2->trackpoints = NULL;
2691
2692     tmp = vtl->current_tp_track_name;
2693
2694     vtl->current_tp_track_name = vtl->last_tp_track_name; /* current_tp stays the same (believe it or not!) */
2695     vik_trw_layer_tpwin_set_tp ( vtl->tpwin, vtl->current_tpl, vtl->current_tp_track_name );
2696
2697     /* if we did this before, trw_layer_delete_track would have canceled the current tp because
2698      * it was the current track. canceling the current tp would have set vtl->current_tpl to NULL */
2699     vik_trw_layer_delete_track ( vtl, tmp );
2700
2701     trw_layer_cancel_last_tp ( vtl ); /* same TP, can't join. */
2702     vik_layer_emit_update(VIK_LAYER(vtl));
2703   }
2704   else if ( response == VIK_TRW_LAYER_TPWIN_DATA_CHANGED )
2705     vik_layer_emit_update (VIK_LAYER(vtl));
2706 }
2707
2708 static void trw_layer_tpwin_init ( VikTrwLayer *vtl )
2709 {
2710   if ( ! vtl->tpwin )
2711   {
2712     vtl->tpwin = vik_trw_layer_tpwin_new ( VIK_GTK_WINDOW_FROM_LAYER(vtl) );
2713     g_signal_connect_swapped ( GTK_DIALOG(vtl->tpwin), "response", G_CALLBACK(trw_layer_tpwin_response), vtl );
2714     /* connect signals -- DELETE SIGNAL VERY IMPORTANT TO SET TO NULL */
2715     g_signal_connect_swapped ( vtl->tpwin, "delete-event", G_CALLBACK(trw_layer_cancel_current_tp), vtl );
2716     gtk_widget_show_all ( GTK_WIDGET(vtl->tpwin) );
2717   }
2718   if ( vtl->current_tpl )
2719     vik_trw_layer_tpwin_set_tp ( vtl->tpwin, vtl->current_tpl, vtl->current_tp_track_name );
2720   /* set layer name and TP data */
2721 }
2722
2723 /***************************************************************************
2724  ** Tool code
2725  ***************************************************************************/
2726
2727 /*** Utility data structures and functions ****/
2728
2729 typedef struct {
2730   gint x, y;
2731   gint closest_x, closest_y;
2732   gchar *closest_wp_name;
2733   VikWaypoint *closest_wp;
2734   VikViewport *vvp;
2735 } WPSearchParams;
2736
2737 typedef struct {
2738   gint x, y;
2739   gint closest_x, closest_y;
2740   gchar *closest_track_name;
2741   VikTrackpoint *closest_tp;
2742   VikViewport *vvp;
2743   GList *closest_tpl;
2744 } TPSearchParams;
2745
2746 static void waypoint_search_closest_tp ( gchar *name, VikWaypoint *wp, WPSearchParams *params )
2747 {
2748   gint x, y;
2749   if ( !wp->visible )
2750     return;
2751
2752   vik_viewport_coord_to_screen ( params->vvp, &(wp->coord), &x, &y );
2753
2754   if ( abs (x - params->x) <= WAYPOINT_SIZE_APPROX && abs (y - params->y) <= WAYPOINT_SIZE_APPROX &&
2755       ((!params->closest_wp) ||        /* was the old waypoint we already found closer than this one? */
2756         abs(x - params->x)+abs(y - params->y) < abs(x - params->closest_x)+abs(y - params->closest_y)))
2757   {
2758     params->closest_wp_name = name;
2759     params->closest_wp = wp;
2760     params->closest_x = x;
2761     params->closest_y = y;
2762   }
2763 }
2764
2765 static void track_search_closest_tp ( gchar *name, VikTrack *t, TPSearchParams *params )
2766 {
2767   GList *tpl = t->trackpoints;
2768   VikTrackpoint *tp;
2769
2770   if ( !t->visible )
2771     return;
2772
2773   while (tpl)
2774   {
2775     gint x, y;
2776     tp = VIK_TRACKPOINT(tpl->data);
2777
2778     vik_viewport_coord_to_screen ( params->vvp, &(tp->coord), &x, &y );
2779
2780     if ( abs (x - params->x) <= TRACKPOINT_SIZE_APPROX && abs (y - params->y) <= TRACKPOINT_SIZE_APPROX &&
2781         ((!params->closest_tp) ||        /* was the old trackpoint we already found closer than this one? */
2782           abs(x - params->x)+abs(y - params->y) < abs(x - params->closest_x)+abs(y - params->closest_y)))
2783     {
2784       params->closest_track_name = name;
2785       params->closest_tp = tp;
2786       params->closest_tpl = tpl;
2787       params->closest_x = x;
2788       params->closest_y = y;
2789     }
2790     tpl = tpl->next;
2791   }
2792 }
2793
2794 static VikTrackpoint *closest_tp_in_five_pixel_interval ( VikTrwLayer *vtl, VikViewport *vvp, gint x, gint y )
2795 {
2796   TPSearchParams params;
2797   params.x = x;
2798   params.y = y;
2799   params.vvp = vvp;
2800   params.closest_track_name = NULL;
2801   params.closest_tp = NULL;
2802   g_hash_table_foreach ( vtl->tracks, (GHFunc) track_search_closest_tp, &params);
2803   return params.closest_tp;
2804 }
2805
2806 static VikWaypoint *closest_wp_in_five_pixel_interval ( VikTrwLayer *vtl, VikViewport *vvp, gint x, gint y )
2807 {
2808   WPSearchParams params;
2809   params.x = x;
2810   params.y = y;
2811   params.vvp = vvp;
2812   params.closest_wp = NULL;
2813   params.closest_wp_name = NULL;
2814   g_hash_table_foreach ( vtl->waypoints, (GHFunc) waypoint_search_closest_tp, &params);
2815   return params.closest_wp;
2816 }
2817
2818 /* background drawing hook, to be passed the viewport */
2819 static gboolean tool_sync_done = TRUE;
2820
2821 static gboolean tool_sync(gpointer data)
2822 {
2823   VikViewport *vvp = data;
2824   gdk_threads_enter();
2825   vik_viewport_sync(vvp);
2826   tool_sync_done = TRUE;
2827   gdk_threads_leave();
2828   return FALSE;
2829 }
2830
2831 typedef struct {
2832   VikViewport *vvp;
2833   gboolean holding;
2834   GdkGC *gc;
2835   int oldx, oldy;
2836 } tool_ed_t;
2837
2838 static void marker_begin_move ( tool_ed_t *t, gint x, gint y )
2839 {
2840   t->holding = TRUE;
2841   t->gc = vik_viewport_new_gc (t->vvp, "black", 2);
2842   gdk_gc_set_function ( t->gc, GDK_INVERT );
2843   vik_viewport_draw_rectangle ( t->vvp, t->gc, FALSE, x-3, y-3, 6, 6 );
2844   vik_viewport_sync(t->vvp);
2845   t->oldx = x;
2846   t->oldy = y;
2847 }
2848
2849 static void marker_moveto ( tool_ed_t *t, gint x, gint y )
2850 {
2851   VikViewport *vvp =  t->vvp;
2852   vik_viewport_draw_rectangle ( vvp, t->gc, FALSE, t->oldx-3, t->oldy-3, 6, 6 );
2853   vik_viewport_draw_rectangle ( vvp, t->gc, FALSE, x-3, y-3, 6, 6 );
2854   t->oldx = x;
2855   t->oldy = y;
2856
2857   if (tool_sync_done) {
2858     g_idle_add_full (G_PRIORITY_HIGH_IDLE + 10, tool_sync, vvp, NULL);
2859     tool_sync_done = FALSE;
2860   }
2861 }
2862
2863 static void marker_end_move ( tool_ed_t *t )
2864 {
2865   vik_viewport_draw_rectangle ( t->vvp, t->gc, FALSE, t->oldx-3, t->oldy-3, 6, 6 );
2866   g_object_unref ( t->gc );
2867   t->holding = FALSE;
2868 }
2869
2870 /*** Edit waypoint ****/
2871
2872 static gpointer tool_edit_waypoint_create ( VikWindow *vw, VikViewport *vvp)
2873 {
2874   tool_ed_t *t = g_new(tool_ed_t, 1);
2875   t->vvp = vvp;
2876   t->holding = FALSE;
2877   return t;
2878 }
2879
2880 static gboolean tool_edit_waypoint_click ( VikTrwLayer *vtl, GdkEventButton *event, gpointer data )
2881 {
2882   WPSearchParams params;
2883   tool_ed_t *t = data;
2884   VikViewport *vvp = t->vvp;
2885
2886   if (!vtl || vtl->vl.type != VIK_LAYER_TRW)
2887     return FALSE;
2888
2889   if ( t->holding ) {
2890     return TRUE;
2891   }
2892
2893   if ( vtl->current_wp && vtl->current_wp->visible )
2894   {
2895     /* first check if current WP is within area (other may be 'closer', but we want to move the current) */
2896     gint x, y;
2897     vik_viewport_coord_to_screen ( vvp, &(vtl->current_wp->coord), &x, &y );
2898
2899     if ( abs(x - event->x) <= WAYPOINT_SIZE_APPROX &&
2900          abs(y - event->y) <= WAYPOINT_SIZE_APPROX )
2901     {
2902       if ( event->button == 3 )
2903         vtl->waypoint_rightclick = TRUE; /* remember that we're clicking; other layers will ignore release signal */
2904       else {
2905         marker_begin_move(t, event->x, event->y);
2906       }
2907       return TRUE;
2908     }
2909   }
2910
2911   params.vvp = vvp;
2912   params.x = event->x;
2913   params.y = event->y;
2914   params.closest_wp_name = NULL;
2915   /* TODO: should get track listitem so we can break it up, make a new track, mess it up, all that. */
2916   params.closest_wp = NULL;
2917   g_hash_table_foreach ( vtl->waypoints, (GHFunc) waypoint_search_closest_tp, &params);
2918   if ( vtl->current_wp == params.closest_wp && vtl->current_wp != NULL )
2919   {
2920     /* how do we get here? I'm putting in the abort until we can figure it out. -alex */
2921     marker_begin_move(t, event->x, event->y);
2922     g_critical("shouldn't be here");
2923     exit(1);
2924   }
2925   else if ( params.closest_wp )
2926   {
2927     if ( event->button == 3 )
2928       vtl->waypoint_rightclick = TRUE; /* remember that we're clicking; other layers will ignore release signal */
2929     else
2930       vtl->waypoint_rightclick = FALSE;
2931
2932     vtl->current_wp = params.closest_wp;
2933     vtl->current_wp_name = params.closest_wp_name;
2934
2935     if ( params.closest_wp )
2936       vik_treeview_select_iter ( VIK_LAYER(vtl)->vt, g_hash_table_lookup ( vtl->waypoints_iters, vtl->current_wp_name ) );
2937
2938     /* could make it so don't update if old WP is off screen and new is null but oh well */
2939     vik_layer_emit_update ( VIK_LAYER(vtl) );
2940     return TRUE;
2941   }
2942
2943   vtl->current_wp = NULL;
2944   vtl->current_wp_name = NULL;
2945   vtl->waypoint_rightclick = FALSE;
2946   vik_layer_emit_update ( VIK_LAYER(vtl) );
2947   return FALSE;
2948 }
2949
2950 static gboolean tool_edit_waypoint_move ( VikTrwLayer *vtl, GdkEventButton *event, gpointer data )
2951 {
2952   tool_ed_t *t = data;
2953   VikViewport *vvp = t->vvp;
2954
2955   if (!vtl || vtl->vl.type != VIK_LAYER_TRW)
2956     return FALSE;
2957
2958   if ( t->holding ) {
2959     VikCoord new_coord;
2960     vik_viewport_screen_to_coord ( vvp, event->x, event->y, &new_coord );
2961
2962     /* snap to TP */
2963     if ( event->state & GDK_CONTROL_MASK )
2964     {
2965       VikTrackpoint *tp = closest_tp_in_five_pixel_interval ( vtl, vvp, event->x, event->y );
2966       if ( tp )
2967         new_coord = tp->coord;
2968     }
2969
2970     /* snap to WP */
2971     if ( event->state & GDK_SHIFT_MASK )
2972     {
2973       VikWaypoint *wp = closest_wp_in_five_pixel_interval ( vtl, vvp, event->x, event->y );
2974       if ( wp && wp != vtl->current_wp )
2975         new_coord = wp->coord;
2976     }
2977
2978     {
2979       gint x, y;
2980       vik_viewport_coord_to_screen ( vvp, &new_coord, &x, &y );
2981
2982       marker_moveto ( t, x, y );
2983     }
2984     return TRUE;
2985   }
2986   return FALSE;
2987 }
2988
2989 static gboolean tool_edit_waypoint_release ( VikTrwLayer *vtl, GdkEventButton *event, gpointer data )
2990 {
2991   tool_ed_t *t = data;
2992   VikViewport *vvp = t->vvp;
2993
2994   if (!vtl || vtl->vl.type != VIK_LAYER_TRW)
2995     return FALSE;
2996
2997   if ( t->holding && event->button == 1 )
2998   {
2999     VikCoord new_coord;
3000     vik_viewport_screen_to_coord ( vvp, event->x, event->y, &new_coord );
3001
3002     /* snap to TP */
3003     if ( event->state & GDK_CONTROL_MASK )
3004     {
3005       VikTrackpoint *tp = closest_tp_in_five_pixel_interval ( vtl, vvp, event->x, event->y );
3006       if ( tp )
3007         new_coord = tp->coord;
3008     }
3009
3010     /* snap to WP */
3011     if ( event->state & GDK_SHIFT_MASK )
3012     {
3013       VikWaypoint *wp = closest_wp_in_five_pixel_interval ( vtl, vvp, event->x, event->y );
3014       if ( wp && wp != vtl->current_wp )
3015         new_coord = wp->coord;
3016     }
3017
3018     marker_end_move ( t );
3019
3020     vtl->current_wp->coord = new_coord;
3021     vik_layer_emit_update ( VIK_LAYER(vtl) );
3022     return TRUE;
3023   }
3024   /* PUT IN RIGHT PLACE!!! */
3025   if ( event->button == 3 && vtl->waypoint_rightclick )
3026   {
3027     if ( vtl->wp_right_click_menu )
3028       gtk_object_sink ( GTK_OBJECT(vtl->wp_right_click_menu) );
3029     vtl->wp_right_click_menu = GTK_MENU ( gtk_menu_new () );
3030     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  ) );
3031     gtk_menu_popup ( vtl->wp_right_click_menu, NULL, NULL, NULL, NULL, event->button, gtk_get_current_event_time() );
3032     vtl->waypoint_rightclick = FALSE;
3033   }
3034   return FALSE;
3035 }
3036
3037 /**** Begin track ***/
3038 static gpointer tool_begin_track_create ( VikWindow *vw, VikViewport *vvp)
3039 {
3040   return vvp;
3041 }
3042
3043 static gboolean tool_begin_track_click ( VikTrwLayer *vtl, GdkEventButton *event, VikViewport *vvp )
3044 {
3045   vtl->current_track = NULL;
3046   return tool_new_track_click ( vtl, event, vvp );
3047 }
3048
3049 /*** New track ****/
3050
3051 static gpointer tool_new_track_create ( VikWindow *vw, VikViewport *vvp)
3052 {
3053   return vvp;
3054 }
3055
3056 typedef struct {
3057   VikTrwLayer *vtl;
3058   VikViewport *vvp;
3059   gint x1,y1,x2,y2;
3060 } new_track_move_passalong_t;
3061
3062 /* sync and undraw, but only when we have time */
3063 static gboolean ct_sync ( gpointer passalong )
3064 {
3065   new_track_move_passalong_t *p = (new_track_move_passalong_t *) passalong;
3066   vik_viewport_sync ( p->vvp );
3067   gdk_gc_set_function ( p->vtl->current_track_gc, GDK_INVERT );
3068   vik_viewport_draw_line ( p->vvp, p->vtl->current_track_gc, p->x1, p->y1, p->x2, p->y2 );
3069   gdk_gc_set_function ( p->vtl->current_track_gc, GDK_COPY );
3070   p->vtl->ct_sync_done = TRUE;
3071   g_free ( p );
3072   return FALSE;
3073 }
3074
3075 static VikLayerToolFuncStatus tool_new_track_move ( VikTrwLayer *vtl, GdkEventButton *event, VikViewport *vvp )
3076 {
3077   /* if we haven't sync'ed yet, we don't have time to do more. */
3078   if ( vtl->ct_sync_done && vtl->current_track && vtl->current_track->trackpoints ) {
3079     GList *iter = vtl->current_track->trackpoints;
3080     new_track_move_passalong_t *passalong;
3081     gint x1, y1;
3082
3083     while ( iter->next )
3084       iter = iter->next;
3085     gdk_gc_set_function ( vtl->current_track_gc, GDK_INVERT );
3086     vik_viewport_coord_to_screen ( vvp, &(VIK_TRACKPOINT(iter->data)->coord), &x1, &y1 );
3087     vik_viewport_draw_line ( vvp, vtl->current_track_gc, x1, y1, event->x, event->y );
3088     gdk_gc_set_function ( vtl->current_track_gc, GDK_COPY );
3089
3090     passalong = g_new(new_track_move_passalong_t,1); /* freed by sync */
3091     passalong->vtl = vtl;
3092     passalong->vvp = vvp;
3093     passalong->x1 = x1;
3094     passalong->y1 = y1;
3095     passalong->x2 = event->x;
3096     passalong->y2 = event->y;
3097
3098     /* this will sync and undraw when we have time to */
3099     g_idle_add_full (G_PRIORITY_HIGH_IDLE + 10, ct_sync, passalong, NULL);
3100     vtl->ct_sync_done = FALSE;
3101     return VIK_LAYER_TOOL_ACK_GRAB_FOCUS;
3102   }
3103   return VIK_LAYER_TOOL_ACK;
3104 }
3105
3106 static gboolean tool_new_track_key_press ( VikTrwLayer *vtl, GdkEventKey *event, VikViewport *vvp )
3107 {
3108   if ( vtl->current_track && event->keyval == GDK_Escape ) {
3109     vtl->current_track = NULL;
3110     vik_layer_emit_update ( VIK_LAYER(vtl) );
3111     return TRUE;
3112   } else if ( vtl->current_track && event->keyval == GDK_BackSpace ) {
3113     /* undo */
3114     if ( vtl->current_track->trackpoints )
3115     {
3116       GList *last = g_list_last(vtl->current_track->trackpoints);
3117       g_free ( last->data );
3118       vtl->current_track->trackpoints = g_list_remove_link ( vtl->current_track->trackpoints, last );
3119     }
3120     vik_layer_emit_update ( VIK_LAYER(vtl) );
3121     return TRUE;
3122   }
3123   return FALSE;
3124 }
3125
3126 static gboolean tool_new_track_click ( VikTrwLayer *vtl, GdkEventButton *event, VikViewport *vvp )
3127 {
3128   VikTrackpoint *tp;
3129
3130   if (!vtl || vtl->vl.type != VIK_LAYER_TRW)
3131     return FALSE;
3132
3133   if ( event->button == 3 && vtl->current_track )
3134   {
3135     /* undo */
3136     if ( vtl->current_track->trackpoints )
3137     {
3138       GList *last = g_list_last(vtl->current_track->trackpoints);
3139       g_free ( last->data );
3140       vtl->current_track->trackpoints = g_list_remove_link ( vtl->current_track->trackpoints, last );
3141     }
3142     vik_layer_emit_update ( VIK_LAYER(vtl) );
3143     return TRUE;
3144   }
3145
3146   if ( event->type == GDK_2BUTTON_PRESS )
3147   {
3148     /* subtract last (duplicate from double click) tp then end */
3149     if ( vtl->current_track && vtl->current_track->trackpoints && vtl->ct_x1 == vtl->ct_x2 && vtl->ct_y1 == vtl->ct_y2 )
3150     {
3151       GList *last = g_list_last(vtl->current_track->trackpoints);
3152       g_free ( last->data );
3153       vtl->current_track->trackpoints = g_list_remove_link ( vtl->current_track->trackpoints, last );
3154       /* undo last, then end */
3155       vtl->current_track = NULL;
3156     }
3157     vik_layer_emit_update ( VIK_LAYER(vtl) );
3158     return TRUE;
3159   }
3160
3161   if ( ! vtl->current_track )
3162   {
3163     gchar *name;
3164     if ( ( name = a_dialog_new_track ( VIK_GTK_WINDOW_FROM_LAYER(vtl), vtl->tracks ) ) )
3165     {
3166       vtl->current_track = vik_track_new();
3167       vtl->current_track->visible = TRUE;
3168       vik_trw_layer_add_track ( vtl, name, vtl->current_track );
3169
3170       /* incase it was created by begin track */
3171       vik_window_enable_layer_tool ( VIK_WINDOW(VIK_GTK_WINDOW_FROM_LAYER(vtl)), VIK_LAYER_TRW, TOOL_CREATE_TRACK );
3172     }
3173     else
3174       return TRUE;
3175   }
3176   tp = vik_trackpoint_new();
3177   vik_viewport_screen_to_coord ( vvp, event->x, event->y, &(tp->coord) );
3178
3179   /* snap to other TP */
3180   if ( event->state & GDK_CONTROL_MASK )
3181   {
3182     VikTrackpoint *other_tp = closest_tp_in_five_pixel_interval ( vtl, vvp, event->x, event->y );
3183     if ( other_tp )
3184       tp->coord = other_tp->coord;
3185   }
3186
3187   tp->newsegment = FALSE;
3188   tp->has_timestamp = FALSE;
3189   tp->timestamp = 0;
3190   tp->altitude = VIK_DEFAULT_ALTITUDE;
3191   vtl->current_track->trackpoints = g_list_append ( vtl->current_track->trackpoints, tp );
3192
3193   vtl->ct_x1 = vtl->ct_x2;
3194   vtl->ct_y1 = vtl->ct_y2;
3195   vtl->ct_x2 = event->x;
3196   vtl->ct_y2 = event->y;
3197
3198   vik_layer_emit_update ( VIK_LAYER(vtl) );
3199   return TRUE;
3200 }
3201
3202
3203 /*** New waypoint ****/
3204
3205 static gpointer tool_new_waypoint_create ( VikWindow *vw, VikViewport *vvp)
3206 {
3207   return vvp;
3208 }
3209
3210 static gboolean tool_new_waypoint_click ( VikTrwLayer *vtl, GdkEventButton *event, VikViewport *vvp )
3211 {
3212   VikCoord coord;
3213   if (!vtl || vtl->vl.type != VIK_LAYER_TRW)
3214     return FALSE;
3215   vik_viewport_screen_to_coord ( vvp, event->x, event->y, &coord );
3216   if (vik_trw_layer_new_waypoint ( vtl, VIK_GTK_WINDOW_FROM_LAYER(vtl), &coord ) && VIK_LAYER(vtl)->visible)
3217     vik_layer_emit_update ( VIK_LAYER(vtl) );
3218   return TRUE;
3219 }
3220
3221
3222 /*** Edit trackpoint ****/
3223
3224 static gpointer tool_edit_trackpoint_create ( VikWindow *vw, VikViewport *vvp)
3225 {
3226   tool_ed_t *t = g_new(tool_ed_t, 1);
3227   t->vvp = vvp;
3228   t->holding = FALSE;
3229   return t;
3230 }
3231
3232 static gboolean tool_edit_trackpoint_click ( VikTrwLayer *vtl, GdkEventButton *event, gpointer data )
3233 {
3234   tool_ed_t *t = data;
3235   VikViewport *vvp = t->vvp;
3236   TPSearchParams params;
3237   /* OUTDATED DOCUMENTATION:
3238    find 5 pixel range on each side. then put these UTM, and a pointer
3239    to the winning track name (and maybe the winning track itself), and a
3240    pointer to the winning trackpoint, inside an array or struct. pass
3241    this along, do a foreach on the tracks which will do a foreach on the
3242    trackpoints. */
3243   params.vvp = vvp;
3244   params.x = event->x;
3245   params.y = event->y;
3246   params.closest_track_name = NULL;
3247   /* TODO: should get track listitem so we can break it up, make a new track, mess it up, all that. */
3248   params.closest_tp = NULL;
3249
3250   if ( event->button != 1 )
3251     return FALSE;
3252
3253   if (!vtl || vtl->vl.type != VIK_LAYER_TRW)
3254     return FALSE;
3255
3256   if ( vtl->current_tpl )
3257   {
3258     /* 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.) */
3259     VikTrackpoint *tp = VIK_TRACKPOINT(vtl->current_tpl->data);
3260     VikTrack *current_tr = VIK_TRACK(g_hash_table_lookup(vtl->tracks, vtl->current_tp_track_name));
3261     gint x, y;
3262     g_assert ( current_tr );
3263
3264     vik_viewport_coord_to_screen ( vvp, &(tp->coord), &x, &y );
3265
3266     if ( current_tr->visible &&
3267          abs(x - event->x) < TRACKPOINT_SIZE_APPROX &&
3268          abs(y - event->y) < TRACKPOINT_SIZE_APPROX ) {
3269       marker_begin_move ( t, event->x, event->y );
3270       return TRUE;
3271     }
3272
3273     vtl->last_tpl = vtl->current_tpl;
3274     vtl->last_tp_track_name = vtl->current_tp_track_name;
3275   }
3276
3277   g_hash_table_foreach ( vtl->tracks, (GHFunc) track_search_closest_tp, &params);
3278
3279   if ( params.closest_tp )
3280   {
3281     vtl->current_tpl = params.closest_tpl;
3282     vtl->current_tp_track_name = params.closest_track_name;
3283     vik_treeview_select_iter ( VIK_LAYER(vtl)->vt, g_hash_table_lookup ( vtl->tracks_iters, vtl->current_tp_track_name ) );
3284     trw_layer_tpwin_init ( vtl );
3285     vik_layer_emit_update ( VIK_LAYER(vtl) );
3286     return TRUE;
3287   }
3288
3289   /* these aren't the droids you're looking for */
3290   return FALSE;
3291 }
3292
3293 static gboolean tool_edit_trackpoint_move ( VikTrwLayer *vtl, GdkEventButton *event, gpointer data )
3294 {
3295   tool_ed_t *t = data;
3296   VikViewport *vvp = t->vvp;
3297
3298   if (!vtl || vtl->vl.type != VIK_LAYER_TRW)
3299     return FALSE;
3300
3301   if ( t->holding )
3302   {
3303     VikCoord new_coord;
3304     vik_viewport_screen_to_coord ( vvp, event->x, event->y, &new_coord );
3305
3306     /* snap to TP */
3307     if ( event->state & GDK_CONTROL_MASK )
3308     {
3309       VikTrackpoint *tp = closest_tp_in_five_pixel_interval ( vtl, vvp, event->x, event->y );
3310       if ( tp && tp != vtl->current_tpl->data )
3311         new_coord = tp->coord;
3312     }
3313     //    VIK_TRACKPOINT(vtl->current_tpl->data)->coord = new_coord;
3314     {
3315       gint x, y;
3316       vik_viewport_coord_to_screen ( vvp, &new_coord, &x, &y );
3317       marker_moveto ( t, x, y );
3318     }
3319
3320     return TRUE;
3321   }
3322   return FALSE;
3323 }
3324
3325 static gboolean tool_edit_trackpoint_release ( VikTrwLayer *vtl, GdkEventButton *event, gpointer data )
3326 {
3327   tool_ed_t *t = data;
3328   VikViewport *vvp = t->vvp;
3329
3330   if (!vtl || vtl->vl.type != VIK_LAYER_TRW)
3331     return FALSE;
3332   if ( event->button != 1)
3333     return FALSE;
3334
3335   if ( t->holding ) {
3336     VikCoord new_coord;
3337     vik_viewport_screen_to_coord ( vvp, event->x, event->y, &new_coord );
3338
3339     /* snap to TP */
3340     if ( event->state & GDK_CONTROL_MASK )
3341     {
3342       VikTrackpoint *tp = closest_tp_in_five_pixel_interval ( vtl, vvp, event->x, event->y );
3343       if ( tp && tp != vtl->current_tpl->data )
3344         new_coord = tp->coord;
3345     }
3346
3347     VIK_TRACKPOINT(vtl->current_tpl->data)->coord = new_coord;
3348
3349     marker_end_move ( t );
3350
3351     /* diff dist is diff from orig */
3352     vik_trw_layer_tpwin_set_tp ( vtl->tpwin, vtl->current_tpl, vtl->current_tp_track_name );
3353     /* can't join with itself! */
3354     trw_layer_cancel_last_tp ( vtl );
3355
3356     vik_layer_emit_update ( VIK_LAYER(vtl) );
3357     return TRUE;
3358   }
3359   return FALSE;
3360 }
3361
3362
3363 /*** Magic Scissors ***/
3364 static gpointer tool_magic_scissors_create ( VikWindow *vw, VikViewport *vvp)
3365 {
3366   return vvp;
3367 }
3368
3369 static gboolean tool_magic_scissors_click ( VikTrwLayer *vtl, GdkEventButton *event, VikViewport *vvp )
3370 {
3371   VikCoord tmp;
3372   if ( !vtl ) return FALSE;
3373   vik_viewport_screen_to_coord ( vvp, event->x, event->y, &tmp );
3374   if ( event->button == 3 && vtl->magic_scissors_current_track ) {
3375     VikCoord *new_end;
3376     new_end = vik_track_cut_back_to_double_point ( vtl->magic_scissors_current_track );
3377     if ( new_end ) {
3378       vtl->magic_scissors_coord = *new_end;
3379       g_free ( new_end );
3380       vik_layer_emit_update ( VIK_LAYER(vtl) );
3381       /* remove last ' to:...' */
3382       if ( vtl->magic_scissors_current_track->comment ) {
3383         gchar *last_to = strrchr ( vtl->magic_scissors_current_track->comment, 't' );
3384         if ( last_to && (last_to - vtl->magic_scissors_current_track->comment > 1) ) {
3385           gchar *new_comment = g_strndup ( vtl->magic_scissors_current_track->comment,
3386                                            last_to - vtl->magic_scissors_current_track->comment - 1);
3387           vik_track_set_comment_no_copy ( vtl->magic_scissors_current_track, new_comment );
3388         }
3389       }
3390     }
3391   }
3392   else if ( vtl->magic_scissors_started || (event->state & GDK_CONTROL_MASK && vtl->magic_scissors_current_track) ) {
3393     struct LatLon start, end;
3394     gchar *cmd;
3395
3396     vik_coord_to_latlon ( &(vtl->magic_scissors_coord), &start );
3397     vik_coord_to_latlon ( &(tmp), &end );
3398     cmd = g_strdup_printf(GOOGLE_DIRECTIONS_STRING, start.lat, start.lon, end.lat, end.lon );
3399     vtl->magic_scissors_coord = tmp; /* for continuations */
3400
3401     /* these are checked when adding a track from a file (vik_trw_layer_filein_add_track) */
3402     if ( event->state & GDK_CONTROL_MASK && vtl->magic_scissors_current_track ) {
3403       vtl->magic_scissors_append = TRUE;  // merge tracks. keep started true.
3404     } else {
3405       vtl->magic_scissors_check_added_track = TRUE;
3406       vtl->magic_scissors_started = FALSE;
3407     }
3408
3409     a_babel_convert_from_shellcommand ( vtl, cmd, "google", NULL, NULL );
3410     g_free ( cmd );
3411
3412     /* see if anything was done -- a track was added or appended to */
3413     if ( vtl->magic_scissors_check_added_track && vtl->magic_scissors_added_track_name ) {
3414       VikTrack *tr;
3415
3416       tr = g_hash_table_lookup ( vtl->tracks, vtl->magic_scissors_added_track_name );
3417
3418       if ( tr )
3419         vik_track_set_comment_no_copy ( tr, g_strdup_printf("from: %f,%f to: %f%f", start.lat, start.lon, end.lat, end.lon ) );
3420
3421       vtl->magic_scissors_current_track = tr;
3422
3423       g_free ( vtl->magic_scissors_added_track_name );
3424       vtl->magic_scissors_added_track_name = NULL;
3425     } else if ( vtl->magic_scissors_append == FALSE && vtl->magic_scissors_current_track ) {
3426       /* magic_scissors_append was originally TRUE but set to FALSE by filein_add_track */
3427       gchar *new_comment = g_strdup_printf("%s to: %f,%f", vtl->magic_scissors_current_track->comment, end.lat, end.lon );
3428       vik_track_set_comment_no_copy ( vtl->magic_scissors_current_track, new_comment );
3429     }
3430     vtl->magic_scissors_check_added_track = FALSE;
3431     vtl->magic_scissors_append = FALSE;
3432
3433     vik_layer_emit_update ( VIK_LAYER(vtl) );
3434   } else {
3435     vtl->magic_scissors_started = TRUE;
3436     vtl->magic_scissors_coord = tmp;
3437     vtl->magic_scissors_current_track = NULL;
3438   }
3439   return TRUE;
3440 }
3441
3442 /*** Show picture ****/
3443
3444 static gpointer tool_show_picture_create ( VikWindow *vw, VikViewport *vvp)
3445 {
3446   return vvp;
3447 }
3448
3449 /* Params are: vvp, event, last match found or NULL */
3450 static void tool_show_picture_wp ( char *name, VikWaypoint *wp, gpointer params[2] )
3451 {
3452   if ( wp->image && wp->visible )
3453   {
3454     gint x, y, slackx, slacky;
3455     GdkEventButton *event = (GdkEventButton *) params[1];
3456
3457     vik_viewport_coord_to_screen ( VIK_VIEWPORT(params[0]), &(wp->coord), &x, &y );
3458     slackx = wp->image_width / 2;
3459     slacky = wp->image_height / 2;
3460     if (    x <= event->x + slackx && x >= event->x - slackx
3461          && y <= event->y + slacky && y >= event->y - slacky )
3462     {
3463       params[2] = wp->image; /* we've found a match. however continue searching
3464                               * since we want to find the last match -- that
3465                               * is, the match that was drawn last. */
3466     }
3467   }
3468 }
3469
3470 static gboolean tool_show_picture_click ( VikTrwLayer *vtl, GdkEventButton *event, VikViewport *vvp )
3471 {
3472   gpointer params[3] = { vvp, event, NULL };
3473   if (!vtl || vtl->vl.type != VIK_LAYER_TRW)
3474     return FALSE;
3475   g_hash_table_foreach ( vtl->waypoints, (GHFunc) tool_show_picture_wp, params );
3476   if ( params[2] )
3477   {
3478     /* thanks to the Gaim people for showing me ShellExecute and g_spawn_command_line_async */
3479 #ifdef WINDOWS
3480     ShellExecute(NULL, NULL, (char *) params[2], NULL, ".\\", 0);
3481 #else /* WINDOWS */
3482     GError *err = NULL;
3483     gchar *quoted_file = g_shell_quote ( (gchar *) params[2] );
3484     gchar *cmd = g_strdup_printf ( "eog %s", quoted_file );
3485     g_free ( quoted_file );
3486     if ( ! g_spawn_command_line_async ( cmd, &err ) )
3487     {
3488       a_dialog_error_msg ( VIK_GTK_WINDOW_FROM_LAYER(vtl), "Could not launch eog to open file." );
3489       g_error_free ( err );
3490     }
3491     g_free ( cmd );
3492 #endif /* WINDOWS */
3493     return TRUE; /* found a match */
3494   }
3495   else
3496     return FALSE; /* go through other layers, searching for a match */
3497 }
3498
3499 /***************************************************************************
3500  ** End tool code
3501  ***************************************************************************/
3502
3503
3504
3505
3506
3507 static void image_wp_make_list ( char *name, VikWaypoint *wp, GSList **pics )
3508 {
3509   if ( wp->image && ( ! a_thumbnails_exists ( wp->image ) ) )
3510     *pics = g_slist_append ( *pics, (gpointer) g_strdup ( wp->image ) );
3511 }
3512
3513 static void create_thumbnails_thread ( GSList *pics, gpointer threaddata )
3514 {
3515   guint total = g_slist_length(pics), done = 0;
3516   while ( pics )
3517   {
3518     a_thumbnails_create ( (gchar *) pics->data );
3519     a_background_thread_progress ( threaddata, ((gdouble) ++done) / total );
3520     pics = pics->next;
3521   }
3522 }
3523
3524 static void free_pics_slist ( GSList *pics )
3525 {
3526   while ( pics )
3527   {
3528     g_free ( pics->data );
3529     pics = g_slist_delete_link ( pics, pics );
3530   }
3531 }
3532
3533 static void trw_layer_verify_thumbnails ( VikTrwLayer *vtl, GtkWidget *vp )
3534 {
3535   if ( ! vtl->has_verified_thumbnails )
3536   {
3537     GSList *pics = NULL;
3538     g_hash_table_foreach ( vtl->waypoints, (GHFunc) image_wp_make_list, &pics );
3539     if ( pics )
3540     {
3541       gint len = g_slist_length ( pics );
3542       gchar *tmp = g_strdup_printf ( "Creating %d Image Thumbnails...", len );
3543       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 );
3544       g_free ( tmp );
3545     }
3546   }
3547 }
3548
3549 VikCoordMode vik_trw_layer_get_coord_mode ( VikTrwLayer *vtl )
3550 {
3551   return vtl->coord_mode;
3552 }
3553
3554
3555
3556 static void waypoint_convert ( const gchar *name, VikWaypoint *wp, VikCoordMode *dest_mode )
3557 {
3558   vik_coord_convert ( &(wp->coord), *dest_mode );
3559 }
3560
3561 static void track_convert ( const gchar *name, VikTrack *tr, VikCoordMode *dest_mode )
3562 {
3563   vik_track_convert ( tr, *dest_mode );
3564 }
3565
3566 static void trw_layer_change_coord_mode ( VikTrwLayer *vtl, VikCoordMode dest_mode )
3567 {
3568   if ( vtl->coord_mode != dest_mode )
3569   {
3570     vtl->coord_mode = dest_mode;
3571     g_hash_table_foreach ( vtl->waypoints, (GHFunc) waypoint_convert, &dest_mode );
3572     g_hash_table_foreach ( vtl->tracks, (GHFunc) track_convert, &dest_mode );
3573   }
3574 }
3575
3576 VikWaypoint *vik_trw_layer_get_waypoint ( VikTrwLayer *vtl, gchar *name )
3577 {
3578   return g_hash_table_lookup ( vtl->waypoints, name );
3579 }
3580
3581 VikTrack *vik_trw_layer_get_track ( VikTrwLayer *vtl, gchar *name )
3582 {
3583   return g_hash_table_lookup ( vtl->tracks, name );
3584 }
3585
3586 static void vik_trw_layer_set_menu_selection(VikTrwLayer *vtl, guint16 selection)
3587 {
3588   vtl->menu_selection = selection;
3589 }
3590
3591 static guint16 vik_trw_layer_get_menu_selection(VikTrwLayer *vtl)
3592 {
3593   return(vtl->menu_selection);
3594 }
3595
3596 /* ----------- Downloading maps along tracks --------------- */
3597
3598 static int get_download_area_width(VikViewport *vvp, gdouble zoom_level, struct LatLon *wh)
3599 {
3600   /* TODO: calculating based on current size of viewport */
3601   const gdouble w_at_zoom_0_125 = 0.0013;
3602   const gdouble h_at_zoom_0_125 = 0.0011;
3603   gdouble zoom_factor = zoom_level/0.125;
3604
3605   wh->lat = h_at_zoom_0_125 * zoom_factor;
3606   wh->lon = w_at_zoom_0_125 * zoom_factor;
3607
3608   return 0;   /* all OK */
3609 }
3610
3611 static VikCoord *get_next_coord(VikCoord *from, VikCoord *to, struct LatLon *dist, gdouble gradient)
3612 {
3613   if ((dist->lon >= ABS(to->east_west - from->east_west)) &&
3614       (dist->lat >= ABS(to->north_south - from->north_south)))
3615     return NULL;
3616
3617   VikCoord *coord = g_malloc(sizeof(VikCoord));
3618   coord->mode = VIK_COORD_LATLON;
3619
3620   if (ABS(gradient) < 1) {
3621     if (from->east_west > to->east_west)
3622       coord->east_west = from->east_west - dist->lon;
3623     else
3624       coord->east_west = from->east_west + dist->lon;
3625     coord->north_south = gradient * (coord->east_west - from->east_west) + from->north_south;
3626   } else {
3627     if (from->north_south > to->north_south)
3628       coord->north_south = from->north_south - dist->lat;
3629     else
3630       coord->north_south = from->north_south + dist->lat;
3631     coord->east_west = (1/gradient) * (coord->north_south - from->north_south) + from->north_south;
3632   }
3633
3634   return coord;
3635 }
3636
3637 static GList *add_fillins(GList *list, VikCoord *from, VikCoord *to, struct LatLon *dist)
3638 {
3639   /* TODO: handle virtical track (to->east_west - from->east_west == 0) */
3640   gdouble gradient = (to->north_south - from->north_south)/(to->east_west - from->east_west);
3641
3642   VikCoord *next = from;
3643   while (TRUE) {
3644     if ((next = get_next_coord(next, to, dist, gradient)) == NULL)
3645         break;
3646     list = g_list_prepend(list, next);
3647   }
3648
3649   return list;
3650 }
3651
3652 void vik_track_download_map(VikTrack *tr, VikMapsLayer *vml, VikViewport *vvp, gdouble zoom_level)
3653 {
3654   typedef struct _Rect {
3655     VikCoord tl;
3656     VikCoord br;
3657     VikCoord center;
3658   } Rect;
3659 #define GLRECT(iter) ((Rect *)((iter)->data))
3660
3661   struct LatLon wh;
3662   GList *rects_to_download = NULL;
3663   GList *rect_iter;
3664
3665   if (get_download_area_width(vvp, zoom_level, &wh))
3666     return;
3667
3668   GList *iter = tr->trackpoints;
3669   if (!iter)
3670     return;
3671
3672   gboolean new_map = TRUE;
3673   VikCoord *cur_coord, tl, br;
3674   Rect *rect;
3675   while (iter) {
3676     cur_coord = &(VIK_TRACKPOINT(iter->data))->coord;
3677     if (new_map) {
3678       vik_coord_set_area(cur_coord, &wh, &tl, &br);
3679       rect = g_malloc(sizeof(Rect));
3680       rect->tl = tl;
3681       rect->br = br;
3682       rect->center = *cur_coord;
3683       rects_to_download = g_list_prepend(rects_to_download, rect);
3684       new_map = FALSE;
3685       iter = iter->next;
3686       continue;
3687     }
3688     gboolean found = FALSE;
3689     for (rect_iter = rects_to_download; rect_iter; rect_iter = rect_iter->next) {
3690       if (vik_coord_inside(cur_coord, &GLRECT(rect_iter)->tl, &GLRECT(rect_iter)->br)) {
3691         found = TRUE;
3692         break;
3693       }
3694     }
3695     if (found)
3696         iter = iter->next;
3697     else
3698       new_map = TRUE;
3699   }
3700
3701   /* fill-ins for far apart points */
3702   GList *cur_rect, *next_rect;
3703   GList *fillins = NULL;
3704   for (cur_rect = rects_to_download;
3705       (next_rect = cur_rect->next) != NULL;
3706       cur_rect = cur_rect->next) {
3707     if ((wh.lon < ABS(GLRECT(cur_rect)->center.east_west - GLRECT(next_rect)->center.east_west)) ||
3708         (wh.lat < ABS(GLRECT(cur_rect)->center.north_south - GLRECT(next_rect)->center.north_south))) {
3709       fillins = add_fillins(fillins, &GLRECT(cur_rect)->center, &GLRECT(next_rect)->center, &wh);
3710     }
3711   }
3712
3713   if (fillins) {
3714     GList *iter = fillins;
3715     while (iter) {
3716       cur_coord = (VikCoord *)(iter->data);
3717       vik_coord_set_area(cur_coord, &wh, &tl, &br);
3718       rect = g_malloc(sizeof(Rect));
3719       rect->tl = tl;
3720       rect->br = br;
3721       rect->center = *cur_coord;
3722       rects_to_download = g_list_prepend(rects_to_download, rect);
3723       iter = iter->next;
3724     }
3725   }
3726
3727   for (rect_iter = rects_to_download; rect_iter; rect_iter = rect_iter->next) {
3728     maps_layer_download_section_without_redraw(vml, vvp, &(((Rect *)(rect_iter->data))->tl), &(((Rect *)(rect_iter->data))->br), zoom_level);
3729   }
3730
3731   if (fillins) {
3732     for (iter = fillins; iter; iter = iter->next)
3733       g_free(iter->data);
3734     g_list_free(fillins);
3735   }
3736   if (rects_to_download) {
3737     for (rect_iter = rects_to_download; rect_iter; rect_iter = rect_iter->next)
3738       g_free(rect_iter->data);
3739     g_list_free(rects_to_download);
3740   }
3741 }
3742
3743 static void trw_layer_download_map_along_track_cb(gpointer pass_along[6])
3744 {
3745   VikMapsLayer *vml;
3746   gint selected_map, default_map;
3747   gchar *zoomlist[] = {"0.125", "0.25", "0.5", "1", "2", "4", "8", "16", "32", "64", "128", "256", "512", "1024", NULL };
3748   gdouble zoom_vals[] = {0.125, 0.25, 0.5, 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024};
3749   gint selected_zoom, default_zoom;
3750   int i,j;
3751
3752
3753   VikTrwLayer *vtl = pass_along[0];
3754   VikLayersPanel *vlp = pass_along[1];
3755   VikTrack *tr = (VikTrack *) g_hash_table_lookup ( VIK_TRW_LAYER(pass_along[0])->tracks, pass_along[3] );
3756   VikViewport *vvp = vik_window_viewport((VikWindow *)(VIK_GTK_WINDOW_FROM_LAYER(vtl)));
3757
3758   GList *vmls = vik_layers_panel_get_all_layers_of_type(vlp, VIK_LAYER_MAPS);
3759   int num_maps = g_list_length(vmls);
3760
3761   if (!num_maps) {
3762     a_dialog_msg(VIK_GTK_WINDOW_FROM_LAYER(vtl), GTK_MESSAGE_ERROR,"No map layer in use. Create one first", NULL);
3763     return;
3764   }
3765
3766   gchar **map_names = g_malloc(1 + num_maps * sizeof(gpointer));
3767   VikMapsLayer **map_layers = g_malloc(1 + num_maps * sizeof(gpointer));
3768
3769   gchar **np = map_names;
3770   VikMapsLayer **lp = map_layers;
3771   for (i = 0; i < num_maps; i++) {
3772     gboolean dup = FALSE;
3773     vml = (VikMapsLayer *)(vmls->data);
3774     for (j = 0; j < i; j++) { /* no duplicate allowed */
3775       if (vik_maps_layer_get_map_type(vml) == vik_maps_layer_get_map_type(map_layers[j])) {
3776         dup = TRUE;
3777         break;
3778       }
3779     }
3780     if (!dup) {
3781       *lp++ = vml;
3782       *np++ = vik_maps_layer_get_map_label(vml);
3783     }
3784     vmls = vmls->next;
3785   }
3786   *lp = NULL;
3787   *np = NULL;
3788   num_maps = lp - map_layers;
3789
3790   for (default_map = 0; default_map < num_maps; default_map++) {
3791     /* TODO: check for parent layer's visibility */
3792     if (VIK_LAYER(map_layers[default_map])->visible)
3793       break;
3794   }
3795   default_map = (default_map == num_maps) ? 0 : default_map;
3796
3797   gdouble cur_zoom = vik_viewport_get_zoom(vvp);
3798   for (default_zoom = 0; default_zoom < sizeof(zoom_vals)/sizeof(gdouble); default_zoom++) {
3799     if (cur_zoom == zoom_vals[default_zoom])
3800       break;
3801   }
3802   default_zoom = (default_zoom == sizeof(zoom_vals)/sizeof(gdouble)) ? sizeof(zoom_vals)/sizeof(gdouble) - 1 : default_zoom;
3803
3804   if (!a_dialog_map_n_zoom(VIK_GTK_WINDOW_FROM_LAYER(vtl), map_names, default_map, zoomlist, default_zoom, &selected_map, &selected_zoom))
3805     goto done;
3806
3807   vik_track_download_map(tr, map_layers[selected_map], vvp, zoom_vals[selected_zoom]);
3808
3809 done:
3810   for (i = 0; i < num_maps; i++)
3811     g_free(map_names[i]);
3812   g_free(map_names);
3813   g_free(map_layers);
3814
3815   g_list_free(vmls);
3816
3817 }
3818