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 #include "googlesearch.h"
  44 #ifdef VIK_CONFIG_OPENSTREETMAP
  45 #include "osm-traces.h"
  46 #endif
  47
  48 #include "icons/icons.h"
  49
  50 #include <math.h>
  51 #include <string.h>
  52 #include <stdlib.h>
  53 #include <ctype.h>
  54
  55 #include <gdk/gdkkeysyms.h>
  56
  57 /* Relax some dependencies */
  58 #if ! GLIB_CHECK_VERSION(2,12,0)
  59 static gboolean return_true (gpointer a, gpointer b, gpointer c) { return TRUE; }
  60 static g_hash_table_remove_all (GHashTable *ght) { g_hash_table_foreach_remove ( ght, (GHRFunc) return_true, FALSE ); }
  61 #endif
  62
  63 #define GOOGLE_DIRECTIONS_STRING "(wget -O - \"http://maps.google.com/maps?q=%f,%f to %f,%f&output=js\" 2>/dev/null)"
  64 #define VIK_TRW_LAYER_TRACK_GC 13
  65 #define VIK_TRW_LAYER_TRACK_GC_RATES 10
  66 #define VIK_TRW_LAYER_TRACK_GC_MIN 0
  67 #define VIK_TRW_LAYER_TRACK_GC_MAX 11
  68 #define VIK_TRW_LAYER_TRACK_GC_BLACK 12
  69
  70 #define DRAWMODE_BY_TRACK 0
  71 #define DRAWMODE_BY_VELOCITY 1
  72 #define DRAWMODE_ALL_BLACK 2
  73
  74 #define POINTS 1
  75 #define LINES 2
  76
  77 /* this is how it knows when you click if you are clicking close to a trackpoint. */
  78 #define TRACKPOINT_SIZE_APPROX 5
  79 #define WAYPOINT_SIZE_APPROX 5
  80
  81 #define MIN_STOP_LENGTH 15
  82 #define MAX_STOP_LENGTH 86400
  83 #define DRAW_ELEVATION_FACTOR 30 /* height of elevation plotting, sort of relative to zoom level ("mpp" that isn't mpp necessarily) */
  84                                  /* this is multiplied by user-inputted value from 1-100. */
  85 enum {
  86 VIK_TRW_LAYER_SUBLAYER_TRACKS,
  87 VIK_TRW_LAYER_SUBLAYER_WAYPOINTS,
  88 VIK_TRW_LAYER_SUBLAYER_TRACK,
  89 VIK_TRW_LAYER_SUBLAYER_WAYPOINT
  90 };
  91
  92 enum { WP_SYMBOL_FILLED_SQUARE, WP_SYMBOL_SQUARE, WP_SYMBOL_CIRCLE, WP_SYMBOL_X, WP_NUM_SYMBOLS };
  93
  94 struct _VikTrwLayer {
  95   VikLayer vl;
  96   GHashTable *tracks;
  97   GHashTable *tracks_iters;
  98   GHashTable *waypoints_iters;
  99   GHashTable *waypoints;
 100   GtkTreeIter waypoints_iter, tracks_iter;
 101   gboolean tracks_visible, waypoints_visible;
 102   guint8 drawmode;
 103   guint8 drawpoints;
 104   guint8 drawelevation;
 105   guint8 elevation_factor;
 106   guint8 drawstops;
 107   guint32 stop_length;
 108   guint8 drawlines;
 109   guint8 line_thickness;
 110   guint8 bg_line_thickness;
 111
 112   guint8 wp_symbol;
 113   guint8 wp_size;
 114   gboolean wp_draw_symbols;
 115
 116   gdouble velocity_min, velocity_max;
 117   GArray *track_gc;
 118   guint16 track_gc_iter;
 119   GdkGC *current_track_gc;
 120   GdkGC *track_bg_gc;
 121   GdkGC *waypoint_gc;
 122   GdkGC *waypoint_text_gc;
 123   GdkGC *waypoint_bg_gc;
 124   GdkFont *waypoint_font;
 125   VikTrack *current_track;
 126   guint16 ct_x1, ct_y1, ct_x2, ct_y2;
 127   gboolean ct_sync_done;
 128
 129
 130   VikCoordMode coord_mode;
 131
 132   /* wp editing tool */
 133   VikWaypoint *current_wp;
 134   gchar *current_wp_name;
 135   gboolean moving_wp;
 136   gboolean waypoint_rightclick;
 137
 138   /* track editing tool */
 139   GList *current_tpl;
 140   gchar *current_tp_track_name;
 141   VikTrwLayerTpwin *tpwin;
 142
 143   /* weird hack for joining tracks */
 144   GList *last_tpl;
 145   gchar *last_tp_track_name;
 146
 147   /* track editing tool -- more specifically, moving tps */
 148   gboolean moving_tp;
 149
 150   /* magic scissors tool */
 151   gboolean magic_scissors_started;
 152   VikCoord magic_scissors_coord;
 153   gboolean magic_scissors_check_added_track;
 154   gchar *magic_scissors_added_track_name;
 155   VikTrack *magic_scissors_current_track;
 156   gboolean magic_scissors_append;
 157
 158   gboolean drawlabels;
 159   gboolean drawimages;
 160   guint8 image_alpha;
 161   GQueue *image_cache;
 162   guint8 image_size;
 163   guint16 image_cache_size;
 164
 165   /* for waypoint text */
 166   PangoLayout *wplabellayout;
 167
 168   gboolean has_verified_thumbnails;
 169
 170   GtkMenu *wp_right_click_menu;
 171
 172   /* menu */
 173   VikStdLayerMenuItem menu_selection;
 174
 175 };
 176
 177 /* A caached waypoint image. */
 178 typedef struct {
 179   GdkPixbuf *pixbuf;
 180   gchar *image; /* filename */
 181 } CachedPixbuf;
 182
 183 struct DrawingParams {
 184   VikViewport *vp;
 185   VikTrwLayer *vtl;
 186   gdouble xmpp, ympp;
 187   guint16 width, height;
 188   const VikCoord *center;
 189   gint track_gc_iter;
 190   gboolean one_zone, lat_lon;
 191   gdouble ce1, ce2, cn1, cn2;
 192 };
 193
 194 static void vik_trw_layer_set_menu_selection(VikTrwLayer *vtl, guint16);
 195 static guint16 vik_trw_layer_get_menu_selection(VikTrwLayer *vtl);
 196
 197 static void trw_layer_delete_item ( gpointer *pass_along );
 198 static void trw_layer_copy_item_cb( gpointer *pass_along);
 199 static void trw_layer_cut_item_cb( gpointer *pass_along);
 200
 201 static void trw_layer_find_maxmin_waypoints ( const gchar *name, const VikWaypoint *w, struct LatLon maxmin[2] );
 202 static void trw_layer_find_maxmin_tracks ( const gchar *name, GList **t, struct LatLon maxmin[2] );
 203
 204 static void trw_layer_new_track_gcs ( VikTrwLayer *vtl, VikViewport *vp );
 205 static void trw_layer_free_track_gcs ( VikTrwLayer *vtl );
 206
 207 static gint calculate_velocity ( VikTrwLayer *vtl, VikTrackpoint *tp1, VikTrackpoint *tp2 );
 208 static void trw_layer_draw_track_cb ( const gchar *name, VikTrack *track, struct DrawingParams *dp );
 209 static void trw_layer_draw_waypoint ( const gchar *name, VikWaypoint *wp, struct DrawingParams *dp );
 210
 211 static void goto_coord ( VikLayersPanel *vlp, const VikCoord *coord );
 212 static void trw_layer_goto_track_startpoint ( gpointer pass_along[5] );
 213 static void trw_layer_goto_track_endpoint ( gpointer pass_along[6] );
 214 static void trw_layer_merge_by_timestamp ( gpointer pass_along[6] );
 215 static void trw_layer_split_by_timestamp ( gpointer pass_along[6] );
 216 static void trw_layer_download_map_along_track_cb(gpointer pass_along[6]);
 217 static void trw_layer_centerize ( gpointer layer_and_vlp[2] );
 218 static void trw_layer_export ( gpointer layer_and_vlp[2], guint file_type );
 219 static void trw_layer_goto_wp ( gpointer layer_and_vlp[2] );
 220 static void trw_layer_new_wp ( gpointer lav[2] );
 221
 222 /* pop-up items */
 223 static void trw_layer_properties_item ( gpointer pass_along[5] );
 224 static void trw_layer_goto_waypoint ( gpointer pass_along[5] );
 225 static void trw_layer_waypoint_gc_webpage ( gpointer pass_along[5] );
 226
 227 static void trw_layer_realize_waypoint ( gchar *name, VikWaypoint *wp, gpointer pass_along[4] );
 228 static void trw_layer_realize_track ( gchar *name, VikTrack *track, gpointer pass_along[4] );
 229 static void init_drawing_params ( struct DrawingParams *dp, VikViewport *vp );
 230
 231
 232 static void trw_layer_marshall( VikTrwLayer *vtl, guint8 **data, gint *len );
 233 static VikTrwLayer *trw_layer_unmarshall( gpointer data, gint len, VikViewport *vvp );
 234
 235 static gboolean trw_layer_set_param ( VikTrwLayer *vtl, guint16 id, VikLayerParamData data, VikViewport *vp );
 236 static VikLayerParamData trw_layer_get_param ( VikTrwLayer *vtl, guint16 id );
 237
 238 static void trw_layer_del_item ( VikTrwLayer *vtl, gint subtype, gpointer sublayer );
 239 static void trw_layer_copy_item ( VikTrwLayer *vtl, gint subtype, gpointer sublayer, guint8 **item, guint *len );
 240 static gboolean trw_layer_paste_item ( VikTrwLayer *vtl, gint subtype, guint8 *item, guint len );
 241 static void trw_layer_free_copied_item ( gint subtype, gpointer item );
 242 static void trw_layer_drag_drop_request ( VikTrwLayer *vtl_src, VikTrwLayer *vtl_dest, GtkTreeIter *src_item_iter, GtkTreePath *dest_path );
 243
 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 && !dp->lat_lon) || ( ( dp->lat_lon || 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 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       vik_trw_layer_propwin_run ( VIK_GTK_WINDOW_FROM_LAYER(vtl),
1931                       vtl, tr,
1932                       pass_along[1], /* vlp */
1933                       pass_along[3]  /* track name */);
1934     }
1935   }
1936 }
1937
1938 static void goto_coord ( VikLayersPanel *vlp, const VikCoord *coord )
1939 {
1940   vik_viewport_set_center_coord ( vik_layers_panel_get_viewport(vlp), coord );
1941   vik_layers_panel_emit_update ( vlp );
1942 }
1943
1944 static void trw_layer_goto_track_startpoint ( gpointer pass_along[5] )
1945 {
1946   GList *trps = ((VikTrack *) g_hash_table_lookup ( VIK_TRW_LAYER(pass_along[0])->tracks, pass_along[3] ))->trackpoints;
1947   if ( trps && trps->data )
1948     goto_coord ( VIK_LAYERS_PANEL(pass_along[1]), &(((VikTrackpoint *) trps->data)->coord));
1949 }
1950
1951 static void trw_layer_goto_track_center ( gpointer pass_along[5] )
1952 {
1953   /* FIXME: get this into viktrack.c, and should be ->trackpoints right? */
1954   GList **trps = g_hash_table_lookup ( VIK_TRW_LAYER(pass_along[0])->tracks, pass_along[3] );
1955   if ( trps && *trps )
1956   {
1957     struct LatLon average, maxmin[2] = { {0,0}, {0,0} };
1958     VikCoord coord;
1959     trw_layer_find_maxmin_tracks ( NULL, trps, maxmin );
1960     average.lat = (maxmin[0].lat+maxmin[1].lat)/2;
1961     average.lon = (maxmin[0].lon+maxmin[1].lon)/2;
1962     vik_coord_load_from_latlon ( &coord, VIK_TRW_LAYER(pass_along[0])->coord_mode, &average );
1963     goto_coord ( VIK_LAYERS_PANEL(pass_along[1]), &coord);
1964   }
1965 }
1966
1967 static void trw_layer_extend_track_end ( gpointer pass_along[6] )
1968 {
1969   VikTrwLayer *vtl = VIK_TRW_LAYER(pass_along[0]);
1970   VikTrack *track = g_hash_table_lookup ( VIK_TRW_LAYER(pass_along[0])->tracks, pass_along[3] );
1971
1972   vtl->current_track = track;
1973   vik_window_enable_layer_tool ( VIK_WINDOW(VIK_GTK_WINDOW_FROM_LAYER(vtl)), VIK_LAYER_TRW, TOOL_CREATE_TRACK );
1974
1975   if ( track->trackpoints )
1976     goto_coord ( VIK_LAYERS_PANEL(pass_along[1]), &(((VikTrackpoint *)g_list_last(track->trackpoints)->data)->coord) );
1977 }
1978
1979 static void trw_layer_apply_dem_data ( gpointer pass_along[6] )
1980 {
1981   /* TODO: check & warn if no DEM data, or no applicable DEM data. */
1982   /* Also warn if overwrite old elevation data */
1983   VikTrack *track = (VikTrack *) g_hash_table_lookup ( VIK_TRW_LAYER(pass_along[0])->tracks, pass_along[3] );
1984
1985   vik_track_apply_dem_data ( track );
1986 }
1987
1988 static void trw_layer_goto_track_endpoint ( gpointer pass_along[6] )
1989 {
1990   GList *trps = ((VikTrack *) g_hash_table_lookup ( VIK_TRW_LAYER(pass_along[0])->tracks, pass_along[3] ))->trackpoints;
1991   if ( !trps )
1992     return;
1993   trps = g_list_last(trps);
1994   goto_coord ( VIK_LAYERS_PANEL(pass_along[1]), &(((VikTrackpoint *) trps->data)->coord));
1995 }
1996
1997
1998 /*************************************
1999  * merge/split by time routines
2000  *************************************/
2001
2002 /* called for each key in track hash table. if original track user_data[1] is close enough
2003  * to the passed one, add it to list in user_data[0]
2004  */
2005 static void find_nearby_track(gpointer key, gpointer value, gpointer user_data)
2006 {
2007   time_t t1, t2;
2008   VikTrackpoint *p1, *p2;
2009
2010   GList **nearby_tracks = ((gpointer *)user_data)[0];
2011   GList *orig_track = ((gpointer *)user_data)[1];
2012   guint thr = (guint)((gpointer *)user_data)[2];
2013
2014   t1 = VIK_TRACKPOINT(orig_track->data)->timestamp;
2015   t2 = VIK_TRACKPOINT(g_list_last(orig_track)->data)->timestamp;
2016
2017   if (VIK_TRACK(value)->trackpoints == orig_track) {
2018     return;
2019   }
2020
2021   p1 = VIK_TRACKPOINT(VIK_TRACK(value)->trackpoints->data);
2022   p2 = VIK_TRACKPOINT(g_list_last(VIK_TRACK(value)->trackpoints)->data);
2023
2024   if (!p1->has_timestamp || !p2->has_timestamp) {
2025     g_print("no timestamp\n");
2026     return;
2027   }
2028
2029   /*  g_print("Got track named %s, times %d, %d\n", (gchar *)key, p1->timestamp, p2->timestamp); */
2030   if (abs(t1 - p2->timestamp) < thr*60 ||
2031       /*  p1 p2      t1 t2 */
2032       abs(p1->timestamp - t2) < thr*60
2033       /*  t1 t2      p1 p2 */
2034       ) {
2035     *nearby_tracks = g_list_prepend(*nearby_tracks, key);
2036   }
2037 }
2038
2039 /* comparison function used to sort tracks; a and b are hash table keys */
2040 static gint track_compare(gconstpointer a, gconstpointer b, gpointer user_data)
2041 {
2042   GHashTable *tracks = user_data;
2043   time_t t1, t2;
2044
2045   t1 = VIK_TRACKPOINT(VIK_TRACK(g_hash_table_lookup(tracks, a))->trackpoints->data)->timestamp;
2046   t2 = VIK_TRACKPOINT(VIK_TRACK(g_hash_table_lookup(tracks, b))->trackpoints->data)->timestamp;
2047
2048   if (t1 < t2) return -1;
2049   if (t1 > t2) return 1;
2050   return 0;
2051 }
2052
2053 /* comparison function used to sort trackpoints */
2054 static gint trackpoint_compare(gconstpointer a, gconstpointer b)
2055 {
2056   time_t t1 = VIK_TRACKPOINT(a)->timestamp, t2 = VIK_TRACKPOINT(b)->timestamp;
2057
2058   if (t1 < t2) return -1;
2059   if (t1 > t2) return 1;
2060   return 0;
2061 }
2062
2063 /* merge by time routine */
2064 static void trw_layer_merge_by_timestamp ( gpointer pass_along[6] )
2065 {
2066   time_t t1, t2;
2067   GList *nearby_tracks = NULL;
2068   VikTrack *track;
2069   GList *trps;
2070   static  guint thr = 1;
2071   guint track_count = 0;
2072   gchar *orig_track_name = strdup(pass_along[3]);
2073
2074   if (!a_dialog_time_threshold(VIK_GTK_WINDOW_FROM_LAYER(pass_along[0]),
2075                                "Merge Threshold...",
2076                                "Merge when time between trackpoints less than:",
2077                                &thr)) {
2078     return;
2079   }
2080
2081   /* merge tracks until we can't */
2082   do {
2083     gpointer params[3];
2084
2085     track = (VikTrack *) g_hash_table_lookup ( VIK_TRW_LAYER(pass_along[0])->tracks, orig_track_name );
2086     trps = track->trackpoints;
2087     if ( !trps )
2088       return;
2089
2090
2091     if (nearby_tracks) {
2092       g_list_free(nearby_tracks);
2093       nearby_tracks = NULL;
2094     }
2095
2096     t1 = ((VikTrackpoint *)trps->data)->timestamp;
2097     t2 = ((VikTrackpoint *)g_list_last(trps)->data)->timestamp;
2098
2099     /*    g_print("Original track times: %d and %d\n", t1, t2);  */
2100     params[0] = &nearby_tracks;
2101     params[1] = trps;
2102     params[2] = (gpointer)thr;
2103
2104     /* get a list of adjacent-in-time tracks */
2105     g_hash_table_foreach(VIK_TRW_LAYER(pass_along[0])->tracks, find_nearby_track, (gpointer)params);
2106
2107     /* add original track */
2108     nearby_tracks = g_list_prepend(nearby_tracks, orig_track_name);
2109
2110     /* sort by first trackpoint; assumes they don't overlap */
2111     nearby_tracks = g_list_sort_with_data(nearby_tracks, track_compare, VIK_TRW_LAYER(pass_along[0])->tracks);
2112
2113     /* merge them */
2114     {
2115 #define get_track(x) VIK_TRACK(g_hash_table_lookup(VIK_TRW_LAYER(pass_along[0])->tracks, (gchar *)((x)->data)))
2116 #define get_first_trackpoint(x) VIK_TRACKPOINT(get_track(x)->trackpoints->data)
2117 #define get_last_trackpoint(x) VIK_TRACKPOINT(g_list_last(get_track(x)->trackpoints)->data)
2118       GList *l = nearby_tracks;
2119       VikTrack *tr = vik_track_new();
2120       tr->visible = track->visible;
2121       track_count = 0;
2122       while (l) {
2123         /*
2124         time_t t1, t2;
2125         t1 = get_first_trackpoint(l)->timestamp;
2126         t2 = get_last_trackpoint(l)->timestamp;
2127         g_print("     %20s: track %d - %d\n", (char *)l->data, (int)t1, (int)t2);
2128         */
2129
2130
2131         /* remove trackpoints from merged track, delete track */
2132         tr->trackpoints = g_list_concat(tr->trackpoints, get_track(l)->trackpoints);
2133         get_track(l)->trackpoints = NULL;
2134         vik_trw_layer_delete_track(VIK_TRW_LAYER(pass_along[0]), l->data);
2135
2136         track_count ++;
2137         l = g_list_next(l);
2138       }
2139       tr->trackpoints = g_list_sort(tr->trackpoints, trackpoint_compare);
2140       vik_trw_layer_add_track(VIK_TRW_LAYER(pass_along[0]), strdup(orig_track_name), tr);
2141
2142 #undef get_first_trackpoint
2143 #undef get_last_trackpoint
2144 #undef get_track
2145     }
2146   } while (track_count > 1);
2147   g_list_free(nearby_tracks);
2148   free(orig_track_name);
2149   vik_layer_emit_update(VIK_LAYER(pass_along[0]));
2150 }
2151
2152 /* split by time routine */
2153 static void trw_layer_split_by_timestamp ( gpointer pass_along[6] )
2154 {
2155   VikTrack *track = (VikTrack *) g_hash_table_lookup ( VIK_TRW_LAYER(pass_along[0])->tracks, pass_along[3] );
2156   GList *trps = track->trackpoints;
2157   GList *iter;
2158   GList *newlists = NULL;
2159   GList *newtps = NULL;
2160   guint i;
2161   static guint thr = 1;
2162
2163   time_t ts, prev_ts;
2164
2165   if ( !trps )
2166     return;
2167
2168   if (!a_dialog_time_threshold(VIK_GTK_WINDOW_FROM_LAYER(pass_along[0]),
2169                                "Split Threshold...",
2170                                "Split when time between trackpoints exceeds:",
2171                                &thr)) {
2172     return;
2173   }
2174
2175   /* iterate through trackpoints, and copy them into new lists without touching original list */
2176   prev_ts = VIK_TRACKPOINT(trps->data)->timestamp;
2177   iter = trps;
2178
2179   while (iter) {
2180     ts = VIK_TRACKPOINT(iter->data)->timestamp;
2181     if (ts < prev_ts) {
2182       g_print("panic: ts < prev_ts: this should never happen!\n");
2183       return;
2184     }
2185     if (ts - prev_ts > thr*60) {
2186       /* flush accumulated trackpoints into new list */
2187       newlists = g_list_prepend(newlists, g_list_reverse(newtps));
2188       newtps = NULL;
2189     }
2190
2191     /* accumulate trackpoint copies in newtps, in reverse order */
2192     newtps = g_list_prepend(newtps, vik_trackpoint_copy(VIK_TRACKPOINT(iter->data)));
2193     prev_ts = ts;
2194     iter = g_list_next(iter);
2195   }
2196   if (newtps) {
2197       newlists = g_list_prepend(newlists, g_list_reverse(newtps));
2198   }
2199
2200   /* put lists of trackpoints into tracks */
2201   iter = newlists;
2202   i = 1;
2203   while (iter) {
2204     gchar *new_tr_name;
2205     VikTrack *tr;
2206
2207     tr = vik_track_new();
2208     tr->visible = track->visible;
2209     tr->trackpoints = (GList *)(iter->data);
2210
2211     new_tr_name = g_strdup_printf("%s #%d", (gchar *) pass_along[3], i++);
2212     vik_trw_layer_add_track(VIK_TRW_LAYER(pass_along[0]), new_tr_name, tr);
2213     /*    g_print("adding track %s, times %d - %d\n", new_tr_name, VIK_TRACKPOINT(tr->trackpoints->data)->timestamp,
2214           VIK_TRACKPOINT(g_list_last(tr->trackpoints)->data)->timestamp);*/
2215
2216     iter = g_list_next(iter);
2217   }
2218   g_list_free(newlists);
2219   vik_trw_layer_delete_track(VIK_TRW_LAYER(pass_along[0]), (gchar *)pass_along[3]);
2220   vik_layer_emit_update(VIK_LAYER(pass_along[0]));
2221 }
2222
2223 /* end of split/merge routines */
2224
2225
2226 static void trw_layer_goto_waypoint ( gpointer pass_along[5] )
2227 {
2228   VikWaypoint *wp = g_hash_table_lookup ( VIK_TRW_LAYER(pass_along[0])->waypoints, pass_along[3] );
2229   if ( wp )
2230     goto_coord ( VIK_LAYERS_PANEL(pass_along[1]), &(wp->coord) );
2231 }
2232
2233 static void trw_layer_waypoint_gc_webpage ( gpointer pass_along[5] )
2234 {
2235   gchar *webpage = g_strdup_printf("http://www.geocaching.com/seek/cache_details.aspx?wp=%s", (gchar *) pass_along[3] );
2236 #ifdef WINDOWS
2237   ShellExecute(NULL, NULL, (char *) webpage, NULL, ".\\", 0);
2238 #else /* WINDOWS */
2239   GError *err = NULL;
2240   gchar *cmd = g_strdup_printf ( "%s %s", UNIX_WEB_BROWSER, webpage );
2241   if ( ! g_spawn_command_line_async ( cmd, &err ) )
2242   {
2243     a_dialog_error_msg ( VIK_GTK_WINDOW_FROM_LAYER(VIK_LAYER(pass_along[0])), "Could not launch web browser." );
2244     g_error_free ( err );
2245   }
2246   g_free ( cmd );
2247 #endif /* WINDOWS */
2248   g_free ( webpage );
2249 }
2250
2251 const gchar *vik_trw_layer_sublayer_rename_request ( VikTrwLayer *l, const gchar *newname, gpointer vlp, gint subtype, gpointer sublayer, GtkTreeIter *iter )
2252 {
2253   if ( subtype == VIK_TRW_LAYER_SUBLAYER_WAYPOINT )
2254   {
2255     int i;
2256     gchar *rv;
2257     VikWaypoint *wp;
2258
2259     if ( strcasecmp ( newname, sublayer ) == 0 )
2260       return NULL;
2261
2262     if ( uppercase_exists_in_hash ( l->waypoints, newname ) )
2263     {
2264       a_dialog_error_msg ( VIK_GTK_WINDOW_FROM_LAYER(l), "Waypoint Already Exists" );
2265       return NULL;
2266     }
2267
2268     iter = g_hash_table_lookup ( l->waypoints_iters, sublayer );
2269     g_hash_table_steal ( l->waypoints_iters, sublayer );
2270
2271     wp = vik_waypoint_copy ( VIK_WAYPOINT(g_hash_table_lookup ( l->waypoints, sublayer )) );
2272     g_hash_table_remove ( l->waypoints, sublayer );
2273
2274     rv = g_strdup(newname);
2275     for ( i = strlen(rv) - 1; i >= 0; i-- )
2276       rv[i] = toupper(rv[i]);
2277
2278     vik_treeview_item_set_pointer ( VIK_LAYER(l)->vt, iter, rv );
2279
2280     g_hash_table_insert ( l->waypoints, rv, wp );
2281     g_hash_table_insert ( l->waypoints_iters, rv, iter );
2282
2283     /* it hasn't been updated yet so we pass new name */
2284 #ifdef VIK_CONFIG_ALPHABETIZED_TRW
2285     vik_treeview_sublayer_realphabetize ( VIK_LAYER(l)->vt, iter, rv );
2286 #endif
2287
2288     vik_layers_panel_emit_update ( VIK_LAYERS_PANEL(vlp) );
2289     return rv;
2290   }
2291   if ( subtype == VIK_TRW_LAYER_SUBLAYER_TRACK )
2292   {
2293     int i;
2294     gchar *rv;
2295     VikTrack *tr;
2296     GtkTreeIter *iter;
2297     gchar *orig_key;
2298
2299     if ( strcasecmp ( newname, sublayer ) == 0 )
2300       return NULL;
2301
2302     if ( uppercase_exists_in_hash ( l->tracks, newname ) )
2303     {
2304       a_dialog_error_msg ( VIK_GTK_WINDOW_FROM_LAYER(l), "Track Already Exists" );
2305       return NULL;
2306     }
2307
2308     g_hash_table_lookup_extended ( l->tracks, sublayer, (void *)&orig_key, (void *)&tr );
2309     g_hash_table_steal ( l->tracks, sublayer );
2310
2311     iter = g_hash_table_lookup ( l->tracks_iters, sublayer );
2312     g_hash_table_steal ( l->tracks_iters, sublayer );
2313
2314     rv = g_strdup(newname);
2315     for ( i = strlen(rv) - 1; i >= 0; i-- )
2316       rv[i] = toupper(rv[i]);
2317
2318     vik_treeview_item_set_pointer ( VIK_LAYER(l)->vt, iter, rv );
2319
2320     g_hash_table_insert ( l->tracks, rv, tr );
2321     g_hash_table_insert ( l->tracks_iters, rv, iter );
2322
2323     /* don't forget about current_tp_track_name, update that too */
2324     if ( l->current_tp_track_name && g_strcasecmp(orig_key,l->current_tp_track_name) == 0 )
2325     {
2326       l->current_tp_track_name = rv;
2327       if ( l->tpwin )
2328         vik_trw_layer_tpwin_set_track_name ( l->tpwin, rv );
2329     }
2330     else if ( l->last_tp_track_name && g_strcasecmp(orig_key,l->last_tp_track_name) == 0 )
2331       l->last_tp_track_name = rv;
2332
2333     g_free ( orig_key );
2334
2335 #ifdef VIK_CONFIG_ALPHABETIZED_TRW
2336     vik_treeview_sublayer_realphabetize ( VIK_LAYER(l)->vt, iter, rv );
2337 #endif
2338
2339     vik_layers_panel_emit_update ( VIK_LAYERS_PANEL(vlp) );
2340     return rv;
2341   }
2342   return NULL;
2343 }
2344
2345 static gboolean is_valid_geocache_name ( gchar *str )
2346 {
2347   gint len = strlen ( str );
2348   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]));
2349 }
2350
2351 static gboolean is_valid_google_route ( VikTrwLayer *vtl, const gchar *track_name )
2352 {
2353   VikTrack *tr = g_hash_table_lookup ( vtl->tracks, track_name );
2354   return ( tr && tr->comment && strlen(tr->comment) > 7 && !strncmp(tr->comment, "from:", 5) );
2355 }
2356
2357 static void trw_layer_track_google_route_webpage( gpointer *pass_along )
2358 {
2359   gchar *track_name = (gchar *) pass_along[3];
2360   VikTrack *tr = g_hash_table_lookup ( VIK_TRW_LAYER(pass_along[0])->tracks, track_name );
2361   if ( tr ) {
2362     gchar *escaped = uri_escape ( tr->comment );
2363     gchar *webpage = g_strdup_printf("http://maps.google.com/maps?f=q&hl=en&q=%s", escaped );
2364     GError *err = NULL;
2365     gchar *cmd = g_strdup_printf ( "%s %s", UNIX_WEB_BROWSER, webpage );
2366
2367     if ( ! g_spawn_command_line_async ( cmd, &err ) )
2368     {
2369       a_dialog_error_msg ( VIK_GTK_WINDOW_FROM_LAYER(VIK_LAYER(pass_along[0])), "Could not launch web browser." );
2370       g_error_free ( err );
2371     }
2372     g_free ( escaped );
2373     g_free ( cmd );
2374     g_free ( webpage );
2375   }
2376 }
2377
2378 /* vlp can be NULL if necessary - i.e. right-click from a tool -- but be careful, some functions may try to use it */
2379 gboolean vik_trw_layer_sublayer_add_menu_items ( VikTrwLayer *l, GtkMenu *menu, gpointer vlp, gint subtype, gpointer sublayer, GtkTreeIter *iter )
2380 {
2381   static GtkTreeIter staticiter;
2382   static gpointer pass_along[5];
2383   GtkWidget *item;
2384   gboolean rv = FALSE;
2385
2386   pass_along[0] = l;
2387   pass_along[1] = vlp;
2388   pass_along[2] = (gpointer) subtype;
2389   pass_along[3] = sublayer;
2390   staticiter = *iter; /* will exist after function has ended */
2391   pass_along[4] = &staticiter;
2392
2393   if ( subtype == VIK_TRW_LAYER_SUBLAYER_WAYPOINT || subtype == VIK_TRW_LAYER_SUBLAYER_TRACK )
2394   {
2395     rv = TRUE;
2396
2397     item = gtk_image_menu_item_new_from_stock ( GTK_STOCK_PROPERTIES, NULL );
2398     g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_properties_item), pass_along );
2399     gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
2400     gtk_widget_show ( item );
2401
2402     if (subtype == VIK_TRW_LAYER_SUBLAYER_TRACK) {
2403       VikTrwLayer *vtl = l;
2404       VikTrack *tr = g_hash_table_lookup ( vtl->tracks, sublayer );
2405       if (tr && tr->property_dialog)
2406         gtk_widget_set_sensitive(GTK_WIDGET(item), FALSE );
2407     }
2408
2409     item = gtk_image_menu_item_new_from_stock ( GTK_STOCK_CUT, NULL );
2410     g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_cut_item_cb), pass_along );
2411     gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
2412     gtk_widget_show ( item );
2413
2414     item = gtk_image_menu_item_new_from_stock ( GTK_STOCK_COPY, NULL );
2415     g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_copy_item_cb), pass_along );
2416     gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
2417     gtk_widget_show ( item );
2418
2419     item = gtk_image_menu_item_new_from_stock ( GTK_STOCK_DELETE, NULL );
2420     g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_delete_item), pass_along );
2421     gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
2422     gtk_widget_show ( item );
2423
2424     if ( subtype == VIK_TRW_LAYER_SUBLAYER_WAYPOINT )
2425     {
2426       /* could be a right-click using the tool */
2427       if ( vlp != NULL ) {
2428         item = gtk_menu_item_new_with_label ( "Goto" );
2429         g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_goto_waypoint), pass_along );
2430         gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
2431         gtk_widget_show ( item );
2432       }
2433
2434       if ( is_valid_geocache_name ( (gchar *) sublayer ) )
2435       {
2436         item = gtk_menu_item_new_with_label ( "Visit Geocache Webpage" );
2437         g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_waypoint_gc_webpage), pass_along );
2438         gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
2439         gtk_widget_show ( item );
2440       }
2441
2442     }
2443   }
2444
2445   if ( subtype == VIK_TRW_LAYER_SUBLAYER_TRACK )
2446   {
2447     item = gtk_menu_item_new ();
2448     gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
2449     gtk_widget_show ( item );
2450
2451     item = gtk_menu_item_new_with_label ( "Goto Startpoint" );
2452     g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_goto_track_startpoint), pass_along );
2453     gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
2454     gtk_widget_show ( item );
2455
2456     item = gtk_menu_item_new_with_label ( "Goto \"Center\"" );
2457     g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_goto_track_center), pass_along );
2458     gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
2459     gtk_widget_show ( item );
2460
2461     item = gtk_menu_item_new_with_label ( "Goto Endpoint" );
2462     g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_goto_track_endpoint), pass_along );
2463     gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
2464     gtk_widget_show ( item );
2465
2466     item = gtk_menu_item_new_with_label ( "Merge By Time" );
2467     g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_merge_by_timestamp), pass_along );
2468     gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
2469     gtk_widget_show ( item );
2470
2471     item = gtk_menu_item_new_with_label ( "Split By Time" );
2472     g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_split_by_timestamp), pass_along );
2473     gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
2474     gtk_widget_show ( item );
2475
2476     item = gtk_menu_item_new_with_label ( "Download maps along track..." );
2477     g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_download_map_along_track_cb), pass_along );
2478     gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
2479     gtk_widget_show ( item );
2480
2481     item = gtk_menu_item_new_with_label ( "Apply DEM Data" );
2482     g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_apply_dem_data), pass_along );
2483     gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
2484     gtk_widget_show ( item );
2485
2486     item = gtk_menu_item_new_with_label ( "Extend track end" );
2487     g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_extend_track_end), pass_along );
2488     gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
2489     gtk_widget_show ( item );
2490
2491 #ifdef VIK_CONFIG_OPENSTREETMAP
2492     item = gtk_menu_item_new_with_label ( "Upload to OSM" );
2493     g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(osm_traces_upload_track_cb), pass_along );
2494     gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
2495     gtk_widget_show ( item );
2496 #endif
2497
2498     if ( is_valid_google_route ( l, (gchar *) sublayer ) )
2499     {
2500       item = gtk_menu_item_new_with_label ( "View Google Directions" );
2501       g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_track_google_route_webpage), pass_along );
2502       gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
2503       gtk_widget_show ( item );
2504     }
2505
2506   }
2507
2508   if ( vlp && (subtype == VIK_TRW_LAYER_SUBLAYER_WAYPOINTS || subtype == VIK_TRW_LAYER_SUBLAYER_WAYPOINT) )
2509   {
2510     item = gtk_menu_item_new ();
2511     gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
2512     gtk_widget_show ( item );
2513
2514     item = gtk_menu_item_new_with_label ( "New Waypoint" );
2515     g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_new_wp), pass_along );
2516     gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
2517     gtk_widget_show ( item );
2518   }
2519
2520   return rv;
2521 }
2522
2523
2524 /* to be called when last_tpl no long exists. */
2525 static void trw_layer_cancel_last_tp ( VikTrwLayer *vtl )
2526 {
2527   if ( vtl->tpwin ) /* can't join with a non-existant TP. */
2528     vik_trw_layer_tpwin_disable_join ( vtl->tpwin );
2529   vtl->last_tpl = NULL;
2530   vtl->last_tp_track_name = NULL;
2531 }
2532
2533 static void trw_layer_cancel_current_tp ( VikTrwLayer *vtl, gboolean destroy )
2534 {
2535   if ( vtl->tpwin )
2536   {
2537     if ( destroy)
2538     {
2539       gtk_widget_destroy ( GTK_WIDGET(vtl->tpwin) );
2540       vtl->tpwin = NULL;
2541     }
2542     else
2543       vik_trw_layer_tpwin_set_empty ( vtl->tpwin );
2544   }
2545   if ( vtl->current_tpl )
2546   {
2547     vtl->current_tpl = NULL;
2548     vtl->current_tp_track_name = NULL;
2549     vik_layer_emit_update(VIK_LAYER(vtl));
2550   }
2551 }
2552
2553 static void trw_layer_tpwin_response ( VikTrwLayer *vtl, gint response )
2554 {
2555   g_assert ( vtl->tpwin != NULL );
2556   if ( response == VIK_TRW_LAYER_TPWIN_CLOSE )
2557     trw_layer_cancel_current_tp ( vtl, TRUE );
2558   else if ( response == VIK_TRW_LAYER_TPWIN_SPLIT && vtl->current_tpl->next && vtl->current_tpl->prev )
2559   {
2560     gchar *name;
2561     if ( ( name = a_dialog_new_track ( GTK_WINDOW(vtl->tpwin), vtl->tracks ) ) )
2562     {
2563       VikTrack *tr = vik_track_new ();
2564       GList *newglist = g_list_alloc ();
2565       newglist->prev = NULL;
2566       newglist->next = vtl->current_tpl->next;
2567       newglist->data = vik_trackpoint_copy(VIK_TRACKPOINT(vtl->current_tpl->data));
2568       tr->trackpoints = newglist;
2569
2570       vtl->current_tpl->next->prev = newglist; /* end old track here */
2571       vtl->current_tpl->next = NULL;
2572
2573       vtl->current_tpl = newglist; /* change tp to first of new track. */
2574       vtl->current_tp_track_name = name;
2575
2576       vik_trw_layer_tpwin_set_tp ( vtl->tpwin, vtl->current_tpl, vtl->current_tp_track_name );
2577
2578       vik_trw_layer_add_track ( vtl, name, tr );
2579       vik_layer_emit_update(VIK_LAYER(vtl));
2580     }
2581   }
2582   else if ( response == VIK_TRW_LAYER_TPWIN_DELETE )
2583   {
2584     VikTrack *tr = g_hash_table_lookup ( vtl->tracks, vtl->current_tp_track_name );
2585     GList *new_tpl;
2586     g_assert(tr != NULL);
2587
2588     /* can't join with a non-existent trackpoint */
2589     vtl->last_tpl = NULL;
2590     vtl->last_tp_track_name = NULL;
2591
2592     if ( (new_tpl = vtl->current_tpl->next) || (new_tpl = vtl->current_tpl->prev) )
2593     {
2594       if ( VIK_TRACKPOINT(vtl->current_tpl->data)->newsegment && vtl->current_tpl->next )
2595         VIK_TRACKPOINT(vtl->current_tpl->next->data)->newsegment = TRUE; /* don't concat segments on del */
2596
2597       tr->trackpoints = g_list_remove_link ( tr->trackpoints, vtl->current_tpl ); /* this nulls current_tpl->prev and next */
2598
2599       /* at this point the old trackpoint exists, but the list links are correct (new), so it is safe to do this. */
2600       vik_trw_layer_tpwin_set_tp ( vtl->tpwin, new_tpl, vtl->current_tp_track_name );
2601
2602       trw_layer_cancel_last_tp ( vtl );
2603
2604       g_free ( vtl->current_tpl->data ); /* TODO: vik_trackpoint_free() */
2605       g_list_free_1 ( vtl->current_tpl );
2606       vtl->current_tpl = new_tpl;
2607       vik_layer_emit_update(VIK_LAYER(vtl));
2608     }
2609     else
2610     {
2611       tr->trackpoints = g_list_remove_link ( tr->trackpoints, vtl->current_tpl );
2612       g_free ( vtl->current_tpl->data ); /* TODO longone: vik_trackpoint_new() and vik_trackpoint_free() */
2613       g_list_free_1 ( vtl->current_tpl );
2614       trw_layer_cancel_current_tp ( vtl, FALSE );
2615     }
2616   }
2617   else if ( response == VIK_TRW_LAYER_TPWIN_FORWARD && vtl->current_tpl->next )
2618   {
2619     vtl->last_tpl = vtl->current_tpl;
2620     vik_trw_layer_tpwin_set_tp ( vtl->tpwin, vtl->current_tpl = vtl->current_tpl->next, vtl->current_tp_track_name );
2621     vik_layer_emit_update(VIK_LAYER(vtl)); /* TODO longone: either move or only update if tp is inside drawing window */
2622   }
2623   else if ( response == VIK_TRW_LAYER_TPWIN_BACK && vtl->current_tpl->prev )
2624   {
2625     vtl->last_tpl = vtl->current_tpl;
2626     vik_trw_layer_tpwin_set_tp ( vtl->tpwin, vtl->current_tpl = vtl->current_tpl->prev, vtl->current_tp_track_name );
2627     vik_layer_emit_update(VIK_LAYER(vtl));
2628   }
2629   else if ( response == VIK_TRW_LAYER_TPWIN_JOIN )
2630   {
2631     VikTrack *tr1 = g_hash_table_lookup ( vtl->tracks, vtl->last_tp_track_name );
2632     VikTrack *tr2 = g_hash_table_lookup ( vtl->tracks, vtl->current_tp_track_name );
2633
2634     VikTrack *tr_first = tr1, *tr_last = tr2;
2635
2636     gchar *tmp;
2637
2638     if ( (!vtl->last_tpl->next) && (!vtl->current_tpl->next) ) /* both endpoints */
2639       vik_track_reverse ( tr2 ); /* reverse the second, that way second track clicked will be later. */
2640     else if ( (!vtl->last_tpl->prev) && (!vtl->current_tpl->prev) )
2641       vik_track_reverse ( tr1 );
2642     else if ( (!vtl->last_tpl->prev) && (!vtl->current_tpl->next) ) /* clicked startpoint, then endpoint -- concat end to start */
2643     {
2644       tr_first = tr2;
2645       tr_last = tr1;
2646     }
2647     /* default -- clicked endpoint then startpoint -- connect endpoint to startpoint */
2648
2649     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. */
2650       VIK_TRACKPOINT(tr_last->trackpoints->data)->newsegment = FALSE;
2651     tr1->trackpoints = g_list_concat ( tr_first->trackpoints, tr_last->trackpoints );
2652     tr2->trackpoints = NULL;
2653
2654     tmp = vtl->current_tp_track_name;
2655
2656     vtl->current_tp_track_name = vtl->last_tp_track_name; /* current_tp stays the same (believe it or not!) */
2657     vik_trw_layer_tpwin_set_tp ( vtl->tpwin, vtl->current_tpl, vtl->current_tp_track_name );
2658
2659     /* if we did this before, trw_layer_delete_track would have canceled the current tp because
2660      * it was the current track. canceling the current tp would have set vtl->current_tpl to NULL */
2661     vik_trw_layer_delete_track ( vtl, tmp );
2662
2663     trw_layer_cancel_last_tp ( vtl ); /* same TP, can't join. */
2664     vik_layer_emit_update(VIK_LAYER(vtl));
2665   }
2666   else if ( response == VIK_TRW_LAYER_TPWIN_DATA_CHANGED )
2667     vik_layer_emit_update (VIK_LAYER(vtl));
2668 }
2669
2670 static void trw_layer_tpwin_init ( VikTrwLayer *vtl )
2671 {
2672   if ( ! vtl->tpwin )
2673   {
2674     vtl->tpwin = vik_trw_layer_tpwin_new ( VIK_GTK_WINDOW_FROM_LAYER(vtl) );
2675     g_signal_connect_swapped ( GTK_DIALOG(vtl->tpwin), "response", G_CALLBACK(trw_layer_tpwin_response), vtl );
2676     /* connect signals -- DELETE SIGNAL VERY IMPORTANT TO SET TO NULL */
2677     g_signal_connect_swapped ( vtl->tpwin, "delete-event", G_CALLBACK(trw_layer_cancel_current_tp), vtl );
2678     gtk_widget_show_all ( GTK_WIDGET(vtl->tpwin) );
2679   }
2680   if ( vtl->current_tpl )
2681     vik_trw_layer_tpwin_set_tp ( vtl->tpwin, vtl->current_tpl, vtl->current_tp_track_name );
2682   /* set layer name and TP data */
2683 }
2684
2685 /***************************************************************************
2686  ** Tool code
2687  ***************************************************************************/
2688
2689 /*** Utility data structures and functions ****/
2690
2691 typedef struct {
2692   gint x, y;
2693   gint closest_x, closest_y;
2694   gchar *closest_wp_name;
2695   VikWaypoint *closest_wp;
2696   VikViewport *vvp;
2697 } WPSearchParams;
2698
2699 typedef struct {
2700   gint x, y;
2701   gint closest_x, closest_y;
2702   gchar *closest_track_name;
2703   VikTrackpoint *closest_tp;
2704   VikViewport *vvp;
2705   GList *closest_tpl;
2706 } TPSearchParams;
2707
2708 static void waypoint_search_closest_tp ( gchar *name, VikWaypoint *wp, WPSearchParams *params )
2709 {
2710   gint x, y;
2711   if ( !wp->visible )
2712     return;
2713
2714   vik_viewport_coord_to_screen ( params->vvp, &(wp->coord), &x, &y );
2715
2716   if ( abs (x - params->x) <= WAYPOINT_SIZE_APPROX && abs (y - params->y) <= WAYPOINT_SIZE_APPROX &&
2717       ((!params->closest_wp) ||        /* was the old waypoint we already found closer than this one? */
2718         abs(x - params->x)+abs(y - params->y) < abs(x - params->closest_x)+abs(y - params->closest_y)))
2719   {
2720     params->closest_wp_name = name;
2721     params->closest_wp = wp;
2722     params->closest_x = x;
2723     params->closest_y = y;
2724   }
2725 }
2726
2727 static void track_search_closest_tp ( gchar *name, VikTrack *t, TPSearchParams *params )
2728 {
2729   GList *tpl = t->trackpoints;
2730   VikTrackpoint *tp;
2731
2732   if ( !t->visible )
2733     return;
2734
2735   while (tpl)
2736   {
2737     gint x, y;
2738     tp = VIK_TRACKPOINT(tpl->data);
2739
2740     vik_viewport_coord_to_screen ( params->vvp, &(tp->coord), &x, &y );
2741
2742     if ( abs (x - params->x) <= TRACKPOINT_SIZE_APPROX && abs (y - params->y) <= TRACKPOINT_SIZE_APPROX &&
2743         ((!params->closest_tp) ||        /* was the old trackpoint we already found closer than this one? */
2744           abs(x - params->x)+abs(y - params->y) < abs(x - params->closest_x)+abs(y - params->closest_y)))
2745     {
2746       params->closest_track_name = name;
2747       params->closest_tp = tp;
2748       params->closest_tpl = tpl;
2749       params->closest_x = x;
2750       params->closest_y = y;
2751     }
2752     tpl = tpl->next;
2753   }
2754 }
2755
2756 static VikTrackpoint *closest_tp_in_five_pixel_interval ( VikTrwLayer *vtl, VikViewport *vvp, gint x, gint y )
2757 {
2758   TPSearchParams params;
2759   params.x = x;
2760   params.y = y;
2761   params.vvp = vvp;
2762   params.closest_track_name = NULL;
2763   params.closest_tp = NULL;
2764   g_hash_table_foreach ( vtl->tracks, (GHFunc) track_search_closest_tp, &params);
2765   return params.closest_tp;
2766 }
2767
2768 static VikWaypoint *closest_wp_in_five_pixel_interval ( VikTrwLayer *vtl, VikViewport *vvp, gint x, gint y )
2769 {
2770   WPSearchParams params;
2771   params.x = x;
2772   params.y = y;
2773   params.vvp = vvp;
2774   params.closest_wp = NULL;
2775   params.closest_wp_name = NULL;
2776   g_hash_table_foreach ( vtl->waypoints, (GHFunc) waypoint_search_closest_tp, &params);
2777   return params.closest_wp;
2778 }
2779
2780 /* background drawing hook, to be passed the viewport */
2781 static gboolean tool_sync_done = TRUE;
2782
2783 static gboolean tool_sync(gpointer data)
2784 {
2785   VikViewport *vvp = data;
2786   gdk_threads_enter();
2787   vik_viewport_sync(vvp);
2788   tool_sync_done = TRUE;
2789   gdk_threads_leave();
2790   return FALSE;
2791 }
2792
2793 typedef struct {
2794   VikViewport *vvp;
2795   gboolean holding;
2796   GdkGC *gc;
2797   int oldx, oldy;
2798 } tool_ed_t;
2799
2800 static void marker_begin_move ( tool_ed_t *t, gint x, gint y )
2801 {
2802   t->holding = TRUE;
2803   t->gc = vik_viewport_new_gc (t->vvp, "black", 2);
2804   gdk_gc_set_function ( t->gc, GDK_INVERT );
2805   vik_viewport_draw_rectangle ( t->vvp, t->gc, FALSE, x-3, y-3, 6, 6 );
2806   vik_viewport_sync(t->vvp);
2807   t->oldx = x;
2808   t->oldy = y;
2809 }
2810
2811 static void marker_moveto ( tool_ed_t *t, gint x, gint y )
2812 {
2813   VikViewport *vvp =  t->vvp;
2814   vik_viewport_draw_rectangle ( vvp, t->gc, FALSE, t->oldx-3, t->oldy-3, 6, 6 );
2815   vik_viewport_draw_rectangle ( vvp, t->gc, FALSE, x-3, y-3, 6, 6 );
2816   t->oldx = x;
2817   t->oldy = y;
2818
2819   if (tool_sync_done) {
2820     g_idle_add_full (G_PRIORITY_HIGH_IDLE + 10, tool_sync, vvp, NULL);
2821     tool_sync_done = FALSE;
2822   }
2823 }
2824
2825 static void marker_end_move ( tool_ed_t *t )
2826 {
2827   vik_viewport_draw_rectangle ( t->vvp, t->gc, FALSE, t->oldx-3, t->oldy-3, 6, 6 );
2828   g_object_unref ( t->gc );
2829   t->holding = FALSE;
2830 }
2831
2832 /*** Edit waypoint ****/
2833
2834 static gpointer tool_edit_waypoint_create ( VikWindow *vw, VikViewport *vvp)
2835 {
2836   tool_ed_t *t = g_new(tool_ed_t, 1);
2837   t->vvp = vvp;
2838   t->holding = FALSE;
2839   return t;
2840 }
2841
2842 static gboolean tool_edit_waypoint_click ( VikTrwLayer *vtl, GdkEventButton *event, gpointer data )
2843 {
2844   WPSearchParams params;
2845   tool_ed_t *t = data;
2846   VikViewport *vvp = t->vvp;
2847
2848   if (!vtl || vtl->vl.type != VIK_LAYER_TRW)
2849     return FALSE;
2850
2851   if ( t->holding ) {
2852     return TRUE;
2853   }
2854
2855   if ( vtl->current_wp && vtl->current_wp->visible )
2856   {
2857     /* first check if current WP is within area (other may be 'closer', but we want to move the current) */
2858     gint x, y;
2859     vik_viewport_coord_to_screen ( vvp, &(vtl->current_wp->coord), &x, &y );
2860
2861     if ( abs(x - event->x) <= WAYPOINT_SIZE_APPROX &&
2862          abs(y - event->y) <= WAYPOINT_SIZE_APPROX )
2863     {
2864       if ( event->button == 3 )
2865         vtl->waypoint_rightclick = TRUE; /* remember that we're clicking; other layers will ignore release signal */
2866       else {
2867         marker_begin_move(t, event->x, event->y);
2868       }
2869       return TRUE;
2870     }
2871   }
2872
2873   params.vvp = vvp;
2874   params.x = event->x;
2875   params.y = event->y;
2876   params.closest_wp_name = NULL;
2877   /* TODO: should get track listitem so we can break it up, make a new track, mess it up, all that. */
2878   params.closest_wp = NULL;
2879   g_hash_table_foreach ( vtl->waypoints, (GHFunc) waypoint_search_closest_tp, &params);
2880   if ( vtl->current_wp == params.closest_wp && vtl->current_wp != NULL )
2881   {
2882     /* how do we get here? I'm putting in the abort until we can figure it out. -alex */
2883     marker_begin_move(t, event->x, event->y);
2884     g_critical("shouldn't be here");
2885     exit(1);
2886   }
2887   else if ( params.closest_wp )
2888   {
2889     if ( event->button == 3 )
2890       vtl->waypoint_rightclick = TRUE; /* remember that we're clicking; other layers will ignore release signal */
2891     else
2892       vtl->waypoint_rightclick = FALSE;
2893
2894     vtl->current_wp = params.closest_wp;
2895     vtl->current_wp_name = params.closest_wp_name;
2896
2897     if ( params.closest_wp )
2898       vik_treeview_select_iter ( VIK_LAYER(vtl)->vt, g_hash_table_lookup ( vtl->waypoints_iters, vtl->current_wp_name ) );
2899
2900     /* could make it so don't update if old WP is off screen and new is null but oh well */
2901     vik_layer_emit_update ( VIK_LAYER(vtl) );
2902     return TRUE;
2903   }
2904
2905   vtl->current_wp = NULL;
2906   vtl->current_wp_name = NULL;
2907   vtl->waypoint_rightclick = FALSE;
2908   vik_layer_emit_update ( VIK_LAYER(vtl) );
2909   return FALSE;
2910 }
2911
2912 static gboolean tool_edit_waypoint_move ( VikTrwLayer *vtl, GdkEventButton *event, gpointer data )
2913 {
2914   tool_ed_t *t = data;
2915   VikViewport *vvp = t->vvp;
2916
2917   if (!vtl || vtl->vl.type != VIK_LAYER_TRW)
2918     return FALSE;
2919
2920   if ( t->holding ) {
2921     VikCoord new_coord;
2922     vik_viewport_screen_to_coord ( vvp, event->x, event->y, &new_coord );
2923
2924     /* snap to TP */
2925     if ( event->state & GDK_CONTROL_MASK )
2926     {
2927       VikTrackpoint *tp = closest_tp_in_five_pixel_interval ( vtl, vvp, event->x, event->y );
2928       if ( tp )
2929         new_coord = tp->coord;
2930     }
2931
2932     /* snap to WP */
2933     if ( event->state & GDK_SHIFT_MASK )
2934     {
2935       VikWaypoint *wp = closest_wp_in_five_pixel_interval ( vtl, vvp, event->x, event->y );
2936       if ( wp && wp != vtl->current_wp )
2937         new_coord = wp->coord;
2938     }
2939
2940     {
2941       gint x, y;
2942       vik_viewport_coord_to_screen ( vvp, &new_coord, &x, &y );
2943
2944       marker_moveto ( t, x, y );
2945     }
2946     return TRUE;
2947   }
2948   return FALSE;
2949 }
2950
2951 static gboolean tool_edit_waypoint_release ( VikTrwLayer *vtl, GdkEventButton *event, gpointer data )
2952 {
2953   tool_ed_t *t = data;
2954   VikViewport *vvp = t->vvp;
2955
2956   if (!vtl || vtl->vl.type != VIK_LAYER_TRW)
2957     return FALSE;
2958
2959   if ( t->holding && event->button == 1 )
2960   {
2961     VikCoord new_coord;
2962     vik_viewport_screen_to_coord ( vvp, event->x, event->y, &new_coord );
2963
2964     /* snap to TP */
2965     if ( event->state & GDK_CONTROL_MASK )
2966     {
2967       VikTrackpoint *tp = closest_tp_in_five_pixel_interval ( vtl, vvp, event->x, event->y );
2968       if ( tp )
2969         new_coord = tp->coord;
2970     }
2971
2972     /* snap to WP */
2973     if ( event->state & GDK_SHIFT_MASK )
2974     {
2975       VikWaypoint *wp = closest_wp_in_five_pixel_interval ( vtl, vvp, event->x, event->y );
2976       if ( wp && wp != vtl->current_wp )
2977         new_coord = wp->coord;
2978     }
2979
2980     marker_end_move ( t );
2981
2982     vtl->current_wp->coord = new_coord;
2983     vik_layer_emit_update ( VIK_LAYER(vtl) );
2984     return TRUE;
2985   }
2986   /* PUT IN RIGHT PLACE!!! */
2987   if ( event->button == 3 && vtl->waypoint_rightclick )
2988   {
2989     if ( vtl->wp_right_click_menu )
2990       gtk_object_sink ( GTK_OBJECT(vtl->wp_right_click_menu) );
2991     vtl->wp_right_click_menu = GTK_MENU ( gtk_menu_new () );
2992     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  ) );
2993     gtk_menu_popup ( vtl->wp_right_click_menu, NULL, NULL, NULL, NULL, event->button, gtk_get_current_event_time() );
2994     vtl->waypoint_rightclick = FALSE;
2995   }
2996   return FALSE;
2997 }
2998
2999 /**** Begin track ***/
3000 static gpointer tool_begin_track_create ( VikWindow *vw, VikViewport *vvp)
3001 {
3002   return vvp;
3003 }
3004
3005 static gboolean tool_begin_track_click ( VikTrwLayer *vtl, GdkEventButton *event, VikViewport *vvp )
3006 {
3007   vtl->current_track = NULL;
3008   return tool_new_track_click ( vtl, event, vvp );
3009 }
3010
3011 /*** New track ****/
3012
3013 static gpointer tool_new_track_create ( VikWindow *vw, VikViewport *vvp)
3014 {
3015   return vvp;
3016 }
3017
3018 typedef struct {
3019   VikTrwLayer *vtl;
3020   VikViewport *vvp;
3021   gint x1,y1,x2,y2;
3022 } new_track_move_passalong_t;
3023
3024 /* sync and undraw, but only when we have time */
3025 static gboolean ct_sync ( gpointer passalong )
3026 {
3027   new_track_move_passalong_t *p = (new_track_move_passalong_t *) passalong;
3028   vik_viewport_sync ( p->vvp );
3029   gdk_gc_set_function ( p->vtl->current_track_gc, GDK_INVERT );
3030   vik_viewport_draw_line ( p->vvp, p->vtl->current_track_gc, p->x1, p->y1, p->x2, p->y2 );
3031   gdk_gc_set_function ( p->vtl->current_track_gc, GDK_COPY );
3032   p->vtl->ct_sync_done = TRUE;
3033   g_free ( p );
3034   return FALSE;
3035 }
3036
3037 static VikLayerToolFuncStatus tool_new_track_move ( VikTrwLayer *vtl, GdkEventButton *event, VikViewport *vvp )
3038 {
3039   /* if we haven't sync'ed yet, we don't have time to do more. */
3040   if ( vtl->ct_sync_done && vtl->current_track && vtl->current_track->trackpoints ) {
3041     GList *iter = vtl->current_track->trackpoints;
3042     new_track_move_passalong_t *passalong;
3043     gint x1, y1;
3044
3045     while ( iter->next )
3046       iter = iter->next;
3047     gdk_gc_set_function ( vtl->current_track_gc, GDK_INVERT );
3048     vik_viewport_coord_to_screen ( vvp, &(VIK_TRACKPOINT(iter->data)->coord), &x1, &y1 );
3049     vik_viewport_draw_line ( vvp, vtl->current_track_gc, x1, y1, event->x, event->y );
3050     gdk_gc_set_function ( vtl->current_track_gc, GDK_COPY );
3051
3052     passalong = g_new(new_track_move_passalong_t,1); /* freed by sync */
3053     passalong->vtl = vtl;
3054     passalong->vvp = vvp;
3055     passalong->x1 = x1;
3056     passalong->y1 = y1;
3057     passalong->x2 = event->x;
3058     passalong->y2 = event->y;
3059
3060     /* this will sync and undraw when we have time to */
3061     g_idle_add_full (G_PRIORITY_HIGH_IDLE + 10, ct_sync, passalong, NULL);
3062     vtl->ct_sync_done = FALSE;
3063     return VIK_LAYER_TOOL_ACK_GRAB_FOCUS;
3064   }
3065   return VIK_LAYER_TOOL_ACK;
3066 }
3067
3068 static gboolean tool_new_track_key_press ( VikTrwLayer *vtl, GdkEventKey *event, VikViewport *vvp )
3069 {
3070   if ( vtl->current_track && event->keyval == GDK_Escape ) {
3071     vtl->current_track = NULL;
3072     vik_layer_emit_update ( VIK_LAYER(vtl) );
3073     return TRUE;
3074   } else if ( vtl->current_track && event->keyval == GDK_BackSpace ) {
3075     /* undo */
3076     if ( vtl->current_track->trackpoints )
3077     {
3078       GList *last = g_list_last(vtl->current_track->trackpoints);
3079       g_free ( last->data );
3080       vtl->current_track->trackpoints = g_list_remove_link ( vtl->current_track->trackpoints, last );
3081     }
3082     vik_layer_emit_update ( VIK_LAYER(vtl) );
3083     return TRUE;
3084   }
3085   return FALSE;
3086 }
3087
3088 static gboolean tool_new_track_click ( VikTrwLayer *vtl, GdkEventButton *event, VikViewport *vvp )
3089 {
3090   VikTrackpoint *tp;
3091
3092   if (!vtl || vtl->vl.type != VIK_LAYER_TRW)
3093     return FALSE;
3094
3095   if ( event->button == 3 && vtl->current_track )
3096   {
3097     /* undo */
3098     if ( vtl->current_track->trackpoints )
3099     {
3100       GList *last = g_list_last(vtl->current_track->trackpoints);
3101       g_free ( last->data );
3102       vtl->current_track->trackpoints = g_list_remove_link ( vtl->current_track->trackpoints, last );
3103     }
3104     vik_layer_emit_update ( VIK_LAYER(vtl) );
3105     return TRUE;
3106   }
3107
3108   if ( event->type == GDK_2BUTTON_PRESS )
3109   {
3110     /* subtract last (duplicate from double click) tp then end */
3111     if ( vtl->current_track && vtl->current_track->trackpoints && vtl->ct_x1 == vtl->ct_x2 && vtl->ct_y1 == vtl->ct_y2 )
3112     {
3113       GList *last = g_list_last(vtl->current_track->trackpoints);
3114       g_free ( last->data );
3115       vtl->current_track->trackpoints = g_list_remove_link ( vtl->current_track->trackpoints, last );
3116       /* undo last, then end */
3117       vtl->current_track = NULL;
3118     }
3119     vik_layer_emit_update ( VIK_LAYER(vtl) );
3120     return TRUE;
3121   }
3122
3123   if ( ! vtl->current_track )
3124   {
3125     gchar *name;
3126     if ( ( name = a_dialog_new_track ( VIK_GTK_WINDOW_FROM_LAYER(vtl), vtl->tracks ) ) )
3127     {
3128       vtl->current_track = vik_track_new();
3129       vtl->current_track->visible = TRUE;
3130       vik_trw_layer_add_track ( vtl, name, vtl->current_track );
3131
3132       /* incase it was created by begin track */
3133       vik_window_enable_layer_tool ( VIK_WINDOW(VIK_GTK_WINDOW_FROM_LAYER(vtl)), VIK_LAYER_TRW, TOOL_CREATE_TRACK );
3134     }
3135     else
3136       return TRUE;
3137   }
3138   tp = vik_trackpoint_new();
3139   vik_viewport_screen_to_coord ( vvp, event->x, event->y, &(tp->coord) );
3140
3141   /* snap to other TP */
3142   if ( event->state & GDK_CONTROL_MASK )
3143   {
3144     VikTrackpoint *other_tp = closest_tp_in_five_pixel_interval ( vtl, vvp, event->x, event->y );
3145     if ( other_tp )
3146       tp->coord = other_tp->coord;
3147   }
3148
3149   tp->newsegment = FALSE;
3150   tp->has_timestamp = FALSE;
3151   tp->timestamp = 0;
3152   tp->altitude = VIK_DEFAULT_ALTITUDE;
3153   vtl->current_track->trackpoints = g_list_append ( vtl->current_track->trackpoints, tp );
3154
3155   vtl->ct_x1 = vtl->ct_x2;
3156   vtl->ct_y1 = vtl->ct_y2;
3157   vtl->ct_x2 = event->x;
3158   vtl->ct_y2 = event->y;
3159
3160   vik_layer_emit_update ( VIK_LAYER(vtl) );
3161   return TRUE;
3162 }
3163
3164
3165 /*** New waypoint ****/
3166
3167 static gpointer tool_new_waypoint_create ( VikWindow *vw, VikViewport *vvp)
3168 {
3169   return vvp;
3170 }
3171
3172 static gboolean tool_new_waypoint_click ( VikTrwLayer *vtl, GdkEventButton *event, VikViewport *vvp )
3173 {
3174   VikCoord coord;
3175   if (!vtl || vtl->vl.type != VIK_LAYER_TRW)
3176     return FALSE;
3177   vik_viewport_screen_to_coord ( vvp, event->x, event->y, &coord );
3178   if (vik_trw_layer_new_waypoint ( vtl, VIK_GTK_WINDOW_FROM_LAYER(vtl), &coord ) && VIK_LAYER(vtl)->visible)
3179     vik_layer_emit_update ( VIK_LAYER(vtl) );
3180   return TRUE;
3181 }
3182
3183
3184 /*** Edit trackpoint ****/
3185
3186 static gpointer tool_edit_trackpoint_create ( VikWindow *vw, VikViewport *vvp)
3187 {
3188   tool_ed_t *t = g_new(tool_ed_t, 1);
3189   t->vvp = vvp;
3190   t->holding = FALSE;
3191   return t;
3192 }
3193
3194 static gboolean tool_edit_trackpoint_click ( VikTrwLayer *vtl, GdkEventButton *event, gpointer data )
3195 {
3196   tool_ed_t *t = data;
3197   VikViewport *vvp = t->vvp;
3198   TPSearchParams params;
3199   /* OUTDATED DOCUMENTATION:
3200    find 5 pixel range on each side. then put these UTM, and a pointer
3201    to the winning track name (and maybe the winning track itself), and a
3202    pointer to the winning trackpoint, inside an array or struct. pass
3203    this along, do a foreach on the tracks which will do a foreach on the
3204    trackpoints. */
3205   params.vvp = vvp;
3206   params.x = event->x;
3207   params.y = event->y;
3208   params.closest_track_name = NULL;
3209   /* TODO: should get track listitem so we can break it up, make a new track, mess it up, all that. */
3210   params.closest_tp = NULL;
3211
3212   if ( event->button != 1 )
3213     return FALSE;
3214
3215   if (!vtl || vtl->vl.type != VIK_LAYER_TRW)
3216     return FALSE;
3217
3218   if ( vtl->current_tpl )
3219   {
3220     /* 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.) */
3221     VikTrackpoint *tp = VIK_TRACKPOINT(vtl->current_tpl->data);
3222     VikTrack *current_tr = VIK_TRACK(g_hash_table_lookup(vtl->tracks, vtl->current_tp_track_name));
3223     gint x, y;
3224     g_assert ( current_tr );
3225
3226     vik_viewport_coord_to_screen ( vvp, &(tp->coord), &x, &y );
3227
3228     if ( current_tr->visible &&
3229          abs(x - event->x) < TRACKPOINT_SIZE_APPROX &&
3230          abs(y - event->y) < TRACKPOINT_SIZE_APPROX ) {
3231       marker_begin_move ( t, event->x, event->y );
3232       return TRUE;
3233     }
3234
3235     vtl->last_tpl = vtl->current_tpl;
3236     vtl->last_tp_track_name = vtl->current_tp_track_name;
3237   }
3238
3239   g_hash_table_foreach ( vtl->tracks, (GHFunc) track_search_closest_tp, &params);
3240
3241   if ( params.closest_tp )
3242   {
3243     vtl->current_tpl = params.closest_tpl;
3244     vtl->current_tp_track_name = params.closest_track_name;
3245     vik_treeview_select_iter ( VIK_LAYER(vtl)->vt, g_hash_table_lookup ( vtl->tracks_iters, vtl->current_tp_track_name ) );
3246     trw_layer_tpwin_init ( vtl );
3247     vik_layer_emit_update ( VIK_LAYER(vtl) );
3248     return TRUE;
3249   }
3250
3251   /* these aren't the droids you're looking for */
3252   return FALSE;
3253 }
3254
3255 static gboolean tool_edit_trackpoint_move ( VikTrwLayer *vtl, GdkEventButton *event, gpointer data )
3256 {
3257   tool_ed_t *t = data;
3258   VikViewport *vvp = t->vvp;
3259
3260   if (!vtl || vtl->vl.type != VIK_LAYER_TRW)
3261     return FALSE;
3262
3263   if ( t->holding )
3264   {
3265     VikCoord new_coord;
3266     vik_viewport_screen_to_coord ( vvp, event->x, event->y, &new_coord );
3267
3268     /* snap to TP */
3269     if ( event->state & GDK_CONTROL_MASK )
3270     {
3271       VikTrackpoint *tp = closest_tp_in_five_pixel_interval ( vtl, vvp, event->x, event->y );
3272       if ( tp && tp != vtl->current_tpl->data )
3273         new_coord = tp->coord;
3274     }
3275     //    VIK_TRACKPOINT(vtl->current_tpl->data)->coord = new_coord;
3276     {
3277       gint x, y;
3278       vik_viewport_coord_to_screen ( vvp, &new_coord, &x, &y );
3279       marker_moveto ( t, x, y );
3280     }
3281
3282     return TRUE;
3283   }
3284   return FALSE;
3285 }
3286
3287 static gboolean tool_edit_trackpoint_release ( VikTrwLayer *vtl, GdkEventButton *event, gpointer data )
3288 {
3289   tool_ed_t *t = data;
3290   VikViewport *vvp = t->vvp;
3291
3292   if (!vtl || vtl->vl.type != VIK_LAYER_TRW)
3293     return FALSE;
3294   if ( event->button != 1)
3295     return FALSE;
3296
3297   if ( t->holding ) {
3298     VikCoord new_coord;
3299     vik_viewport_screen_to_coord ( vvp, event->x, event->y, &new_coord );
3300
3301     /* snap to TP */
3302     if ( event->state & GDK_CONTROL_MASK )
3303     {
3304       VikTrackpoint *tp = closest_tp_in_five_pixel_interval ( vtl, vvp, event->x, event->y );
3305       if ( tp && tp != vtl->current_tpl->data )
3306         new_coord = tp->coord;
3307     }
3308
3309     VIK_TRACKPOINT(vtl->current_tpl->data)->coord = new_coord;
3310
3311     marker_end_move ( t );
3312
3313     /* diff dist is diff from orig */
3314     vik_trw_layer_tpwin_set_tp ( vtl->tpwin, vtl->current_tpl, vtl->current_tp_track_name );
3315     /* can't join with itself! */
3316     trw_layer_cancel_last_tp ( vtl );
3317
3318     vik_layer_emit_update ( VIK_LAYER(vtl) );
3319     return TRUE;
3320   }
3321   return FALSE;
3322 }
3323
3324
3325 /*** Magic Scissors ***/
3326 static gpointer tool_magic_scissors_create ( VikWindow *vw, VikViewport *vvp)
3327 {
3328   return vvp;
3329 }
3330
3331 static gboolean tool_magic_scissors_click ( VikTrwLayer *vtl, GdkEventButton *event, VikViewport *vvp )
3332 {
3333   VikCoord tmp;
3334   if ( !vtl ) return FALSE;
3335   vik_viewport_screen_to_coord ( vvp, event->x, event->y, &tmp );
3336   if ( event->button == 3 && vtl->magic_scissors_current_track ) {
3337     VikCoord *new_end;
3338     new_end = vik_track_cut_back_to_double_point ( vtl->magic_scissors_current_track );
3339     if ( new_end ) {
3340       vtl->magic_scissors_coord = *new_end;
3341       g_free ( new_end );
3342       vik_layer_emit_update ( VIK_LAYER(vtl) );
3343       /* remove last ' to:...' */
3344       if ( vtl->magic_scissors_current_track->comment ) {
3345         gchar *last_to = strrchr ( vtl->magic_scissors_current_track->comment, 't' );
3346         if ( last_to && (last_to - vtl->magic_scissors_current_track->comment > 1) ) {
3347           gchar *new_comment = g_strndup ( vtl->magic_scissors_current_track->comment,
3348                                            last_to - vtl->magic_scissors_current_track->comment - 1);
3349           vik_track_set_comment_no_copy ( vtl->magic_scissors_current_track, new_comment );
3350         }
3351       }
3352     }
3353   }
3354   else if ( vtl->magic_scissors_started || (event->state & GDK_CONTROL_MASK && vtl->magic_scissors_current_track) ) {
3355     struct LatLon start, end;
3356     gchar *cmd;
3357
3358     vik_coord_to_latlon ( &(vtl->magic_scissors_coord), &start );
3359     vik_coord_to_latlon ( &(tmp), &end );
3360     cmd = g_strdup_printf(GOOGLE_DIRECTIONS_STRING, start.lat, start.lon, end.lat, end.lon );
3361     vtl->magic_scissors_coord = tmp; /* for continuations */
3362
3363     /* these are checked when adding a track from a file (vik_trw_layer_filein_add_track) */
3364     if ( event->state & GDK_CONTROL_MASK && vtl->magic_scissors_current_track ) {
3365       vtl->magic_scissors_append = TRUE;  // merge tracks. keep started true.
3366     } else {
3367       vtl->magic_scissors_check_added_track = TRUE;
3368       vtl->magic_scissors_started = FALSE;
3369     }
3370
3371     a_babel_convert_from_shellcommand ( vtl, cmd, "google", NULL, NULL );
3372     g_free ( cmd );
3373
3374     /* see if anything was done -- a track was added or appended to */
3375     if ( vtl->magic_scissors_check_added_track && vtl->magic_scissors_added_track_name ) {
3376       VikTrack *tr;
3377
3378       tr = g_hash_table_lookup ( vtl->tracks, vtl->magic_scissors_added_track_name );
3379
3380       if ( tr )
3381         vik_track_set_comment_no_copy ( tr, g_strdup_printf("from: %f,%f to: %f%f", start.lat, start.lon, end.lat, end.lon ) );
3382
3383       vtl->magic_scissors_current_track = tr;
3384
3385       g_free ( vtl->magic_scissors_added_track_name );
3386       vtl->magic_scissors_added_track_name = NULL;
3387     } else if ( vtl->magic_scissors_append == FALSE && vtl->magic_scissors_current_track ) {
3388       /* magic_scissors_append was originally TRUE but set to FALSE by filein_add_track */
3389       gchar *new_comment = g_strdup_printf("%s to: %f,%f", vtl->magic_scissors_current_track->comment, end.lat, end.lon );
3390       vik_track_set_comment_no_copy ( vtl->magic_scissors_current_track, new_comment );
3391     }
3392     vtl->magic_scissors_check_added_track = FALSE;
3393     vtl->magic_scissors_append = FALSE;
3394
3395     vik_layer_emit_update ( VIK_LAYER(vtl) );
3396   } else {
3397     vtl->magic_scissors_started = TRUE;
3398     vtl->magic_scissors_coord = tmp;
3399     vtl->magic_scissors_current_track = NULL;
3400   }
3401   return TRUE;
3402 }
3403
3404 /*** Show picture ****/
3405
3406 static gpointer tool_show_picture_create ( VikWindow *vw, VikViewport *vvp)
3407 {
3408   return vvp;
3409 }
3410
3411 /* Params are: vvp, event, last match found or NULL */
3412 static void tool_show_picture_wp ( char *name, VikWaypoint *wp, gpointer params[2] )
3413 {
3414   if ( wp->image && wp->visible )
3415   {
3416     gint x, y, slackx, slacky;
3417     GdkEventButton *event = (GdkEventButton *) params[1];
3418
3419     vik_viewport_coord_to_screen ( VIK_VIEWPORT(params[0]), &(wp->coord), &x, &y );
3420     slackx = wp->image_width / 2;
3421     slacky = wp->image_height / 2;
3422     if (    x <= event->x + slackx && x >= event->x - slackx
3423          && y <= event->y + slacky && y >= event->y - slacky )
3424     {
3425       params[2] = wp->image; /* we've found a match. however continue searching
3426                               * since we want to find the last match -- that
3427                               * is, the match that was drawn last. */
3428     }
3429   }
3430 }
3431
3432 static gboolean tool_show_picture_click ( VikTrwLayer *vtl, GdkEventButton *event, VikViewport *vvp )
3433 {
3434   gpointer params[3] = { vvp, event, NULL };
3435   if (!vtl || vtl->vl.type != VIK_LAYER_TRW)
3436     return FALSE;
3437   g_hash_table_foreach ( vtl->waypoints, (GHFunc) tool_show_picture_wp, params );
3438   if ( params[2] )
3439   {
3440     /* thanks to the Gaim people for showing me ShellExecute and g_spawn_command_line_async */
3441 #ifdef WINDOWS
3442     ShellExecute(NULL, NULL, (char *) params[2], NULL, ".\\", 0);
3443 #else /* WINDOWS */
3444     GError *err = NULL;
3445     gchar *quoted_file = g_shell_quote ( (gchar *) params[2] );
3446     gchar *cmd = g_strdup_printf ( "eog %s", quoted_file );
3447     g_free ( quoted_file );
3448     if ( ! g_spawn_command_line_async ( cmd, &err ) )
3449     {
3450       a_dialog_error_msg ( VIK_GTK_WINDOW_FROM_LAYER(vtl), "Could not launch eog to open file." );
3451       g_error_free ( err );
3452     }
3453     g_free ( cmd );
3454 #endif /* WINDOWS */
3455     return TRUE; /* found a match */
3456   }
3457   else
3458     return FALSE; /* go through other layers, searching for a match */
3459 }
3460
3461 /***************************************************************************
3462  ** End tool code
3463  ***************************************************************************/
3464
3465
3466
3467
3468
3469 static void image_wp_make_list ( char *name, VikWaypoint *wp, GSList **pics )
3470 {
3471   if ( wp->image && ( ! a_thumbnails_exists ( wp->image ) ) )
3472     *pics = g_slist_append ( *pics, (gpointer) g_strdup ( wp->image ) );
3473 }
3474
3475 static void create_thumbnails_thread ( GSList *pics, gpointer threaddata )
3476 {
3477   guint total = g_slist_length(pics), done = 0;
3478   while ( pics )
3479   {
3480     a_thumbnails_create ( (gchar *) pics->data );
3481     a_background_thread_progress ( threaddata, ((gdouble) ++done) / total );
3482     pics = pics->next;
3483   }
3484 }
3485
3486 static void free_pics_slist ( GSList *pics )
3487 {
3488   while ( pics )
3489   {
3490     g_free ( pics->data );
3491     pics = g_slist_delete_link ( pics, pics );
3492   }
3493 }
3494
3495 static void trw_layer_verify_thumbnails ( VikTrwLayer *vtl, GtkWidget *vp )
3496 {
3497   if ( ! vtl->has_verified_thumbnails )
3498   {
3499     GSList *pics = NULL;
3500     g_hash_table_foreach ( vtl->waypoints, (GHFunc) image_wp_make_list, &pics );
3501     if ( pics )
3502     {
3503       gint len = g_slist_length ( pics );
3504       gchar *tmp = g_strdup_printf ( "Creating %d Image Thumbnails...", len );
3505       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 );
3506       g_free ( tmp );
3507     }
3508   }
3509 }
3510
3511 VikCoordMode vik_trw_layer_get_coord_mode ( VikTrwLayer *vtl )
3512 {
3513   return vtl->coord_mode;
3514 }
3515
3516
3517
3518 static void waypoint_convert ( const gchar *name, VikWaypoint *wp, VikCoordMode *dest_mode )
3519 {
3520   vik_coord_convert ( &(wp->coord), *dest_mode );
3521 }
3522
3523 static void track_convert ( const gchar *name, VikTrack *tr, VikCoordMode *dest_mode )
3524 {
3525   vik_track_convert ( tr, *dest_mode );
3526 }
3527
3528 static void trw_layer_change_coord_mode ( VikTrwLayer *vtl, VikCoordMode dest_mode )
3529 {
3530   if ( vtl->coord_mode != dest_mode )
3531   {
3532     vtl->coord_mode = dest_mode;
3533     g_hash_table_foreach ( vtl->waypoints, (GHFunc) waypoint_convert, &dest_mode );
3534     g_hash_table_foreach ( vtl->tracks, (GHFunc) track_convert, &dest_mode );
3535   }
3536 }
3537
3538 VikWaypoint *vik_trw_layer_get_waypoint ( VikTrwLayer *vtl, gchar *name )
3539 {
3540   return g_hash_table_lookup ( vtl->waypoints, name );
3541 }
3542
3543 VikTrack *vik_trw_layer_get_track ( VikTrwLayer *vtl, gchar *name )
3544 {
3545   return g_hash_table_lookup ( vtl->tracks, name );
3546 }
3547
3548 static void vik_trw_layer_set_menu_selection(VikTrwLayer *vtl, guint16 selection)
3549 {
3550   vtl->menu_selection = selection;
3551 }
3552
3553 static guint16 vik_trw_layer_get_menu_selection(VikTrwLayer *vtl)
3554 {
3555   return(vtl->menu_selection);
3556 }
3557
3558 /* ----------- Downloading maps along tracks --------------- */
3559
3560 static int get_download_area_width(VikViewport *vvp, gdouble zoom_level, struct LatLon *wh)
3561 {
3562   /* TODO: calculating based on current size of viewport */
3563   const gdouble w_at_zoom_0_125 = 0.0013;
3564   const gdouble h_at_zoom_0_125 = 0.0011;
3565   gdouble zoom_factor = zoom_level/0.125;
3566
3567   wh->lat = h_at_zoom_0_125 * zoom_factor;
3568   wh->lon = w_at_zoom_0_125 * zoom_factor;
3569
3570   return 0;   /* all OK */
3571 }
3572
3573 static VikCoord *get_next_coord(VikCoord *from, VikCoord *to, struct LatLon *dist, gdouble gradient)
3574 {
3575   if ((dist->lon >= ABS(to->east_west - from->east_west)) &&
3576       (dist->lat >= ABS(to->north_south - from->north_south)))
3577     return NULL;
3578
3579   VikCoord *coord = g_malloc(sizeof(VikCoord));
3580   coord->mode = VIK_COORD_LATLON;
3581
3582   if (ABS(gradient) < 1) {
3583     if (from->east_west > to->east_west)
3584       coord->east_west = from->east_west - dist->lon;
3585     else
3586       coord->east_west = from->east_west + dist->lon;
3587     coord->north_south = gradient * (coord->east_west - from->east_west) + from->north_south;
3588   } else {
3589     if (from->north_south > to->north_south)
3590       coord->north_south = from->north_south - dist->lat;
3591     else
3592       coord->north_south = from->north_south + dist->lat;
3593     coord->east_west = (1/gradient) * (coord->north_south - from->north_south) + from->north_south;
3594   }
3595
3596   return coord;
3597 }
3598
3599 static GList *add_fillins(GList *list, VikCoord *from, VikCoord *to, struct LatLon *dist)
3600 {
3601   /* TODO: handle virtical track (to->east_west - from->east_west == 0) */
3602   gdouble gradient = (to->north_south - from->north_south)/(to->east_west - from->east_west);
3603
3604   VikCoord *next = from;
3605   while (TRUE) {
3606     if ((next = get_next_coord(next, to, dist, gradient)) == NULL)
3607         break;
3608     list = g_list_prepend(list, next);
3609   }
3610
3611   return list;
3612 }
3613
3614 void vik_track_download_map(VikTrack *tr, VikMapsLayer *vml, VikViewport *vvp, gdouble zoom_level)
3615 {
3616   typedef struct _Rect {
3617     VikCoord tl;
3618     VikCoord br;
3619     VikCoord center;
3620   } Rect;
3621 #define GLRECT(iter) ((Rect *)((iter)->data))
3622
3623   struct LatLon wh;
3624   GList *rects_to_download = NULL;
3625   GList *rect_iter;
3626
3627   if (get_download_area_width(vvp, zoom_level, &wh))
3628     return;
3629
3630   GList *iter = tr->trackpoints;
3631   if (!iter)
3632     return;
3633
3634   gboolean new_map = TRUE;
3635   VikCoord *cur_coord, tl, br;
3636   Rect *rect;
3637   while (iter) {
3638     cur_coord = &(VIK_TRACKPOINT(iter->data))->coord;
3639     if (new_map) {
3640       vik_coord_set_area(cur_coord, &wh, &tl, &br);
3641       rect = g_malloc(sizeof(Rect));
3642       rect->tl = tl;
3643       rect->br = br;
3644       rect->center = *cur_coord;
3645       rects_to_download = g_list_prepend(rects_to_download, rect);
3646       new_map = FALSE;
3647       iter = iter->next;
3648       continue;
3649     }
3650     gboolean found = FALSE;
3651     for (rect_iter = rects_to_download; rect_iter; rect_iter = rect_iter->next) {
3652       if (vik_coord_inside(cur_coord, &GLRECT(rect_iter)->tl, &GLRECT(rect_iter)->br)) {
3653         found = TRUE;
3654         break;
3655       }
3656     }
3657     if (found)
3658         iter = iter->next;
3659     else
3660       new_map = TRUE;
3661   }
3662
3663   /* fill-ins for far apart points */
3664   GList *cur_rect, *next_rect;
3665   GList *fillins = NULL;
3666   for (cur_rect = rects_to_download;
3667       (next_rect = cur_rect->next) != NULL;
3668       cur_rect = cur_rect->next) {
3669     if ((wh.lon < ABS(GLRECT(cur_rect)->center.east_west - GLRECT(next_rect)->center.east_west)) ||
3670         (wh.lat < ABS(GLRECT(cur_rect)->center.north_south - GLRECT(next_rect)->center.north_south))) {
3671       fillins = add_fillins(fillins, &GLRECT(cur_rect)->center, &GLRECT(next_rect)->center, &wh);
3672     }
3673   }
3674
3675   if (fillins) {
3676     GList *iter = fillins;
3677     while (iter) {
3678       cur_coord = (VikCoord *)(iter->data);
3679       vik_coord_set_area(cur_coord, &wh, &tl, &br);
3680       rect = g_malloc(sizeof(Rect));
3681       rect->tl = tl;
3682       rect->br = br;
3683       rect->center = *cur_coord;
3684       rects_to_download = g_list_prepend(rects_to_download, rect);
3685       iter = iter->next;
3686     }
3687   }
3688
3689   for (rect_iter = rects_to_download; rect_iter; rect_iter = rect_iter->next) {
3690     maps_layer_download_section_without_redraw(vml, vvp, &(((Rect *)(rect_iter->data))->tl), &(((Rect *)(rect_iter->data))->br), zoom_level);
3691   }
3692
3693   if (fillins) {
3694     for (iter = fillins; iter; iter = iter->next)
3695       g_free(iter->data);
3696     g_list_free(fillins);
3697   }
3698   if (rects_to_download) {
3699     for (rect_iter = rects_to_download; rect_iter; rect_iter = rect_iter->next)
3700       g_free(rect_iter->data);
3701     g_list_free(rects_to_download);
3702   }
3703 }
3704
3705 static void trw_layer_download_map_along_track_cb(gpointer pass_along[6])
3706 {
3707   VikMapsLayer *vml;
3708   gint selected_map, default_map;
3709   gchar *zoomlist[] = {"0.125", "0.25", "0.5", "1", "2", "4", "8", "16", "32", "64", "128", "256", "512", "1024", NULL };
3710   gdouble zoom_vals[] = {0.125, 0.25, 0.5, 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024};
3711   gint selected_zoom, default_zoom;
3712   int i,j;
3713
3714
3715   VikTrwLayer *vtl = pass_along[0];
3716   VikLayersPanel *vlp = pass_along[1];
3717   VikTrack *tr = (VikTrack *) g_hash_table_lookup ( VIK_TRW_LAYER(pass_along[0])->tracks, pass_along[3] );
3718   VikViewport *vvp = vik_window_viewport((VikWindow *)(VIK_GTK_WINDOW_FROM_LAYER(vtl)));
3719
3720   GList *vmls = vik_layers_panel_get_all_layers_of_type(vlp, VIK_LAYER_MAPS);
3721   int num_maps = g_list_length(vmls);
3722
3723   if (!num_maps) {
3724     a_dialog_msg(VIK_GTK_WINDOW_FROM_LAYER(vtl), GTK_MESSAGE_ERROR,"No map layer in use. Create one first", NULL);
3725     return;
3726   }
3727
3728   gchar **map_names = g_malloc(1 + num_maps * sizeof(gpointer));
3729   VikMapsLayer **map_layers = g_malloc(1 + num_maps * sizeof(gpointer));
3730
3731   gchar **np = map_names;
3732   VikMapsLayer **lp = map_layers;
3733   for (i = 0; i < num_maps; i++) {
3734     gboolean dup = FALSE;
3735     vml = (VikMapsLayer *)(vmls->data);
3736     for (j = 0; j < i; j++) { /* no duplicate allowed */
3737       if (vik_maps_layer_get_map_type(vml) == vik_maps_layer_get_map_type(map_layers[j])) {
3738         dup = TRUE;
3739         break;
3740       }
3741     }
3742     if (!dup) {
3743       *lp++ = vml;
3744       *np++ = vik_maps_layer_get_map_label(vml);
3745     }
3746     vmls = vmls->next;
3747   }
3748   *lp = NULL;
3749   *np = NULL;
3750   num_maps = lp - map_layers;
3751
3752   for (default_map = 0; default_map < num_maps; default_map++) {
3753     /* TODO: check for parent layer's visibility */
3754     if (VIK_LAYER(map_layers[default_map])->visible)
3755       break;
3756   }
3757   default_map = (default_map == num_maps) ? 0 : default_map;
3758
3759   gdouble cur_zoom = vik_viewport_get_zoom(vvp);
3760   for (default_zoom = 0; default_zoom < sizeof(zoom_vals)/sizeof(gdouble); default_zoom++) {
3761     if (cur_zoom == zoom_vals[default_zoom])
3762       break;
3763   }
3764   default_zoom = (default_zoom == sizeof(zoom_vals)/sizeof(gdouble)) ? sizeof(zoom_vals)/sizeof(gdouble) - 1 : default_zoom;
3765
3766   if (!a_dialog_map_n_zoom(VIK_GTK_WINDOW_FROM_LAYER(vtl), map_names, default_map, zoomlist, default_zoom, &selected_map, &selected_zoom))
3767     goto done;
3768
3769   vik_track_download_map(tr, map_layers[selected_map], vvp, zoom_vals[selected_zoom]);
3770
3771 done:
3772   for (i = 0; i < num_maps; i++)
3773     g_free(map_names[i]);
3774   g_free(map_names);
3775   g_free(map_layers);
3776
3777   g_list_free(vmls);
3778
3779 }
3780