]> git.street.me.uk Git - andy/viking.git/blame_incremental - src/viktrwlayer.c
projects / andy / viking.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Releasing Viking 1.5
[andy/viking.git] / src / viktrwlayer.c
... / ...
CommitLineData
1/*
2 * viking -- GPS Data and Topo Analyzer, Explorer, and Manager
3 *
4 * Copyright (C) 2003-2007, Evan Battaglia <gtoevan@gmx.net>
5 * Copyright (C) 2005-2008, Alex Foobarian <foobarian@gmail.com>
6 * Copyright (C) 2007, Quy Tonthat <qtonthat@gmail.com>
7 * Copyright (C) 2009, Hein Ragas <viking@ragas.nl>
8 * Copyright (c) 2012, Rob Norris <rw_norris@hotmail.com>
9 * Copyright (c) 2012-2013, Guilhem Bonnefille <guilhem.bonnefille@gmail.com>
10 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
15 *
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, write to the Free Software
23 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24 *
25 */
26/* WARNING: If you go beyond this point, we are NOT responsible for any ill effects on your sanity */
27/* viktrwlayer.c -- 8000+ lines can make a difference in the state of things */
28
29#ifdef HAVE_CONFIG_H
30#include "config.h"
31#endif
32
33#include "viking.h"
34#include "vikmapslayer.h"
35#include "vikgpslayer.h"
36#include "viktrwlayer_tpwin.h"
37#include "viktrwlayer_propwin.h"
38#include "viktrwlayer_analysis.h"
39#include "viktrwlayer_tracklist.h"
40#include "viktrwlayer_waypointlist.h"
41#ifdef VIK_CONFIG_GEOTAG
42#include "viktrwlayer_geotag.h"
43#include "geotag_exif.h"
44#endif
45#include "garminsymbols.h"
46#include "thumbnails.h"
47#include "background.h"
48#include "gpx.h"
49#include "babel.h"
50#include "dem.h"
51#include "dems.h"
52#include "geonamessearch.h"
53#ifdef VIK_CONFIG_OPENSTREETMAP
54#include "osm-traces.h"
55#endif
56#include "acquire.h"
57#include "datasources.h"
58#include "datasource_gps.h"
59#include "vikexttool_datasources.h"
60#include "util.h"
61#include "vikutils.h"
62
63#include "vikrouting.h"
64
65#include "icons/icons.h"
66
67#ifdef HAVE_MATH_H
68#include <math.h>
69#endif
70#ifdef HAVE_STRING_H
71#include <string.h>
72#endif
73#ifdef HAVE_STDLIB_H
74#include <stdlib.h>
75#endif
76#include <stdio.h>
77#include <ctype.h>
78
79#include <gdk/gdkkeysyms.h>
80#include <glib.h>
81#include <glib/gstdio.h>
82#include <glib/gi18n.h>
83
84#define VIK_TRW_LAYER_TRACK_GC 6
85#define VIK_TRW_LAYER_TRACK_GCS 10
86#define VIK_TRW_LAYER_TRACK_GC_BLACK 0
87#define VIK_TRW_LAYER_TRACK_GC_SLOW 1
88#define VIK_TRW_LAYER_TRACK_GC_AVER 2
89#define VIK_TRW_LAYER_TRACK_GC_FAST 3
90#define VIK_TRW_LAYER_TRACK_GC_STOP 4
91#define VIK_TRW_LAYER_TRACK_GC_SINGLE 5
92
93#define DRAWMODE_BY_TRACK 0
94#define DRAWMODE_BY_SPEED 1
95#define DRAWMODE_ALL_SAME_COLOR 2
96// Note using DRAWMODE_BY_SPEED may be slow especially for vast numbers of trackpoints
97// as we are (re)calculating the colour for every point
98
99#define POINTS 1
100#define LINES 2
101
102/* this is how it knows when you click if you are clicking close to a trackpoint. */
103#define TRACKPOINT_SIZE_APPROX 5
104#define WAYPOINT_SIZE_APPROX 5
105
106#define MIN_STOP_LENGTH 15
107#define MAX_STOP_LENGTH 86400
108#define DRAW_ELEVATION_FACTOR 30 /* height of elevation plotting, sort of relative to zoom level ("mpp" that isn't mpp necessarily) */
109 /* this is multiplied by user-inputted value from 1-100. */
110
111enum { WP_SYMBOL_FILLED_SQUARE, WP_SYMBOL_SQUARE, WP_SYMBOL_CIRCLE, WP_SYMBOL_X, WP_NUM_SYMBOLS };
112
113// See http://developer.gnome.org/pango/stable/PangoMarkupFormat.html
114typedef enum {
115 FS_XX_SMALL = 0, // 'xx-small'
116 FS_X_SMALL,
117 FS_SMALL,
118 FS_MEDIUM, // DEFAULT
119 FS_LARGE,
120 FS_X_LARGE,
121 FS_XX_LARGE,
122 FS_NUM_SIZES
123} font_size_t;
124
125struct _VikTrwLayer {
126 VikLayer vl;
127 GHashTable *tracks;
128 GHashTable *tracks_iters;
129 GHashTable *routes;
130 GHashTable *routes_iters;
131 GHashTable *waypoints_iters;
132 GHashTable *waypoints;
133 GtkTreeIter tracks_iter, routes_iter, waypoints_iter;
134 gboolean tracks_visible, routes_visible, waypoints_visible;
135 LatLonBBox waypoints_bbox;
136
137 gboolean track_draw_labels;
138 guint8 drawmode;
139 guint8 drawpoints;
140 guint8 drawpoints_size;
141 guint8 drawelevation;
142 guint8 elevation_factor;
143 guint8 drawstops;
144 guint32 stop_length;
145 guint8 drawlines;
146 guint8 drawdirections;
147 guint8 drawdirections_size;
148 guint8 line_thickness;
149 guint8 bg_line_thickness;
150 vik_layer_sort_order_t track_sort_order;
151
152 PangoLayout *tracklabellayout;
153 font_size_t track_font_size;
154 gchar *track_fsize_str;
155
156 guint8 wp_symbol;
157 guint8 wp_size;
158 gboolean wp_draw_symbols;
159 font_size_t wp_font_size;
160 gchar *wp_fsize_str;
161 vik_layer_sort_order_t wp_sort_order;
162
163 gdouble track_draw_speed_factor;
164 GArray *track_gc;
165 GdkGC *track_1color_gc;
166 GdkColor track_color;
167 GdkGC *current_track_gc;
168 // Separate GC for a track's potential new point as drawn via separate method
169 // (compared to the actual track points drawn in the main trw_layer_draw_track function)
170 GdkGC *current_track_newpoint_gc;
171 GdkGC *track_bg_gc; GdkColor track_bg_color;
172 GdkGC *waypoint_gc; GdkColor waypoint_color;
173 GdkGC *waypoint_text_gc; GdkColor waypoint_text_color;
174 GdkGC *waypoint_bg_gc; GdkColor waypoint_bg_color;
175 gboolean wpbgand;
176 GdkFont *waypoint_font;
177 VikTrack *current_track; // ATM shared between new tracks and new routes
178 guint16 ct_x1, ct_y1, ct_x2, ct_y2;
179 gboolean draw_sync_done;
180 gboolean draw_sync_do;
181
182 VikCoordMode coord_mode;
183
184 /* wp editing tool */
185 VikWaypoint *current_wp;
186 gpointer current_wp_id;
187 gboolean moving_wp;
188 gboolean waypoint_rightclick;
189
190 /* track editing tool */
191 GList *current_tpl;
192 VikTrack *current_tp_track;
193 gpointer current_tp_id;
194 VikTrwLayerTpwin *tpwin;
195
196 /* track editing tool -- more specifically, moving tps */
197 gboolean moving_tp;
198
199 /* route finder tool */
200 gboolean route_finder_started;
201 VikCoord route_finder_coord;
202 gboolean route_finder_check_added_track;
203 VikTrack *route_finder_added_track;
204 VikTrack *route_finder_current_track;
205 gboolean route_finder_append;
206
207 gboolean drawlabels;
208 gboolean drawimages;
209 guint8 image_alpha;
210 GQueue *image_cache;
211 guint8 image_size;
212 guint16 image_cache_size;
213
214 /* for waypoint text */
215 PangoLayout *wplabellayout;
216
217 gboolean has_verified_thumbnails;
218
219 GtkMenu *wp_right_click_menu;
220 GtkMenu *track_right_click_menu;
221
222 /* menu */
223 VikStdLayerMenuItem menu_selection;
224
225 gint highest_wp_number;
226
227 // One per layer
228 GtkWidget *tracks_analysis_dialog;
229};
230
231/* A caached waypoint image. */
232typedef struct {
233 GdkPixbuf *pixbuf;
234 gchar *image; /* filename */
235} CachedPixbuf;
236
237struct DrawingParams {
238 VikViewport *vp;
239 VikTrwLayer *vtl;
240 VikWindow *vw;
241 gdouble xmpp, ympp;
242 guint16 width, height;
243 gdouble cc; // Cosine factor in track directions
244 gdouble ss; // Sine factor in track directions
245 const VikCoord *center;
246 gboolean one_zone, lat_lon;
247 gdouble ce1, ce2, cn1, cn2;
248 LatLonBBox bbox;
249};
250
251static gboolean trw_layer_delete_waypoint ( VikTrwLayer *vtl, VikWaypoint *wp );
252
253static void trw_layer_delete_item ( gpointer pass_along[6] );
254static void trw_layer_copy_item_cb ( gpointer pass_along[6] );
255static void trw_layer_cut_item_cb ( gpointer pass_along[6] );
256
257static void trw_layer_find_maxmin_tracks ( const gpointer id, const VikTrack *trk, struct LatLon maxmin[2] );
258static void trw_layer_find_maxmin (VikTrwLayer *vtl, struct LatLon maxmin[2]);
259
260static void trw_layer_new_track_gcs ( VikTrwLayer *vtl, VikViewport *vp );
261static void trw_layer_free_track_gcs ( VikTrwLayer *vtl );
262
263static void trw_layer_draw_track_cb ( const gpointer id, VikTrack *track, struct DrawingParams *dp );
264static void trw_layer_draw_waypoint ( const gpointer id, VikWaypoint *wp, struct DrawingParams *dp );
265
266static void goto_coord ( gpointer *vlp, gpointer vvp, gpointer vl, const VikCoord *coord );
267static void trw_layer_goto_track_startpoint ( gpointer pass_along[6] );
268static void trw_layer_goto_track_endpoint ( gpointer pass_along[6] );
269static void trw_layer_goto_track_max_speed ( gpointer pass_along[6] );
270static void trw_layer_goto_track_max_alt ( gpointer pass_along[6] );
271static void trw_layer_goto_track_min_alt ( gpointer pass_along[6] );
272static void trw_layer_goto_track_center ( gpointer pass_along[6] );
273static void trw_layer_merge_by_segment ( gpointer pass_along[6] );
274static void trw_layer_merge_by_timestamp ( gpointer pass_along[6] );
275static void trw_layer_merge_with_other ( gpointer pass_along[6] );
276static void trw_layer_append_track ( gpointer pass_along[6] );
277static void trw_layer_split_by_timestamp ( gpointer pass_along[6] );
278static void trw_layer_split_by_n_points ( gpointer pass_along[6] );
279static void trw_layer_split_at_trackpoint ( gpointer pass_along[6] );
280static void trw_layer_split_segments ( gpointer pass_along[6] );
281static void trw_layer_delete_point_selected ( gpointer pass_along[6] );
282static void trw_layer_delete_points_same_position ( gpointer pass_along[6] );
283static void trw_layer_delete_points_same_time ( gpointer pass_along[6] );
284static void trw_layer_reverse ( gpointer pass_along[6] );
285static void trw_layer_download_map_along_track_cb ( gpointer pass_along[6] );
286static void trw_layer_edit_trackpoint ( gpointer pass_along[6] );
287static void trw_layer_show_picture ( gpointer pass_along[6] );
288static void trw_layer_gps_upload_any ( gpointer pass_along[6] );
289
290static void trw_layer_centerize ( gpointer layer_and_vlp[2] );
291static void trw_layer_auto_view ( gpointer layer_and_vlp[2] );
292static void trw_layer_export ( gpointer layer_and_vlp[2], const gchar* title, const gchar* default_name, VikTrack* trk, guint file_type );
293static void trw_layer_goto_wp ( gpointer layer_and_vlp[2] );
294static void trw_layer_new_wp ( gpointer lav[2] );
295static void trw_layer_new_track ( gpointer lav[2] );
296static void trw_layer_new_route ( gpointer lav[2] );
297static void trw_layer_finish_track ( gpointer lav[2] );
298static void trw_layer_auto_waypoints_view ( gpointer lav[2] );
299static void trw_layer_auto_tracks_view ( gpointer lav[2] );
300static void trw_layer_delete_all_tracks ( gpointer lav[2] );
301static void trw_layer_delete_tracks_from_selection ( gpointer lav[2] );
302static void trw_layer_delete_all_waypoints ( gpointer lav[2] );
303static void trw_layer_delete_waypoints_from_selection ( gpointer lav[2] );
304static void trw_layer_new_wikipedia_wp_viewport ( gpointer lav[2] );
305static void trw_layer_new_wikipedia_wp_layer ( gpointer lav[2] );
306#ifdef VIK_CONFIG_GEOTAG
307static void trw_layer_geotagging_waypoint_mtime_keep ( gpointer pass_along[6] );
308static void trw_layer_geotagging_waypoint_mtime_update ( gpointer pass_along[6] );
309static void trw_layer_geotagging_track ( gpointer pass_along[6] );
310static void trw_layer_geotagging ( gpointer lav[2] );
311#endif
312static void trw_layer_acquire_gps_cb ( gpointer lav[2] );
313static void trw_layer_acquire_routing_cb ( gpointer lav[2] );
314static void trw_layer_acquire_url_cb ( gpointer lav[2] );
315#ifdef VIK_CONFIG_OPENSTREETMAP
316static void trw_layer_acquire_osm_cb ( gpointer lav[2] );
317static void trw_layer_acquire_osm_my_traces_cb ( gpointer lav[2] );
318#endif
319#ifdef VIK_CONFIG_GEOCACHES
320static void trw_layer_acquire_geocache_cb ( gpointer lav[2] );
321#endif
322#ifdef VIK_CONFIG_GEOTAG
323static void trw_layer_acquire_geotagged_cb ( gpointer lav[2] );
324#endif
325static void trw_layer_acquire_file_cb ( gpointer lav[2] );
326static void trw_layer_gps_upload ( gpointer lav[2] );
327
328static void trw_layer_track_list_dialog_single ( gpointer pass_along[6] );
329static void trw_layer_track_list_dialog ( gpointer lav[2] );
330static void trw_layer_waypoint_list_dialog ( gpointer lav[2] );
331
332// Specific route versions:
333// Most track handling functions can handle operating on the route list
334// However these ones are easier in separate functions
335static void trw_layer_auto_routes_view ( gpointer lav[2] );
336static void trw_layer_delete_all_routes ( gpointer lav[2] );
337static void trw_layer_delete_routes_from_selection ( gpointer lav[2] );
338
339/* pop-up items */
340static void trw_layer_properties_item ( gpointer pass_along[7] );
341static void trw_layer_goto_waypoint ( gpointer pass_along[6] );
342static void trw_layer_waypoint_gc_webpage ( gpointer pass_along[6] );
343static void trw_layer_waypoint_webpage ( gpointer pass_along[6] );
344
345static void trw_layer_realize_waypoint ( gpointer id, VikWaypoint *wp, gpointer pass_along[5] );
346static void trw_layer_realize_track ( gpointer id, VikTrack *track, gpointer pass_along[5] );
347static void init_drawing_params ( struct DrawingParams *dp, VikTrwLayer *vtl, VikViewport *vp );
348
349static void trw_layer_insert_tp_beside_current_tp ( VikTrwLayer *vtl, gboolean );
350static void trw_layer_cancel_current_tp ( VikTrwLayer *vtl, gboolean destroy );
351static void trw_layer_tpwin_response ( VikTrwLayer *vtl, gint response );
352static void trw_layer_tpwin_init ( VikTrwLayer *vtl );
353
354static gpointer tool_edit_trackpoint_create ( VikWindow *vw, VikViewport *vvp);
355static void tool_edit_trackpoint_destroy ( tool_ed_t *t );
356static gboolean tool_edit_trackpoint_click ( VikTrwLayer *vtl, GdkEventButton *event, gpointer data );
357static gboolean tool_edit_trackpoint_move ( VikTrwLayer *vtl, GdkEventMotion *event, gpointer data );
358static gboolean tool_edit_trackpoint_release ( VikTrwLayer *vtl, GdkEventButton *event, gpointer data );
359static gpointer tool_show_picture_create ( VikWindow *vw, VikViewport *vvp);
360static gboolean tool_show_picture_click ( VikTrwLayer *vtl, GdkEventButton *event, VikViewport *vvp );
361static gpointer tool_edit_waypoint_create ( VikWindow *vw, VikViewport *vvp);
362static void tool_edit_waypoint_destroy ( tool_ed_t *t );
363static gboolean tool_edit_waypoint_click ( VikTrwLayer *vtl, GdkEventButton *event, gpointer data );
364static gboolean tool_edit_waypoint_move ( VikTrwLayer *vtl, GdkEventMotion *event, gpointer data );
365static gboolean tool_edit_waypoint_release ( VikTrwLayer *vtl, GdkEventButton *event, gpointer data );
366static gpointer tool_new_route_create ( VikWindow *vw, VikViewport *vvp);
367static gboolean tool_new_route_click ( VikTrwLayer *vtl, GdkEventButton *event, VikViewport *vvp );
368static gpointer tool_new_track_create ( VikWindow *vw, VikViewport *vvp);
369static gboolean tool_new_track_click ( VikTrwLayer *vtl, GdkEventButton *event, VikViewport *vvp );
370static VikLayerToolFuncStatus tool_new_track_move ( VikTrwLayer *vtl, GdkEventMotion *event, VikViewport *vvp );
371static void tool_new_track_release ( VikTrwLayer *vtl, GdkEventButton *event, VikViewport *vvp );
372static gboolean tool_new_track_key_press ( VikTrwLayer *vtl, GdkEventKey *event, VikViewport *vvp );
373static gpointer tool_new_waypoint_create ( VikWindow *vw, VikViewport *vvp);
374static gboolean tool_new_waypoint_click ( VikTrwLayer *vtl, GdkEventButton *event, VikViewport *vvp );
375static gpointer tool_route_finder_create ( VikWindow *vw, VikViewport *vvp);
376static gboolean tool_route_finder_click ( VikTrwLayer *vtl, GdkEventButton *event, VikViewport *vvp );
377
378static void cached_pixbuf_free ( CachedPixbuf *cp );
379static gint cached_pixbuf_cmp ( CachedPixbuf *cp, const gchar *name );
380
381static VikTrackpoint *closest_tp_in_five_pixel_interval ( VikTrwLayer *vtl, VikViewport *vvp, gint x, gint y );
382static VikWaypoint *closest_wp_in_five_pixel_interval ( VikTrwLayer *vtl, VikViewport *vvp, gint x, gint y );
383
384static void waypoint_convert ( const gpointer id, VikWaypoint *wp, VikCoordMode *dest_mode );
385static void track_convert ( const gpointer id, VikTrack *tr, VikCoordMode *dest_mode );
386
387static gchar *highest_wp_number_get(VikTrwLayer *vtl);
388static void highest_wp_number_reset(VikTrwLayer *vtl);
389static void highest_wp_number_add_wp(VikTrwLayer *vtl, const gchar *new_wp_name);
390static void highest_wp_number_remove_wp(VikTrwLayer *vtl, const gchar *old_wp_name);
391
392// Note for the following tool GtkRadioActionEntry texts:
393// the very first text value is an internal name not displayed anywhere
394// the first N_ text value is the name used for menu entries - hence has an underscore for the keyboard accelerator
395// * remember not to clash with the values used for VikWindow level tools (Pan, Zoom, Ruler + Select)
396// the second N_ text value is used for the button tooltip (i.e. generally don't want an underscore here)
397// the value is always set to 0 and the tool loader in VikWindow will set the actual appropriate value used
398static VikToolInterface trw_layer_tools[] = {
399 { { "CreateWaypoint", "vik-icon-Create Waypoint", N_("Create _Waypoint"), "<control><shift>W", N_("Create Waypoint"), 0 },
400 (VikToolConstructorFunc) tool_new_waypoint_create, NULL, NULL, NULL,
401 (VikToolMouseFunc) tool_new_waypoint_click, NULL, NULL, (VikToolKeyFunc) NULL,
402 FALSE,
403 GDK_CURSOR_IS_PIXMAP, &cursor_addwp_pixbuf },
404
405 { { "CreateTrack", "vik-icon-Create Track", N_("Create _Track"), "<control><shift>T", N_("Create Track"), 0 },
406 (VikToolConstructorFunc) tool_new_track_create, NULL, NULL, NULL,
407 (VikToolMouseFunc) tool_new_track_click,
408 (VikToolMouseMoveFunc) tool_new_track_move,
409 (VikToolMouseFunc) tool_new_track_release,
410 (VikToolKeyFunc) tool_new_track_key_press,
411 TRUE, // Still need to handle clicks when in PAN mode to disable the potential trackpoint drawing
412 GDK_CURSOR_IS_PIXMAP, &cursor_addtr_pixbuf },
413
414 { { "CreateRoute", "vik-icon-Create Route", N_("Create _Route"), "<control><shift>B", N_("Create Route"), 0 },
415 (VikToolConstructorFunc) tool_new_route_create, NULL, NULL, NULL,
416 (VikToolMouseFunc) tool_new_route_click,
417 (VikToolMouseMoveFunc) tool_new_track_move, // -\#
418 (VikToolMouseFunc) tool_new_track_release, // -> Reuse these track methods on a route
419 (VikToolKeyFunc) tool_new_track_key_press, // -/#
420 TRUE, // Still need to handle clicks when in PAN mode to disable the potential trackpoint drawing
421 GDK_CURSOR_IS_PIXMAP, &cursor_new_route_pixbuf },
422
423 { { "EditWaypoint", "vik-icon-Edit Waypoint", N_("_Edit Waypoint"), "<control><shift>E", N_("Edit Waypoint"), 0 },
424 (VikToolConstructorFunc) tool_edit_waypoint_create,
425 (VikToolDestructorFunc) tool_edit_waypoint_destroy,
426 NULL, NULL,
427 (VikToolMouseFunc) tool_edit_waypoint_click,
428 (VikToolMouseMoveFunc) tool_edit_waypoint_move,
429 (VikToolMouseFunc) tool_edit_waypoint_release, (VikToolKeyFunc) NULL,
430 FALSE,
431 GDK_CURSOR_IS_PIXMAP, &cursor_edwp_pixbuf },
432
433 { { "EditTrackpoint", "vik-icon-Edit Trackpoint", N_("Edit Trac_kpoint"), "<control><shift>K", N_("Edit Trackpoint"), 0 },
434 (VikToolConstructorFunc) tool_edit_trackpoint_create,
435 (VikToolDestructorFunc) tool_edit_trackpoint_destroy,
436 NULL, NULL,
437 (VikToolMouseFunc) tool_edit_trackpoint_click,
438 (VikToolMouseMoveFunc) tool_edit_trackpoint_move,
439 (VikToolMouseFunc) tool_edit_trackpoint_release, (VikToolKeyFunc) NULL,
440 FALSE,
441 GDK_CURSOR_IS_PIXMAP, &cursor_edtr_pixbuf },
442
443 { { "ShowPicture", "vik-icon-Show Picture", N_("Show P_icture"), "<control><shift>I", N_("Show Picture"), 0 },
444 (VikToolConstructorFunc) tool_show_picture_create, NULL, NULL, NULL,
445 (VikToolMouseFunc) tool_show_picture_click, NULL, NULL, (VikToolKeyFunc) NULL,
446 FALSE,
447 GDK_CURSOR_IS_PIXMAP, &cursor_showpic_pixbuf },
448
449 { { "RouteFinder", "vik-icon-Route Finder", N_("Route _Finder"), "<control><shift>F", N_("Route Finder"), 0 },
450 (VikToolConstructorFunc) tool_route_finder_create, NULL, NULL, NULL,
451 (VikToolMouseFunc) tool_route_finder_click, NULL, NULL, (VikToolKeyFunc) NULL,
452 FALSE,
453 GDK_CURSOR_IS_PIXMAP, &cursor_route_finder_pixbuf },
454};
455
456enum {
457 TOOL_CREATE_WAYPOINT=0,
458 TOOL_CREATE_TRACK,
459 TOOL_CREATE_ROUTE,
460 TOOL_EDIT_WAYPOINT,
461 TOOL_EDIT_TRACKPOINT,
462 TOOL_SHOW_PICTURE,
463 TOOL_ROUTE_FINDER,
464 NUM_TOOLS
465};
466
467/****** PARAMETERS ******/
468
469static gchar *params_groups[] = { N_("Waypoints"), N_("Tracks"), N_("Waypoint Images"), N_("Tracks Advanced") };
470enum { GROUP_WAYPOINTS, GROUP_TRACKS, GROUP_IMAGES, GROUP_TRACKS_ADV };
471
472static gchar *params_drawmodes[] = { N_("Draw by Track"), N_("Draw by Speed"), N_("All Tracks Same Color"), NULL };
473static gchar *params_wpsymbols[] = { N_("Filled Square"), N_("Square"), N_("Circle"), N_("X"), 0 };
474
475#define MIN_POINT_SIZE 2
476#define MAX_POINT_SIZE 10
477
478#define MIN_ARROW_SIZE 3
479#define MAX_ARROW_SIZE 20
480
481static VikLayerParamScale params_scales[] = {
482 /* min max step digits */
483 { 1, 10, 1, 0 }, /* line_thickness */
484 { 0, 100, 1, 0 }, /* track draw speed factor */
485 { 1.0, 100.0, 1.0, 2 }, /* UNUSED */
486 /* 5 * step == how much to turn */
487 { 16, 128, 4, 0 }, // 3: image_size - NB step size ignored when an HSCALE used
488 { 0, 255, 5, 0 }, // 4: image alpha - " " " "
489 { 5, 500, 5, 0 }, // 5: image cache_size - " "
490 { 0, 8, 1, 0 }, // 6: Background line thickness
491 { 1, 64, 1, 0 }, /* wpsize */
492 { MIN_STOP_LENGTH, MAX_STOP_LENGTH, 1, 0 }, /* stop_length */
493 { 1, 100, 1, 0 }, // 9: elevation factor
494 { MIN_POINT_SIZE, MAX_POINT_SIZE, 1, 0 }, // 10: track point size
495 { MIN_ARROW_SIZE, MAX_ARROW_SIZE, 1, 0 }, // 11: direction arrow size
496};
497
498static gchar* params_font_sizes[] = {
499 N_("Extra Extra Small"),
500 N_("Extra Small"),
501 N_("Small"),
502 N_("Medium"),
503 N_("Large"),
504 N_("Extra Large"),
505 N_("Extra Extra Large"),
506 NULL };
507
508// Needs to align with vik_layer_sort_order_t
509static gchar* params_sort_order[] = {
510 N_("None"),
511 N_("Name Ascending"),
512 N_("Name Descending"),
513 NULL
514};
515
516static VikLayerParamData black_color_default ( void ) {
517 VikLayerParamData data; gdk_color_parse ( "#000000", &data.c ); return data; // Black
518}
519static VikLayerParamData drawmode_default ( void ) { return VIK_LPD_UINT ( DRAWMODE_BY_TRACK ); }
520static VikLayerParamData line_thickness_default ( void ) { return VIK_LPD_UINT ( 1 ); }
521static VikLayerParamData trkpointsize_default ( void ) { return VIK_LPD_UINT ( MIN_POINT_SIZE ); }
522static VikLayerParamData trkdirectionsize_default ( void ) { return VIK_LPD_UINT ( 5 ); }
523static VikLayerParamData bg_line_thickness_default ( void ) { return VIK_LPD_UINT ( 0 ); }
524static VikLayerParamData trackbgcolor_default ( void ) {
525 VikLayerParamData data; gdk_color_parse ( "#FFFFFF", &data.c ); return data; // White
526}
527static VikLayerParamData elevation_factor_default ( void ) { return VIK_LPD_UINT ( 30 ); }
528static VikLayerParamData stop_length_default ( void ) { return VIK_LPD_UINT ( 60 ); }
529static VikLayerParamData speed_factor_default ( void ) { return VIK_LPD_DOUBLE ( 30.0 ); }
530
531static VikLayerParamData tnfontsize_default ( void ) { return VIK_LPD_UINT ( FS_MEDIUM ); }
532static VikLayerParamData wpfontsize_default ( void ) { return VIK_LPD_UINT ( FS_MEDIUM ); }
533static VikLayerParamData wptextcolor_default ( void ) {
534 VikLayerParamData data; gdk_color_parse ( "#FFFFFF", &data.c ); return data; // White
535}
536static VikLayerParamData wpbgcolor_default ( void ) {
537 VikLayerParamData data; gdk_color_parse ( "#8383C4", &data.c ); return data; // Kind of Blue
538}
539static VikLayerParamData wpsize_default ( void ) { return VIK_LPD_UINT ( 4 ); }
540static VikLayerParamData wpsymbol_default ( void ) { return VIK_LPD_UINT ( WP_SYMBOL_FILLED_SQUARE ); }
541
542static VikLayerParamData image_size_default ( void ) { return VIK_LPD_UINT ( 64 ); }
543static VikLayerParamData image_alpha_default ( void ) { return VIK_LPD_UINT ( 255 ); }
544static VikLayerParamData image_cache_size_default ( void ) { return VIK_LPD_UINT ( 300 ); }
545
546static VikLayerParamData sort_order_default ( void ) { return VIK_LPD_UINT ( 0 ); }
547
548VikLayerParam trw_layer_params[] = {
549 { VIK_LAYER_TRW, "tracks_visible", VIK_LAYER_PARAM_BOOLEAN, VIK_LAYER_NOT_IN_PROPERTIES, NULL, 0, NULL, NULL, NULL, vik_lpd_true_default, NULL, NULL },
550 { VIK_LAYER_TRW, "waypoints_visible", VIK_LAYER_PARAM_BOOLEAN, VIK_LAYER_NOT_IN_PROPERTIES, NULL, 0, NULL, NULL, NULL, vik_lpd_true_default, NULL, NULL },
551 { VIK_LAYER_TRW, "routes_visible", VIK_LAYER_PARAM_BOOLEAN, VIK_LAYER_NOT_IN_PROPERTIES, NULL, 0, NULL, NULL, NULL, vik_lpd_true_default, NULL, NULL },
552
553 { VIK_LAYER_TRW, "trackdrawlabels", VIK_LAYER_PARAM_BOOLEAN, GROUP_TRACKS, N_("Draw Labels"), VIK_LAYER_WIDGET_CHECKBUTTON, NULL, NULL,
554 N_("Note: the individual track controls what labels may be displayed"), vik_lpd_true_default, NULL, NULL },
555 { VIK_LAYER_TRW, "trackfontsize", VIK_LAYER_PARAM_UINT, GROUP_TRACKS_ADV, N_("Track Labels Font Size:"), VIK_LAYER_WIDGET_COMBOBOX, params_font_sizes, NULL, NULL, tnfontsize_default, NULL, NULL },
556 { VIK_LAYER_TRW, "drawmode", VIK_LAYER_PARAM_UINT, GROUP_TRACKS, N_("Track Drawing Mode:"), VIK_LAYER_WIDGET_COMBOBOX, params_drawmodes, NULL, NULL, drawmode_default, NULL, NULL },
557 { VIK_LAYER_TRW, "trackcolor", VIK_LAYER_PARAM_COLOR, GROUP_TRACKS, N_("All Tracks Color:"), VIK_LAYER_WIDGET_COLOR, NULL, NULL,
558 N_("The color used when 'All Tracks Same Color' drawing mode is selected"), black_color_default, NULL, NULL },
559 { VIK_LAYER_TRW, "drawlines", VIK_LAYER_PARAM_BOOLEAN, GROUP_TRACKS, N_("Draw Track Lines"), VIK_LAYER_WIDGET_CHECKBUTTON, NULL, NULL, NULL, vik_lpd_true_default, NULL, NULL },
560 { VIK_LAYER_TRW, "line_thickness", VIK_LAYER_PARAM_UINT, GROUP_TRACKS_ADV, N_("Track Thickness:"), VIK_LAYER_WIDGET_SPINBUTTON, &params_scales[0], NULL, NULL, line_thickness_default, NULL, NULL },
561 { VIK_LAYER_TRW, "drawdirections", VIK_LAYER_PARAM_BOOLEAN, GROUP_TRACKS, N_("Draw Track Direction"), VIK_LAYER_WIDGET_CHECKBUTTON, NULL, NULL, NULL, vik_lpd_false_default, NULL, NULL },
562 { VIK_LAYER_TRW, "trkdirectionsize", VIK_LAYER_PARAM_UINT, GROUP_TRACKS_ADV, N_("Direction Size:"), VIK_LAYER_WIDGET_SPINBUTTON, &params_scales[11], NULL, NULL, trkdirectionsize_default, NULL, NULL },
563 { VIK_LAYER_TRW, "drawpoints", VIK_LAYER_PARAM_BOOLEAN, GROUP_TRACKS, N_("Draw Trackpoints"), VIK_LAYER_WIDGET_CHECKBUTTON, NULL, NULL, NULL, vik_lpd_true_default, NULL, NULL },
564 { VIK_LAYER_TRW, "trkpointsize", VIK_LAYER_PARAM_UINT, GROUP_TRACKS_ADV, N_("Trackpoint Size:"), VIK_LAYER_WIDGET_SPINBUTTON, &params_scales[10], NULL, NULL, trkpointsize_default, NULL, NULL },
565 { VIK_LAYER_TRW, "drawelevation", VIK_LAYER_PARAM_BOOLEAN, GROUP_TRACKS, N_("Draw Elevation"), VIK_LAYER_WIDGET_CHECKBUTTON, NULL, NULL, NULL, vik_lpd_false_default, NULL, NULL },
566 { VIK_LAYER_TRW, "elevation_factor", VIK_LAYER_PARAM_UINT, GROUP_TRACKS_ADV, N_("Draw Elevation Height %:"), VIK_LAYER_WIDGET_HSCALE, &params_scales[9], NULL, NULL, elevation_factor_default, NULL, NULL },
567 { VIK_LAYER_TRW, "drawstops", VIK_LAYER_PARAM_BOOLEAN, GROUP_TRACKS, N_("Draw Stops"), VIK_LAYER_WIDGET_CHECKBUTTON, NULL, NULL,
568 N_("Whether to draw a marker when trackpoints are at the same position but over the minimum stop length apart in time"), vik_lpd_false_default, NULL, NULL },
569 { VIK_LAYER_TRW, "stop_length", VIK_LAYER_PARAM_UINT, GROUP_TRACKS_ADV, N_("Min Stop Length (seconds):"), VIK_LAYER_WIDGET_SPINBUTTON, &params_scales[8], NULL, NULL, stop_length_default, NULL, NULL },
570
571 { VIK_LAYER_TRW, "bg_line_thickness", VIK_LAYER_PARAM_UINT, GROUP_TRACKS_ADV, N_("Track BG Thickness:"), VIK_LAYER_WIDGET_SPINBUTTON, &params_scales[6], NULL, NULL, bg_line_thickness_default, NULL, NULL },
572 { VIK_LAYER_TRW, "trackbgcolor", VIK_LAYER_PARAM_COLOR, GROUP_TRACKS_ADV, N_("Track Background Color"), VIK_LAYER_WIDGET_COLOR, NULL, NULL, NULL, trackbgcolor_default, NULL, NULL },
573 { VIK_LAYER_TRW, "speed_factor", VIK_LAYER_PARAM_DOUBLE, GROUP_TRACKS_ADV, N_("Draw by Speed Factor (%):"), VIK_LAYER_WIDGET_HSCALE, &params_scales[1], NULL,
574 N_("The percentage factor away from the average speed determining the color used"), speed_factor_default, NULL, NULL },
575 { VIK_LAYER_TRW, "tracksortorder", VIK_LAYER_PARAM_UINT, GROUP_TRACKS_ADV, N_("Track Sort Order:"), VIK_LAYER_WIDGET_COMBOBOX, params_sort_order, NULL, NULL, sort_order_default, NULL, NULL },
576
577 { VIK_LAYER_TRW, "drawlabels", VIK_LAYER_PARAM_BOOLEAN, GROUP_WAYPOINTS, N_("Draw Labels"), VIK_LAYER_WIDGET_CHECKBUTTON, NULL, NULL, NULL, vik_lpd_true_default, NULL, NULL },
578 { VIK_LAYER_TRW, "wpfontsize", VIK_LAYER_PARAM_UINT, GROUP_WAYPOINTS, N_("Waypoint Font Size:"), VIK_LAYER_WIDGET_COMBOBOX, params_font_sizes, NULL, NULL, wpfontsize_default, NULL, NULL },
579 { VIK_LAYER_TRW, "wpcolor", VIK_LAYER_PARAM_COLOR, GROUP_WAYPOINTS, N_("Waypoint Color:"), VIK_LAYER_WIDGET_COLOR, NULL, NULL, NULL, black_color_default, NULL, NULL },
580 { VIK_LAYER_TRW, "wptextcolor", VIK_LAYER_PARAM_COLOR, GROUP_WAYPOINTS, N_("Waypoint Text:"), VIK_LAYER_WIDGET_COLOR, NULL, NULL, NULL, wptextcolor_default, NULL, NULL },
581 { VIK_LAYER_TRW, "wpbgcolor", VIK_LAYER_PARAM_COLOR, GROUP_WAYPOINTS, N_("Background:"), VIK_LAYER_WIDGET_COLOR, NULL, NULL, NULL, wpbgcolor_default, NULL, NULL },
582 { VIK_LAYER_TRW, "wpbgand", VIK_LAYER_PARAM_BOOLEAN, GROUP_WAYPOINTS, N_("Fake BG Color Translucency:"), VIK_LAYER_WIDGET_CHECKBUTTON, NULL, NULL, NULL, vik_lpd_false_default, NULL, NULL },
583 { VIK_LAYER_TRW, "wpsymbol", VIK_LAYER_PARAM_UINT, GROUP_WAYPOINTS, N_("Waypoint marker:"), VIK_LAYER_WIDGET_COMBOBOX, params_wpsymbols, NULL, NULL, wpsymbol_default, NULL, NULL },
584 { VIK_LAYER_TRW, "wpsize", VIK_LAYER_PARAM_UINT, GROUP_WAYPOINTS, N_("Waypoint size:"), VIK_LAYER_WIDGET_SPINBUTTON, &params_scales[7], NULL, NULL, wpsize_default, NULL, NULL },
585 { VIK_LAYER_TRW, "wpsyms", VIK_LAYER_PARAM_BOOLEAN, GROUP_WAYPOINTS, N_("Draw Waypoint Symbols:"), VIK_LAYER_WIDGET_CHECKBUTTON, NULL, NULL, NULL, vik_lpd_true_default, NULL, NULL },
586 { VIK_LAYER_TRW, "wpsortorder", VIK_LAYER_PARAM_UINT, GROUP_WAYPOINTS, N_("Waypoint Sort Order:"), VIK_LAYER_WIDGET_COMBOBOX, params_sort_order, NULL, NULL, sort_order_default, NULL, NULL },
587
588 { VIK_LAYER_TRW, "drawimages", VIK_LAYER_PARAM_BOOLEAN, GROUP_IMAGES, N_("Draw Waypoint Images"), VIK_LAYER_WIDGET_CHECKBUTTON, NULL, NULL, NULL, vik_lpd_true_default, NULL, NULL },
589 { VIK_LAYER_TRW, "image_size", VIK_LAYER_PARAM_UINT, GROUP_IMAGES, N_("Image Size (pixels):"), VIK_LAYER_WIDGET_HSCALE, &params_scales[3], NULL, NULL, image_size_default, NULL, NULL },
590 { VIK_LAYER_TRW, "image_alpha", VIK_LAYER_PARAM_UINT, GROUP_IMAGES, N_("Image Alpha:"), VIK_LAYER_WIDGET_HSCALE, &params_scales[4], NULL, NULL, image_alpha_default, NULL, NULL },
591 { VIK_LAYER_TRW, "image_cache_size", VIK_LAYER_PARAM_UINT, GROUP_IMAGES, N_("Image Memory Cache Size:"), VIK_LAYER_WIDGET_HSCALE, &params_scales[5], NULL, NULL, image_cache_size_default, NULL, NULL },
592};
593
594// ENUMERATION MUST BE IN THE SAME ORDER AS THE NAMED PARAMS ABOVE
595enum {
596 // Sublayer visibilities
597 PARAM_TV,
598 PARAM_WV,
599 PARAM_RV,
600 // Tracks
601 PARAM_TDL,
602 PARAM_TLFONTSIZE,
603 PARAM_DM,
604 PARAM_TC,
605 PARAM_DL,
606 PARAM_LT,
607 PARAM_DD,
608 PARAM_DDS,
609 PARAM_DP,
610 PARAM_DPS,
611 PARAM_DE,
612 PARAM_EF,
613 PARAM_DS,
614 PARAM_SL,
615 PARAM_BLT,
616 PARAM_TBGC,
617 PARAM_TDSF,
618 PARAM_TSO,
619 // Waypoints
620 PARAM_DLA,
621 PARAM_WPFONTSIZE,
622 PARAM_WPC,
623 PARAM_WPTC,
624 PARAM_WPBC,
625 PARAM_WPBA,
626 PARAM_WPSYM,
627 PARAM_WPSIZE,
628 PARAM_WPSYMS,
629 PARAM_WPSO,
630 // WP images
631 PARAM_DI,
632 PARAM_IS,
633 PARAM_IA,
634 PARAM_ICS,
635 NUM_PARAMS
636};
637
638/*** TO ADD A PARAM:
639 *** 1) Add to trw_layer_params and enumeration
640 *** 2) Handle in get_param & set_param (presumably adding on to VikTrwLayer struct)
641 ***/
642
643/****** END PARAMETERS ******/
644
645/* Layer Interface function definitions */
646static VikTrwLayer* trw_layer_create ( VikViewport *vp );
647static void trw_layer_realize ( VikTrwLayer *vtl, VikTreeview *vt, GtkTreeIter *layer_iter );
648static void trw_layer_post_read ( VikTrwLayer *vtl, GtkWidget *vvp, gboolean from_file );
649static void trw_layer_free ( VikTrwLayer *trwlayer );
650static void trw_layer_draw ( VikTrwLayer *l, gpointer data );
651static void trw_layer_change_coord_mode ( VikTrwLayer *vtl, VikCoordMode dest_mode );
652static void trw_layer_set_menu_selection ( VikTrwLayer *vtl, guint16 );
653static guint16 trw_layer_get_menu_selection ( VikTrwLayer *vtl );
654static void trw_layer_add_menu_items ( VikTrwLayer *vtl, GtkMenu *menu, gpointer vlp );
655static gboolean trw_layer_sublayer_add_menu_items ( VikTrwLayer *l, GtkMenu *menu, gpointer vlp, gint subtype, gpointer sublayer, GtkTreeIter *iter, VikViewport *vvp );
656static const gchar* trw_layer_sublayer_rename_request ( VikTrwLayer *l, const gchar *newname, gpointer vlp, gint subtype, gpointer sublayer, GtkTreeIter *iter );
657static gboolean trw_layer_sublayer_toggle_visible ( VikTrwLayer *l, gint subtype, gpointer sublayer );
658static const gchar* trw_layer_layer_tooltip ( VikTrwLayer *vtl );
659static const gchar* trw_layer_sublayer_tooltip ( VikTrwLayer *l, gint subtype, gpointer sublayer );
660static gboolean trw_layer_selected ( VikTrwLayer *l, gint subtype, gpointer sublayer, gint type, gpointer vlp );
661static void trw_layer_marshall ( VikTrwLayer *vtl, guint8 **data, gint *len );
662static VikTrwLayer *trw_layer_unmarshall ( guint8 *data, gint len, VikViewport *vvp );
663static gboolean trw_layer_set_param ( VikTrwLayer *vtl, guint16 id, VikLayerParamData data, VikViewport *vp, gboolean is_file_operation );
664static VikLayerParamData trw_layer_get_param ( VikTrwLayer *vtl, guint16 id, gboolean is_file_operation );
665static void trw_layer_del_item ( VikTrwLayer *vtl, gint subtype, gpointer sublayer );
666static void trw_layer_cut_item ( VikTrwLayer *vtl, gint subtype, gpointer sublayer );
667static void trw_layer_copy_item ( VikTrwLayer *vtl, gint subtype, gpointer sublayer, guint8 **item, guint *len );
668static gboolean trw_layer_paste_item ( VikTrwLayer *vtl, gint subtype, guint8 *item, guint len );
669static void trw_layer_free_copied_item ( gint subtype, gpointer item );
670static void trw_layer_drag_drop_request ( VikTrwLayer *vtl_src, VikTrwLayer *vtl_dest, GtkTreeIter *src_item_iter, GtkTreePath *dest_path );
671static gboolean trw_layer_select_click ( VikTrwLayer *vtl, GdkEventButton *event, VikViewport *vvp, tool_ed_t *t );
672static gboolean trw_layer_select_move ( VikTrwLayer *vtl, GdkEventButton *event, VikViewport *vvp, tool_ed_t *t );
673static gboolean trw_layer_select_release ( VikTrwLayer *vtl, GdkEventButton *event, VikViewport *vvp, tool_ed_t *t );
674static gboolean trw_layer_show_selected_viewport_menu ( VikTrwLayer *vtl, GdkEventButton *event, VikViewport *vvp );
675/* End Layer Interface function definitions */
676
677VikLayerInterface vik_trw_layer_interface = {
678 "TrackWaypoint",
679 N_("TrackWaypoint"),
680 "<control><shift>Y",
681 &viktrwlayer_pixbuf,
682
683 trw_layer_tools,
684 sizeof(trw_layer_tools) / sizeof(VikToolInterface),
685
686 trw_layer_params,
687 NUM_PARAMS,
688 params_groups, /* params_groups */
689 sizeof(params_groups)/sizeof(params_groups[0]), /* number of groups */
690
691 VIK_MENU_ITEM_ALL,
692
693 (VikLayerFuncCreate) trw_layer_create,
694 (VikLayerFuncRealize) trw_layer_realize,
695 (VikLayerFuncPostRead) trw_layer_post_read,
696 (VikLayerFuncFree) trw_layer_free,
697
698 (VikLayerFuncProperties) NULL,
699 (VikLayerFuncDraw) trw_layer_draw,
700 (VikLayerFuncChangeCoordMode) trw_layer_change_coord_mode,
701
702 (VikLayerFuncSetMenuItemsSelection) trw_layer_set_menu_selection,
703 (VikLayerFuncGetMenuItemsSelection) trw_layer_get_menu_selection,
704
705 (VikLayerFuncAddMenuItems) trw_layer_add_menu_items,
706 (VikLayerFuncSublayerAddMenuItems) trw_layer_sublayer_add_menu_items,
707
708 (VikLayerFuncSublayerRenameRequest) trw_layer_sublayer_rename_request,
709 (VikLayerFuncSublayerToggleVisible) trw_layer_sublayer_toggle_visible,
710 (VikLayerFuncSublayerTooltip) trw_layer_sublayer_tooltip,
711 (VikLayerFuncLayerTooltip) trw_layer_layer_tooltip,
712 (VikLayerFuncLayerSelected) trw_layer_selected,
713
714 (VikLayerFuncMarshall) trw_layer_marshall,
715 (VikLayerFuncUnmarshall) trw_layer_unmarshall,
716
717 (VikLayerFuncSetParam) trw_layer_set_param,
718 (VikLayerFuncGetParam) trw_layer_get_param,
719
720 (VikLayerFuncReadFileData) a_gpspoint_read_file,
721 (VikLayerFuncWriteFileData) a_gpspoint_write_file,
722
723 (VikLayerFuncDeleteItem) trw_layer_del_item,
724 (VikLayerFuncCutItem) trw_layer_cut_item,
725 (VikLayerFuncCopyItem) trw_layer_copy_item,
726 (VikLayerFuncPasteItem) trw_layer_paste_item,
727 (VikLayerFuncFreeCopiedItem) trw_layer_free_copied_item,
728
729 (VikLayerFuncDragDropRequest) trw_layer_drag_drop_request,
730
731 (VikLayerFuncSelectClick) trw_layer_select_click,
732 (VikLayerFuncSelectMove) trw_layer_select_move,
733 (VikLayerFuncSelectRelease) trw_layer_select_release,
734 (VikLayerFuncSelectedViewportMenu) trw_layer_show_selected_viewport_menu,
735};
736
737GType vik_trw_layer_get_type ()
738{
739 static GType vtl_type = 0;
740
741 if (!vtl_type)
742 {
743 static const GTypeInfo vtl_info =
744 {
745 sizeof (VikTrwLayerClass),
746 NULL, /* base_init */
747 NULL, /* base_finalize */
748 NULL, /* class init */
749 NULL, /* class_finalize */
750 NULL, /* class_data */
751 sizeof (VikTrwLayer),
752 0,
753 NULL /* instance init */
754 };
755 vtl_type = g_type_register_static ( VIK_LAYER_TYPE, "VikTrwLayer", &vtl_info, 0 );
756 }
757
758 return vtl_type;
759}
760
761static void trw_layer_del_item ( VikTrwLayer *vtl, gint subtype, gpointer sublayer )
762{
763 static gpointer pass_along[6];
764 if (!sublayer) {
765 return;
766 }
767
768 pass_along[0] = vtl;
769 pass_along[1] = NULL;
770 pass_along[2] = GINT_TO_POINTER (subtype);
771 pass_along[3] = sublayer;
772 pass_along[4] = GINT_TO_POINTER (1); // Confirm delete request
773 pass_along[5] = NULL;
774
775 trw_layer_delete_item ( pass_along );
776}
777
778static void trw_layer_cut_item ( VikTrwLayer *vtl, gint subtype, gpointer sublayer )
779{
780 static gpointer pass_along[6];
781 if (!sublayer) {
782 return;
783 }
784
785 pass_along[0] = vtl;
786 pass_along[1] = NULL;
787 pass_along[2] = GINT_TO_POINTER (subtype);
788 pass_along[3] = sublayer;
789 pass_along[4] = GINT_TO_POINTER (0); // No delete confirmation needed for auto delete
790 pass_along[5] = NULL;
791
792 trw_layer_copy_item_cb(pass_along);
793 trw_layer_cut_item_cb(pass_along);
794}
795
796static void trw_layer_copy_item_cb ( gpointer pass_along[6])
797{
798 VikTrwLayer *vtl = VIK_TRW_LAYER(pass_along[0]);
799 gint subtype = GPOINTER_TO_INT (pass_along[2]);
800 gpointer * sublayer = pass_along[3];
801 guint8 *data = NULL;
802 guint len;
803
804 trw_layer_copy_item( vtl, subtype, sublayer, &data, &len);
805
806 if (data) {
807 const gchar* name;
808 if ( subtype == VIK_TRW_LAYER_SUBLAYER_WAYPOINT ) {
809 VikWaypoint *wp = g_hash_table_lookup ( vtl->waypoints, sublayer);
810 if ( wp && wp->name )
811 name = wp->name;
812 else
813 name = NULL; // Broken :(
814 }
815 else if ( subtype == VIK_TRW_LAYER_SUBLAYER_TRACK ) {
816 VikTrack *trk = g_hash_table_lookup ( vtl->tracks, sublayer);
817 if ( trk && trk->name )
818 name = trk->name;
819 else
820 name = NULL; // Broken :(
821 }
822 else {
823 VikTrack *trk = g_hash_table_lookup ( vtl->routes, sublayer);
824 if ( trk && trk->name )
825 name = trk->name;
826 else
827 name = NULL; // Broken :(
828 }
829
830 a_clipboard_copy( VIK_CLIPBOARD_DATA_SUBLAYER, VIK_LAYER_TRW,
831 subtype, len, name, data);
832 }
833}
834
835static void trw_layer_cut_item_cb ( gpointer pass_along[6])
836{
837 trw_layer_copy_item_cb(pass_along);
838 pass_along[4] = GINT_TO_POINTER (0); // Never need to confirm automatic delete
839 trw_layer_delete_item(pass_along);
840}
841
842static void trw_layer_paste_item_cb ( gpointer pass_along[6])
843{
844 // Slightly cheating method, routing via the panels capability
845 a_clipboard_paste (VIK_LAYERS_PANEL(pass_along[1]));
846}
847
848static void trw_layer_copy_item ( VikTrwLayer *vtl, gint subtype, gpointer sublayer, guint8 **item, guint *len )
849{
850 guint8 *id;
851 guint il;
852
853 if (!sublayer) {
854 *item = NULL;
855 return;
856 }
857
858 GByteArray *ba = g_byte_array_new ();
859
860 if ( subtype == VIK_TRW_LAYER_SUBLAYER_WAYPOINT ) {
861 vik_waypoint_marshall ( g_hash_table_lookup ( vtl->waypoints, sublayer ), &id, &il );
862 } else if ( subtype == VIK_TRW_LAYER_SUBLAYER_TRACK ) {
863 vik_track_marshall ( g_hash_table_lookup ( vtl->tracks, sublayer ), &id, &il );
864 } else {
865 vik_track_marshall ( g_hash_table_lookup ( vtl->routes, sublayer ), &id, &il );
866 }
867
868 g_byte_array_append ( ba, id, il );
869
870 g_free(id);
871
872 *len = ba->len;
873 *item = ba->data;
874}
875
876static gboolean trw_layer_paste_item ( VikTrwLayer *vtl, gint subtype, guint8 *item, guint len )
877{
878 if ( !item )
879 return FALSE;
880
881 gchar *name;
882
883 if ( subtype == VIK_TRW_LAYER_SUBLAYER_WAYPOINT )
884 {
885 VikWaypoint *w;
886
887 w = vik_waypoint_unmarshall ( item, len );
888 // When copying - we'll create a new name based on the original
889 name = trw_layer_new_unique_sublayer_name(vtl, VIK_TRW_LAYER_SUBLAYER_WAYPOINT, w->name);
890 vik_trw_layer_add_waypoint ( vtl, name, w );
891 waypoint_convert (NULL, w, &vtl->coord_mode);
892 g_free ( name );
893
894 trw_layer_calculate_bounds_waypoints ( vtl );
895
896 // Consider if redraw necessary for the new item
897 if ( vtl->vl.visible && vtl->waypoints_visible && w->visible )
898 vik_layer_emit_update ( VIK_LAYER(vtl) );
899 return TRUE;
900 }
901 if ( subtype == VIK_TRW_LAYER_SUBLAYER_TRACK )
902 {
903 VikTrack *t;
904
905 t = vik_track_unmarshall ( item, len );
906 // When copying - we'll create a new name based on the original
907 name = trw_layer_new_unique_sublayer_name(vtl, VIK_TRW_LAYER_SUBLAYER_TRACK, t->name);
908 vik_trw_layer_add_track ( vtl, name, t );
909 vik_track_convert (t, vtl->coord_mode);
910 g_free ( name );
911
912 // Consider if redraw necessary for the new item
913 if ( vtl->vl.visible && vtl->tracks_visible && t->visible )
914 vik_layer_emit_update ( VIK_LAYER(vtl) );
915 return TRUE;
916 }
917 if ( subtype == VIK_TRW_LAYER_SUBLAYER_ROUTE )
918 {
919 VikTrack *t;
920
921 t = vik_track_unmarshall ( item, len );
922 // When copying - we'll create a new name based on the original
923 name = trw_layer_new_unique_sublayer_name(vtl, VIK_TRW_LAYER_SUBLAYER_ROUTE, t->name);
924 vik_trw_layer_add_route ( vtl, name, t );
925 vik_track_convert (t, vtl->coord_mode);
926 g_free ( name );
927
928 // Consider if redraw necessary for the new item
929 if ( vtl->vl.visible && vtl->routes_visible && t->visible )
930 vik_layer_emit_update ( VIK_LAYER(vtl) );
931 return TRUE;
932 }
933 return FALSE;
934}
935
936static void trw_layer_free_copied_item ( gint subtype, gpointer item )
937{
938 if (item) {
939 g_free(item);
940 }
941}
942
943static gboolean trw_layer_set_param ( VikTrwLayer *vtl, guint16 id, VikLayerParamData data, VikViewport *vp, gboolean is_file_operation )
944{
945 switch ( id )
946 {
947 case PARAM_TV: vtl->tracks_visible = data.b; break;
948 case PARAM_WV: vtl->waypoints_visible = data.b; break;
949 case PARAM_RV: vtl->routes_visible = data.b; break;
950 case PARAM_TDL: vtl->track_draw_labels = data.b; break;
951 case PARAM_TLFONTSIZE:
952 if ( data.u < FS_NUM_SIZES ) {
953 vtl->track_font_size = data.u;
954 g_free ( vtl->track_fsize_str );
955 switch ( vtl->track_font_size ) {
956 case FS_XX_SMALL: vtl->track_fsize_str = g_strdup ( "xx-small" ); break;
957 case FS_X_SMALL: vtl->track_fsize_str = g_strdup ( "x-small" ); break;
958 case FS_SMALL: vtl->track_fsize_str = g_strdup ( "small" ); break;
959 case FS_LARGE: vtl->track_fsize_str = g_strdup ( "large" ); break;
960 case FS_X_LARGE: vtl->track_fsize_str = g_strdup ( "x-large" ); break;
961 case FS_XX_LARGE: vtl->track_fsize_str = g_strdup ( "xx-large" ); break;
962 default: vtl->track_fsize_str = g_strdup ( "medium" ); break;
963 }
964 }
965 break;
966 case PARAM_DM: vtl->drawmode = data.u; break;
967 case PARAM_TC:
968 vtl->track_color = data.c;
969 if ( vp ) trw_layer_new_track_gcs ( vtl, vp );
970 break;
971 case PARAM_DP: vtl->drawpoints = data.b; break;
972 case PARAM_DPS:
973 if ( data.u >= MIN_POINT_SIZE && data.u <= MAX_POINT_SIZE )
974 vtl->drawpoints_size = data.u;
975 break;
976 case PARAM_DE: vtl->drawelevation = data.b; break;
977 case PARAM_DS: vtl->drawstops = data.b; break;
978 case PARAM_DL: vtl->drawlines = data.b; break;
979 case PARAM_DD: vtl->drawdirections = data.b; break;
980 case PARAM_DDS:
981 if ( data.u >= MIN_ARROW_SIZE && data.u <= MAX_ARROW_SIZE )
982 vtl->drawdirections_size = data.u;
983 break;
984 case PARAM_SL: if ( data.u >= MIN_STOP_LENGTH && data.u <= MAX_STOP_LENGTH )
985 vtl->stop_length = data.u;
986 break;
987 case PARAM_EF: if ( data.u >= 1 && data.u <= 100 )
988 vtl->elevation_factor = data.u;
989 break;
990 case PARAM_LT: if ( data.u > 0 && data.u < 15 && data.u != vtl->line_thickness )
991 {
992 vtl->line_thickness = data.u;
993 if ( vp ) trw_layer_new_track_gcs ( vtl, vp );
994 }
995 break;
996 case PARAM_BLT: if ( data.u <= 8 && data.u != vtl->bg_line_thickness )
997 {
998 vtl->bg_line_thickness = data.u;
999 if ( vp ) trw_layer_new_track_gcs ( vtl, vp );
1000 }
1001 break;
1002 case PARAM_TBGC:
1003 vtl->track_bg_color = data.c;
1004 if ( vtl->track_bg_gc )
1005 gdk_gc_set_rgb_fg_color(vtl->track_bg_gc, &(vtl->track_bg_color));
1006 break;
1007 case PARAM_TDSF: vtl->track_draw_speed_factor = data.d; break;
1008 case PARAM_TSO: if ( data.u < VL_SO_LAST ) vtl->track_sort_order = data.u; break;
1009 case PARAM_DLA: vtl->drawlabels = data.b; break;
1010 case PARAM_DI: vtl->drawimages = data.b; break;
1011 case PARAM_IS: if ( data.u != vtl->image_size )
1012 {
1013 vtl->image_size = data.u;
1014 g_list_foreach ( vtl->image_cache->head, (GFunc) cached_pixbuf_free, NULL );
1015 g_queue_free ( vtl->image_cache );
1016 vtl->image_cache = g_queue_new ();
1017 }
1018 break;
1019 case PARAM_IA: vtl->image_alpha = data.u; break;
1020 case PARAM_ICS: vtl->image_cache_size = data.u;
1021 while ( vtl->image_cache->length > vtl->image_cache_size ) /* if shrinking cache_size, free pixbuf ASAP */
1022 cached_pixbuf_free ( g_queue_pop_tail ( vtl->image_cache ) );
1023 break;
1024 case PARAM_WPC:
1025 vtl->waypoint_color = data.c;
1026 if ( vtl->waypoint_gc )
1027 gdk_gc_set_rgb_fg_color(vtl->waypoint_gc, &(vtl->waypoint_color));
1028 break;
1029 case PARAM_WPTC:
1030 vtl->waypoint_text_color = data.c;
1031 if ( vtl->waypoint_text_gc )
1032 gdk_gc_set_rgb_fg_color(vtl->waypoint_text_gc, &(vtl->waypoint_text_color));
1033 break;
1034 case PARAM_WPBC:
1035 vtl->waypoint_bg_color = data.c;
1036 if ( vtl->waypoint_bg_gc )
1037 gdk_gc_set_rgb_fg_color(vtl->waypoint_bg_gc, &(vtl->waypoint_bg_color));
1038 break;
1039 case PARAM_WPBA:
1040 vtl->wpbgand = data.b;
1041 if ( vtl->waypoint_bg_gc )
1042 gdk_gc_set_function(vtl->waypoint_bg_gc, data.b ? GDK_AND : GDK_COPY );
1043 break;
1044 case PARAM_WPSYM: if ( data.u < WP_NUM_SYMBOLS ) vtl->wp_symbol = data.u; break;
1045 case PARAM_WPSIZE: if ( data.u > 0 && data.u <= 64 ) vtl->wp_size = data.u; break;
1046 case PARAM_WPSYMS: vtl->wp_draw_symbols = data.b; break;
1047 case PARAM_WPFONTSIZE:
1048 if ( data.u < FS_NUM_SIZES ) {
1049 vtl->wp_font_size = data.u;
1050 g_free ( vtl->wp_fsize_str );
1051 switch ( vtl->wp_font_size ) {
1052 case FS_XX_SMALL: vtl->wp_fsize_str = g_strdup ( "xx-small" ); break;
1053 case FS_X_SMALL: vtl->wp_fsize_str = g_strdup ( "x-small" ); break;
1054 case FS_SMALL: vtl->wp_fsize_str = g_strdup ( "small" ); break;
1055 case FS_LARGE: vtl->wp_fsize_str = g_strdup ( "large" ); break;
1056 case FS_X_LARGE: vtl->wp_fsize_str = g_strdup ( "x-large" ); break;
1057 case FS_XX_LARGE: vtl->wp_fsize_str = g_strdup ( "xx-large" ); break;
1058 default: vtl->wp_fsize_str = g_strdup ( "medium" ); break;
1059 }
1060 }
1061 break;
1062 case PARAM_WPSO: if ( data.u < VL_SO_LAST ) vtl->wp_sort_order = data.u; break;
1063 }
1064 return TRUE;
1065}
1066
1067static VikLayerParamData trw_layer_get_param ( VikTrwLayer *vtl, guint16 id, gboolean is_file_operation )
1068{
1069 VikLayerParamData rv;
1070 switch ( id )
1071 {
1072 case PARAM_TV: rv.b = vtl->tracks_visible; break;
1073 case PARAM_WV: rv.b = vtl->waypoints_visible; break;
1074 case PARAM_RV: rv.b = vtl->routes_visible; break;
1075 case PARAM_TDL: rv.b = vtl->track_draw_labels; break;
1076 case PARAM_TLFONTSIZE: rv.u = vtl->track_font_size; break;
1077 case PARAM_DM: rv.u = vtl->drawmode; break;
1078 case PARAM_TC: rv.c = vtl->track_color; break;
1079 case PARAM_DP: rv.b = vtl->drawpoints; break;
1080 case PARAM_DPS: rv.u = vtl->drawpoints_size; break;
1081 case PARAM_DE: rv.b = vtl->drawelevation; break;
1082 case PARAM_EF: rv.u = vtl->elevation_factor; break;
1083 case PARAM_DS: rv.b = vtl->drawstops; break;
1084 case PARAM_SL: rv.u = vtl->stop_length; break;
1085 case PARAM_DL: rv.b = vtl->drawlines; break;
1086 case PARAM_DD: rv.b = vtl->drawdirections; break;
1087 case PARAM_DDS: rv.u = vtl->drawdirections_size; break;
1088 case PARAM_LT: rv.u = vtl->line_thickness; break;
1089 case PARAM_BLT: rv.u = vtl->bg_line_thickness; break;
1090 case PARAM_DLA: rv.b = vtl->drawlabels; break;
1091 case PARAM_DI: rv.b = vtl->drawimages; break;
1092 case PARAM_TBGC: rv.c = vtl->track_bg_color; break;
1093 case PARAM_TDSF: rv.d = vtl->track_draw_speed_factor; break;
1094 case PARAM_TSO: rv.u = vtl->track_sort_order; break;
1095 case PARAM_IS: rv.u = vtl->image_size; break;
1096 case PARAM_IA: rv.u = vtl->image_alpha; break;
1097 case PARAM_ICS: rv.u = vtl->image_cache_size; break;
1098 case PARAM_WPC: rv.c = vtl->waypoint_color; break;
1099 case PARAM_WPTC: rv.c = vtl->waypoint_text_color; break;
1100 case PARAM_WPBC: rv.c = vtl->waypoint_bg_color; break;
1101 case PARAM_WPBA: rv.b = vtl->wpbgand; break;
1102 case PARAM_WPSYM: rv.u = vtl->wp_symbol; break;
1103 case PARAM_WPSIZE: rv.u = vtl->wp_size; break;
1104 case PARAM_WPSYMS: rv.b = vtl->wp_draw_symbols; break;
1105 case PARAM_WPFONTSIZE: rv.u = vtl->wp_font_size; break;
1106 case PARAM_WPSO: rv.u = vtl->wp_sort_order; break;
1107 }
1108 return rv;
1109}
1110
1111static void trw_layer_marshall( VikTrwLayer *vtl, guint8 **data, gint *len )
1112{
1113 guint8 *pd;
1114 gint pl;
1115
1116 *data = NULL;
1117
1118 // Use byte arrays to store sublayer data
1119 // much like done elsewhere e.g. vik_layer_marshall_params()
1120 GByteArray *ba = g_byte_array_new ( );
1121
1122 guint8 *sl_data;
1123 guint sl_len;
1124
1125 guint object_length;
1126 guint subtype;
1127 // store:
1128 // the length of the item
1129 // the sublayer type of item
1130 // the the actual item
1131#define tlm_append(object_pointer, size, type) \
1132 subtype = (type); \
1133 object_length = (size); \
1134 g_byte_array_append ( ba, (guint8 *)&object_length, sizeof(object_length) ); \
1135 g_byte_array_append ( ba, (guint8 *)&subtype, sizeof(subtype) ); \
1136 g_byte_array_append ( ba, (object_pointer), object_length );
1137
1138 // Layer parameters first
1139 vik_layer_marshall_params(VIK_LAYER(vtl), &pd, &pl);
1140 g_byte_array_append ( ba, (guint8 *)&pl, sizeof(pl) ); \
1141 g_byte_array_append ( ba, pd, pl );
1142 g_free ( pd );
1143
1144 // Now sublayer data
1145 GHashTableIter iter;
1146 gpointer key, value;
1147
1148 // Waypoints
1149 g_hash_table_iter_init ( &iter, vtl->waypoints );
1150 while ( g_hash_table_iter_next (&iter, &key, &value) ) {
1151 vik_waypoint_marshall ( VIK_WAYPOINT(value), &sl_data, &sl_len );
1152 tlm_append ( sl_data, sl_len, VIK_TRW_LAYER_SUBLAYER_WAYPOINT );
1153 g_free ( sl_data );
1154 }
1155
1156 // Tracks
1157 g_hash_table_iter_init ( &iter, vtl->tracks );
1158 while ( g_hash_table_iter_next (&iter, &key, &value) ) {
1159 vik_track_marshall ( VIK_TRACK(value), &sl_data, &sl_len );
1160 tlm_append ( sl_data, sl_len, VIK_TRW_LAYER_SUBLAYER_TRACK );
1161 g_free ( sl_data );
1162 }
1163
1164 // Routes
1165 g_hash_table_iter_init ( &iter, vtl->routes );
1166 while ( g_hash_table_iter_next (&iter, &key, &value) ) {
1167 vik_track_marshall ( VIK_TRACK(value), &sl_data, &sl_len );
1168 tlm_append ( sl_data, sl_len, VIK_TRW_LAYER_SUBLAYER_ROUTE );
1169 g_free ( sl_data );
1170 }
1171
1172#undef tlm_append
1173
1174 *data = ba->data;
1175 *len = ba->len;
1176}
1177
1178static VikTrwLayer *trw_layer_unmarshall( guint8 *data, gint len, VikViewport *vvp )
1179{
1180 VikTrwLayer *vtl = VIK_TRW_LAYER(vik_layer_create ( VIK_LAYER_TRW, vvp, NULL, FALSE ));
1181 gint pl;
1182 gint consumed_length;
1183
1184 // First the overall layer parameters
1185 memcpy(&pl, data, sizeof(pl));
1186 data += sizeof(pl);
1187 vik_layer_unmarshall_params ( VIK_LAYER(vtl), data, pl, vvp );
1188 data += pl;
1189
1190 consumed_length = pl;
1191 const gint sizeof_len_and_subtype = sizeof(gint) + sizeof(gint);
1192
1193#define tlm_size (*(gint *)data)
1194 // See marshalling above for order of how this is written
1195#define tlm_next \
1196 data += sizeof_len_and_subtype + tlm_size;
1197
1198 // Now the individual sublayers:
1199
1200 while ( *data && consumed_length < len ) {
1201 // Normally four extra bytes at the end of the datastream
1202 // (since it's a GByteArray and that's where it's length is stored)
1203 // So only attempt read when there's an actual block of sublayer data
1204 if ( consumed_length + tlm_size < len ) {
1205
1206 // Reuse pl to read the subtype from the data stream
1207 memcpy(&pl, data+sizeof(gint), sizeof(pl));
1208
1209 if ( pl == VIK_TRW_LAYER_SUBLAYER_TRACK ) {
1210 VikTrack *trk = vik_track_unmarshall ( data + sizeof_len_and_subtype, 0 );
1211 gchar *name = g_strdup ( trk->name );
1212 vik_trw_layer_add_track ( vtl, name, trk );
1213 g_free ( name );
1214 }
1215 if ( pl == VIK_TRW_LAYER_SUBLAYER_WAYPOINT ) {
1216 VikWaypoint *wp = vik_waypoint_unmarshall ( data + sizeof_len_and_subtype, 0 );
1217 gchar *name = g_strdup ( wp->name );
1218 vik_trw_layer_add_waypoint ( vtl, name, wp );
1219 g_free ( name );
1220 }
1221 if ( pl == VIK_TRW_LAYER_SUBLAYER_ROUTE ) {
1222 VikTrack *trk = vik_track_unmarshall ( data + sizeof_len_and_subtype, 0 );
1223 gchar *name = g_strdup ( trk->name );
1224 vik_trw_layer_add_route ( vtl, name, trk );
1225 g_free ( name );
1226 }
1227 }
1228 consumed_length += tlm_size + sizeof_len_and_subtype;
1229 tlm_next;
1230 }
1231 //g_debug ("consumed_length %d vs len %d", consumed_length, len);
1232
1233 // Not stored anywhere else so need to regenerate
1234 trw_layer_calculate_bounds_waypoints ( vtl );
1235
1236 return vtl;
1237}
1238
1239// Keep interesting hash function at least visible
1240/*
1241static guint strcase_hash(gconstpointer v)
1242{
1243 // 31 bit hash function
1244 int i;
1245 const gchar *t = v;
1246 gchar s[128]; // malloc is too slow for reading big files
1247 gchar *p = s;
1248
1249 for (i = 0; (i < (sizeof(s)- 1)) && t[i]; i++)
1250 p[i] = toupper(t[i]);
1251 p[i] = '\0';
1252
1253 p = s;
1254 guint32 h = *p;
1255 if (h) {
1256 for (p += 1; *p != '\0'; p++)
1257 h = (h << 5) - h + *p;
1258 }
1259
1260 return h;
1261}
1262*/
1263
1264// Stick a 1 at the end of the function name to make it more unique
1265// thus more easily searchable in a simple text editor
1266static VikTrwLayer* trw_layer_new1 ( VikViewport *vvp )
1267{
1268 VikTrwLayer *rv = VIK_TRW_LAYER ( g_object_new ( VIK_TRW_LAYER_TYPE, NULL ) );
1269 vik_layer_set_type ( VIK_LAYER(rv), VIK_LAYER_TRW );
1270
1271 // It's not entirely clear the benefits of hash tables usage here - possibly the simplicity of first implementation for unique names
1272 // Now with the name of the item stored as part of the item - these tables are effectively straightforward lists
1273
1274 // For this reworking I've choosen to keep the use of hash tables since for the expected data sizes
1275 // - even many hundreds of waypoints and tracks is quite small in the grand scheme of things,
1276 // and with normal PC processing capabilities - it has negligibile performance impact
1277 // This also minimized the amount of rework - as the management of the hash tables already exists.
1278
1279 // The hash tables are indexed by simple integers acting as a UUID hash, which again shouldn't affect performance much
1280 // we have to maintain a uniqueness (as before when multiple names where not allowed),
1281 // this is to ensure it refers to the same item in the data structures used on the viewport and on the layers panel
1282
1283 rv->waypoints = g_hash_table_new_full ( g_direct_hash, g_direct_equal, NULL, (GDestroyNotify) vik_waypoint_free );
1284 rv->waypoints_iters = g_hash_table_new_full ( g_direct_hash, g_direct_equal, NULL, g_free );
1285 rv->tracks = g_hash_table_new_full ( g_direct_hash, g_direct_equal, NULL, (GDestroyNotify) vik_track_free );
1286 rv->tracks_iters = g_hash_table_new_full ( g_direct_hash, g_direct_equal, NULL, g_free );
1287 rv->routes = g_hash_table_new_full ( g_direct_hash, g_direct_equal, NULL, (GDestroyNotify) vik_track_free );
1288 rv->routes_iters = g_hash_table_new_full ( g_direct_hash, g_direct_equal, NULL, g_free );
1289
1290 rv->image_cache = g_queue_new(); // Must be performed before set_params via set_defaults
1291
1292 vik_layer_set_defaults ( VIK_LAYER(rv), vvp );
1293
1294 // Param settings that are not available via the GUI
1295 // Force to on after processing params (which defaults them to off with a zero value)
1296 rv->waypoints_visible = rv->tracks_visible = rv->routes_visible = TRUE;
1297
1298 rv->draw_sync_done = TRUE;
1299 rv->draw_sync_do = TRUE;
1300 // Everything else is 0, FALSE or NULL
1301
1302 return rv;
1303}
1304
1305
1306static void trw_layer_free ( VikTrwLayer *trwlayer )
1307{
1308 g_hash_table_destroy(trwlayer->waypoints);
1309 g_hash_table_destroy(trwlayer->waypoints_iters);
1310 g_hash_table_destroy(trwlayer->tracks);
1311 g_hash_table_destroy(trwlayer->tracks_iters);
1312 g_hash_table_destroy(trwlayer->routes);
1313 g_hash_table_destroy(trwlayer->routes_iters);
1314
1315 /* ODC: replace with GArray */
1316 trw_layer_free_track_gcs ( trwlayer );
1317
1318 if ( trwlayer->wp_right_click_menu )
1319 g_object_ref_sink ( G_OBJECT(trwlayer->wp_right_click_menu) );
1320
1321 if ( trwlayer->track_right_click_menu )
1322 g_object_ref_sink ( G_OBJECT(trwlayer->track_right_click_menu) );
1323
1324 if ( trwlayer->tracklabellayout != NULL)
1325 g_object_unref ( G_OBJECT ( trwlayer->tracklabellayout ) );
1326
1327 if ( trwlayer->wplabellayout != NULL)
1328 g_object_unref ( G_OBJECT ( trwlayer->wplabellayout ) );
1329
1330 if ( trwlayer->waypoint_gc != NULL )
1331 g_object_unref ( G_OBJECT ( trwlayer->waypoint_gc ) );
1332
1333 if ( trwlayer->waypoint_text_gc != NULL )
1334 g_object_unref ( G_OBJECT ( trwlayer->waypoint_text_gc ) );
1335
1336 if ( trwlayer->waypoint_bg_gc != NULL )
1337 g_object_unref ( G_OBJECT ( trwlayer->waypoint_bg_gc ) );
1338
1339 g_free ( trwlayer->wp_fsize_str );
1340 g_free ( trwlayer->track_fsize_str );
1341
1342 if ( trwlayer->tpwin != NULL )
1343 gtk_widget_destroy ( GTK_WIDGET(trwlayer->tpwin) );
1344
1345 if ( trwlayer->tracks_analysis_dialog != NULL )
1346 gtk_widget_destroy ( GTK_WIDGET(trwlayer->tracks_analysis_dialog) );
1347
1348 g_list_foreach ( trwlayer->image_cache->head, (GFunc) cached_pixbuf_free, NULL );
1349 g_queue_free ( trwlayer->image_cache );
1350}
1351
1352static void init_drawing_params ( struct DrawingParams *dp, VikTrwLayer *vtl, VikViewport *vp )
1353{
1354 dp->vtl = vtl;
1355 dp->vp = vp;
1356 dp->vw = (VikWindow *)VIK_GTK_WINDOW_FROM_LAYER(dp->vtl);
1357 dp->xmpp = vik_viewport_get_xmpp ( vp );
1358 dp->ympp = vik_viewport_get_ympp ( vp );
1359 dp->width = vik_viewport_get_width ( vp );
1360 dp->height = vik_viewport_get_height ( vp );
1361 dp->cc = vtl->drawdirections_size*cos(DEG2RAD(45)); // Calculate once per vtl update - even if not used
1362 dp->ss = vtl->drawdirections_size*sin(DEG2RAD(45)); // Calculate once per vtl update - even if not used
1363
1364 dp->center = vik_viewport_get_center ( vp );
1365 dp->one_zone = vik_viewport_is_one_zone ( vp ); /* false if some other projection besides UTM */
1366 dp->lat_lon = vik_viewport_get_coord_mode ( vp ) == VIK_COORD_LATLON;
1367
1368 if ( dp->one_zone )
1369 {
1370 gint w2, h2;
1371 w2 = dp->xmpp * (dp->width / 2) + 1600 / dp->xmpp;
1372 h2 = dp->ympp * (dp->height / 2) + 1600 / dp->ympp;
1373 /* leniency -- for tracks. Obviously for waypoints this SHOULD be a lot smaller */
1374
1375 dp->ce1 = dp->center->east_west-w2;
1376 dp->ce2 = dp->center->east_west+w2;
1377 dp->cn1 = dp->center->north_south-h2;
1378 dp->cn2 = dp->center->north_south+h2;
1379 } else if ( dp->lat_lon ) {
1380 VikCoord upperleft, bottomright;
1381 /* quick & dirty calculation; really want to check all corners due to lat/lon smaller at top in northern hemisphere */
1382 /* this also DOESN'T WORK if you are crossing 180/-180 lon. I don't plan to in the near future... */
1383 vik_viewport_screen_to_coord ( vp, -500, -500, &upperleft );
1384 vik_viewport_screen_to_coord ( vp, dp->width+500, dp->height+500, &bottomright );
1385 dp->ce1 = upperleft.east_west;
1386 dp->ce2 = bottomright.east_west;
1387 dp->cn1 = bottomright.north_south;
1388 dp->cn2 = upperleft.north_south;
1389 }
1390
1391 vik_viewport_get_min_max_lat_lon ( vp, &(dp->bbox.south), &(dp->bbox.north), &(dp->bbox.west), &(dp->bbox.east) );
1392}
1393
1394/*
1395 * Determine the colour of the trackpoint (and/or trackline) relative to the average speed
1396 * Here a simple traffic like light colour system is used:
1397 * . slow points are red
1398 * . average is yellow
1399 * . fast points are green
1400 */
1401static gint track_section_colour_by_speed ( VikTrwLayer *vtl, VikTrackpoint *tp1, VikTrackpoint *tp2, gdouble average_speed, gdouble low_speed, gdouble high_speed )
1402{
1403 gdouble rv = 0;
1404 if ( tp1->has_timestamp && tp2->has_timestamp ) {
1405 if ( average_speed > 0 ) {
1406 rv = ( vik_coord_diff ( &(tp1->coord), &(tp2->coord) ) / (tp1->timestamp - tp2->timestamp) );
1407 if ( rv < low_speed )
1408 return VIK_TRW_LAYER_TRACK_GC_SLOW;
1409 else if ( rv > high_speed )
1410 return VIK_TRW_LAYER_TRACK_GC_FAST;
1411 else
1412 return VIK_TRW_LAYER_TRACK_GC_AVER;
1413 }
1414 }
1415 return VIK_TRW_LAYER_TRACK_GC_BLACK;
1416}
1417
1418static void draw_utm_skip_insignia ( VikViewport *vvp, GdkGC *gc, gint x, gint y )
1419{
1420 vik_viewport_draw_line ( vvp, gc, x+5, y, x-5, y );
1421 vik_viewport_draw_line ( vvp, gc, x, y+5, x, y-5 );
1422 vik_viewport_draw_line ( vvp, gc, x+5, y+5, x-5, y-5 );
1423 vik_viewport_draw_line ( vvp, gc, x+5, y-5, x-5, y+5 );
1424}
1425
1426
1427static void trw_layer_draw_track_label ( gchar *name, gchar *fgcolour, gchar *bgcolour, struct DrawingParams *dp, VikCoord *coord )
1428{
1429 gchar *label_markup = g_strdup_printf ( "<span foreground=\"%s\" background=\"%s\" size=\"%s\">%s</span>", fgcolour, bgcolour, dp->vtl->track_fsize_str, name );
1430
1431 if ( pango_parse_markup ( label_markup, -1, 0, NULL, NULL, NULL, NULL ) )
1432 pango_layout_set_markup ( dp->vtl->tracklabellayout, label_markup, -1 );
1433 else
1434 // Fallback if parse failure
1435 pango_layout_set_text ( dp->vtl->tracklabellayout, name, -1 );
1436
1437 g_free ( label_markup );
1438
1439 gint label_x, label_y;
1440 gint width, height;
1441 pango_layout_get_pixel_size ( dp->vtl->tracklabellayout, &width, &height );
1442
1443 vik_viewport_coord_to_screen ( dp->vp, coord, &label_x, &label_y );
1444 vik_viewport_draw_layout ( dp->vp, dp->vtl->track_bg_gc, label_x-width/2, label_y-height/2, dp->vtl->tracklabellayout );
1445}
1446
1447/**
1448 * distance_in_preferred_units:
1449 * @dist: The source distance in standard SI Units (i.e. metres)
1450 *
1451 * TODO: This is a generic function that could be moved into globals.c or utils.c
1452 *
1453 * Probably best used if you have a only few conversions to perform.
1454 * However if doing many points (such as on all points along a track) then this may be a bit slow,
1455 * since it will be doing the preference check on each call
1456 *
1457 * Returns: The distance in the units as specified by the preferences
1458 */
1459static gdouble distance_in_preferred_units ( gdouble dist )
1460{
1461 gdouble mydist;
1462 vik_units_distance_t dist_units = a_vik_get_units_distance ();
1463 switch (dist_units) {
1464 case VIK_UNITS_DISTANCE_MILES:
1465 mydist = VIK_METERS_TO_MILES(dist);
1466 break;
1467 // VIK_UNITS_DISTANCE_KILOMETRES:
1468 default:
1469 mydist = dist/1000.0;
1470 break;
1471 }
1472 return mydist;
1473}
1474
1475/**
1476 * trw_layer_draw_dist_labels:
1477 *
1478 * Draw a few labels along a track at nicely seperated distances
1479 * This might slow things down if there's many tracks being displayed with this on.
1480 */
1481static void trw_layer_draw_dist_labels ( struct DrawingParams *dp, VikTrack *trk, gboolean drawing_highlight )
1482{
1483 static const gdouble chunksd[] = {0.25, 0.5, 1.0, 2.0, 5.0, 10.0, 15.0, 20.0,
1484 25.0, 40.0, 50.0, 75.0, 100.0,
1485 150.0, 200.0, 250.0, 500.0, 1000.0};
1486
1487 gdouble dist = vik_track_get_length_including_gaps ( trk ) / (trk->max_number_dist_labels+1);
1488
1489 // Convert to specified unit to find the friendly breakdown value
1490 dist = distance_in_preferred_units ( dist );
1491
1492 gint index = 0;
1493 gint i=0;
1494 for ( i = 0; i < G_N_ELEMENTS(chunksd); i++ ) {
1495 if ( chunksd[i] > dist ) {
1496 index = i;
1497 dist = chunksd[index];
1498 break;
1499 }
1500 }
1501
1502 vik_units_distance_t dist_units = a_vik_get_units_distance ();
1503
1504 for ( i = 1; i < trk->max_number_dist_labels+1; i++ ) {
1505 gdouble dist_i = dist * i;
1506
1507 // Convert distance back into metres for use in finding a trackpoint
1508 switch (dist_units) {
1509 case VIK_UNITS_DISTANCE_MILES:
1510 dist_i = VIK_MILES_TO_METERS(dist_i);
1511 break;
1512 // VIK_UNITS_DISTANCE_KILOMETRES:
1513 default:
1514 dist_i = dist_i*1000.0;
1515 break;
1516 }
1517
1518 gdouble dist_current = 0.0;
1519 VikTrackpoint *tp_current = vik_track_get_tp_by_dist ( trk, dist_i, FALSE, &dist_current );
1520 gdouble dist_next = 0.0;
1521 VikTrackpoint *tp_next = vik_track_get_tp_by_dist ( trk, dist_i, TRUE, &dist_next );
1522
1523 gdouble dist_between_tps = fabs (dist_next - dist_current);
1524 gdouble ratio = 0.0;
1525 // Prevent division by 0 errors
1526 if ( dist_between_tps > 0.0 )
1527 ratio = fabs(dist_i-dist_current)/dist_between_tps;
1528
1529 if ( tp_current && tp_next ) {
1530 // Construct the name based on the distance value
1531 gchar *name;
1532 gchar *units;
1533 switch (dist_units) {
1534 case VIK_UNITS_DISTANCE_MILES:
1535 units = g_strdup ( _("miles") );
1536 break;
1537 // VIK_UNITS_DISTANCE_KILOMETRES:
1538 default:
1539 units = g_strdup ( _("km") );
1540 break;
1541 }
1542
1543 // Convert for display
1544 dist_i = distance_in_preferred_units ( dist_i );
1545
1546 // Make the precision of the output related to the unit size.
1547 if ( index == 0 )
1548 name = g_strdup_printf ( "%.2f %s", dist_i, units);
1549 else if ( index == 1 )
1550 name = g_strdup_printf ( "%.1f %s", dist_i, units);
1551 else
1552 name = g_strdup_printf ( "%d %s", (gint)round(dist_i), units); // TODO single vs plurals
1553 g_free ( units );
1554
1555 struct LatLon ll_current, ll_next;
1556 vik_coord_to_latlon ( &tp_current->coord, &ll_current );
1557 vik_coord_to_latlon ( &tp_next->coord, &ll_next );
1558
1559 // positional interpolation
1560 // Using a simple ratio - may not be perfectly correct due to lat/long projections
1561 // but should be good enough over the small scale that I anticipate usage on
1562 struct LatLon ll_new = { ll_current.lat + (ll_next.lat-ll_current.lat)*ratio,
1563 ll_current.lon + (ll_next.lon-ll_current.lon)*ratio };
1564 VikCoord coord;
1565 vik_coord_load_from_latlon ( &coord, dp->vtl->coord_mode, &ll_new );
1566
1567 gchar *fgcolour;
1568 if ( dp->vtl->drawmode == DRAWMODE_BY_TRACK )
1569 fgcolour = gdk_color_to_string ( &(trk->color) );
1570 else
1571 fgcolour = gdk_color_to_string ( &(dp->vtl->track_color) );
1572
1573 // if highlight mode on, then colour the background in the highlight colour
1574 gchar *bgcolour;
1575 if ( drawing_highlight )
1576 bgcolour = g_strdup ( vik_viewport_get_highlight_color ( dp->vp ) );
1577 else
1578 bgcolour = gdk_color_to_string ( &(dp->vtl->track_bg_color) );
1579
1580 trw_layer_draw_track_label ( name, fgcolour, bgcolour, dp, &coord );
1581
1582 g_free ( fgcolour );
1583 g_free ( bgcolour );
1584 g_free ( name );
1585 }
1586 }
1587}
1588
1589/**
1590 * trw_layer_draw_track_name_labels:
1591 *
1592 * Draw a label (or labels) for the track name somewhere depending on the track's properties
1593 */
1594static void trw_layer_draw_track_name_labels ( struct DrawingParams *dp, VikTrack *trk, gboolean drawing_highlight )
1595{
1596 gchar *fgcolour;
1597 if ( dp->vtl->drawmode == DRAWMODE_BY_TRACK )
1598 fgcolour = gdk_color_to_string ( &(trk->color) );
1599 else
1600 fgcolour = gdk_color_to_string ( &(dp->vtl->track_color) );
1601
1602 // if highlight mode on, then colour the background in the highlight colour
1603 gchar *bgcolour;
1604 if ( drawing_highlight )
1605 bgcolour = g_strdup ( vik_viewport_get_highlight_color ( dp->vp ) );
1606 else
1607 bgcolour = gdk_color_to_string ( &(dp->vtl->track_bg_color) );
1608
1609 gchar *ename = g_markup_escape_text ( trk->name, -1 );
1610
1611 if ( trk->draw_name_mode == TRACK_DRAWNAME_START_END_CENTRE ||
1612 trk->draw_name_mode == TRACK_DRAWNAME_CENTRE ) {
1613 struct LatLon average, maxmin[2] = { {0,0}, {0,0} };
1614 trw_layer_find_maxmin_tracks ( NULL, trk, maxmin );
1615 average.lat = (maxmin[0].lat+maxmin[1].lat)/2;
1616 average.lon = (maxmin[0].lon+maxmin[1].lon)/2;
1617 VikCoord coord;
1618 vik_coord_load_from_latlon ( &coord, dp->vtl->coord_mode, &average );
1619
1620 trw_layer_draw_track_label ( ename, fgcolour, bgcolour, dp, &coord );
1621 }
1622
1623 if ( trk->draw_name_mode == TRACK_DRAWNAME_CENTRE )
1624 // No other labels to draw
1625 return;
1626
1627 GList *ending = g_list_last ( trk->trackpoints );
1628 VikCoord begin_coord = VIK_TRACKPOINT(trk->trackpoints->data)->coord;
1629 VikCoord end_coord = VIK_TRACKPOINT(ending->data)->coord;
1630
1631 gboolean done_start_end = FALSE;
1632
1633 if ( trk->draw_name_mode == TRACK_DRAWNAME_START_END ||
1634 trk->draw_name_mode == TRACK_DRAWNAME_START_END_CENTRE ) {
1635
1636 // This number can be configured via the settings if you really want to change it
1637 gdouble distance_diff;
1638 if ( ! a_settings_get_double ( "trackwaypoint_start_end_distance_diff", &distance_diff ) )
1639 distance_diff = 100.0; // Metres
1640
1641 if ( vik_coord_diff ( &begin_coord, &end_coord ) < distance_diff ) {
1642 // Start and end 'close' together so only draw one label at an average location
1643 gint x1, x2, y1, y2;
1644 vik_viewport_coord_to_screen ( dp->vp, &begin_coord, &x1, &y1);
1645 vik_viewport_coord_to_screen ( dp->vp, &end_coord, &x2, &y2);
1646 VikCoord av_coord;
1647 vik_viewport_screen_to_coord ( dp->vp, (x1 + x2) / 2, (y1 + y2) / 2, &av_coord );
1648
1649 gchar *name = g_strdup_printf ( "%s: %s", ename, _("start/end") );
1650 trw_layer_draw_track_label ( name, fgcolour, bgcolour, dp, &av_coord );
1651 g_free ( name );
1652
1653 done_start_end = TRUE;
1654 }
1655 }
1656
1657 if ( ! done_start_end ) {
1658 if ( trk->draw_name_mode == TRACK_DRAWNAME_START ||
1659 trk->draw_name_mode == TRACK_DRAWNAME_START_END ||
1660 trk->draw_name_mode == TRACK_DRAWNAME_START_END_CENTRE ) {
1661 gchar *name_start = g_strdup_printf ( "%s: %s", ename, _("start") );
1662 trw_layer_draw_track_label ( name_start, fgcolour, bgcolour, dp, &begin_coord );
1663 g_free ( name_start );
1664 }
1665 // Don't draw end label if this is the one being created
1666 if ( trk != dp->vtl->current_track ) {
1667 if ( trk->draw_name_mode == TRACK_DRAWNAME_END ||
1668 trk->draw_name_mode == TRACK_DRAWNAME_START_END ||
1669 trk->draw_name_mode == TRACK_DRAWNAME_START_END_CENTRE ) {
1670 gchar *name_end = g_strdup_printf ( "%s: %s", ename, _("end") );
1671 trw_layer_draw_track_label ( name_end, fgcolour, bgcolour, dp, &end_coord );
1672 g_free ( name_end );
1673 }
1674 }
1675 }
1676
1677 g_free ( fgcolour );
1678 g_free ( bgcolour );
1679 g_free ( ename );
1680}
1681
1682static void trw_layer_draw_track ( const gpointer id, VikTrack *track, struct DrawingParams *dp, gboolean draw_track_outline )
1683{
1684 if ( ! track->visible )
1685 return;
1686
1687 /* TODO: this function is a mess, get rid of any redundancy */
1688 GList *list = track->trackpoints;
1689 GdkGC *main_gc;
1690 gboolean useoldvals = TRUE;
1691
1692 gboolean drawpoints;
1693 gboolean drawstops;
1694 gboolean drawelevation;
1695 gdouble min_alt, max_alt, alt_diff = 0;
1696
1697 const guint8 tp_size_reg = dp->vtl->drawpoints_size;
1698 const guint8 tp_size_cur = dp->vtl->drawpoints_size*2;
1699 guint8 tp_size;
1700
1701 if ( dp->vtl->drawelevation )
1702 {
1703 /* assume if it has elevation at the beginning, it has it throughout. not ness a true good assumption */
1704 if ( ( drawelevation = vik_track_get_minmax_alt ( track, &min_alt, &max_alt ) ) )
1705 alt_diff = max_alt - min_alt;
1706 }
1707
1708 /* admittedly this is not an efficient way to do it because we go through the whole GC thing all over... */
1709 if ( dp->vtl->bg_line_thickness && !draw_track_outline )
1710 trw_layer_draw_track ( id, track, dp, TRUE );
1711
1712 if ( draw_track_outline )
1713 drawpoints = drawstops = FALSE;
1714 else {
1715 drawpoints = dp->vtl->drawpoints;
1716 drawstops = dp->vtl->drawstops;
1717 }
1718
1719 gboolean drawing_highlight = FALSE;
1720 /* Current track - used for creation */
1721 if ( track == dp->vtl->current_track )
1722 main_gc = dp->vtl->current_track_gc;
1723 else {
1724 if ( vik_viewport_get_draw_highlight ( dp->vp ) ) {
1725 /* Draw all tracks of the layer in special colour */
1726 /* if track is member of selected layer or is the current selected track
1727 then draw in the highlight colour.
1728 NB this supercedes the drawmode */
1729 if ( ( dp->vtl == vik_window_get_selected_trw_layer ( dp->vw ) ) ||
1730 ( !track->is_route && ( dp->vtl->tracks == vik_window_get_selected_tracks ( dp->vw ) ) ) ||
1731 ( track->is_route && ( dp->vtl->routes == vik_window_get_selected_tracks ( dp->vw ) ) ) ||
1732 ( track == vik_window_get_selected_track ( dp->vw ) ) ) {
1733 main_gc = vik_viewport_get_gc_highlight (dp->vp);
1734 drawing_highlight = TRUE;
1735 }
1736 }
1737 if ( !drawing_highlight ) {
1738 // Still need to figure out the gc according to the drawing mode:
1739 switch ( dp->vtl->drawmode ) {
1740 case DRAWMODE_BY_TRACK:
1741 if ( dp->vtl->track_1color_gc )
1742 g_object_unref ( dp->vtl->track_1color_gc );
1743 dp->vtl->track_1color_gc = vik_viewport_new_gc_from_color ( dp->vp, &track->color, dp->vtl->line_thickness );
1744 main_gc = dp->vtl->track_1color_gc;
1745 break;
1746 default:
1747 // Mostly for DRAWMODE_ALL_SAME_COLOR
1748 // but includes DRAWMODE_BY_SPEED, main_gc is set later on as necessary
1749 main_gc = g_array_index(dp->vtl->track_gc, GdkGC *, VIK_TRW_LAYER_TRACK_GC_SINGLE);
1750 break;
1751 }
1752 }
1753 }
1754
1755 if (list) {
1756 int x, y, oldx, oldy;
1757 VikTrackpoint *tp = VIK_TRACKPOINT(list->data);
1758
1759 tp_size = (list == dp->vtl->current_tpl) ? tp_size_cur : tp_size_reg;
1760
1761 vik_viewport_coord_to_screen ( dp->vp, &(tp->coord), &x, &y );
1762
1763 // Draw the first point as something a bit different from the normal points
1764 // ATM it's slightly bigger and a triangle
1765 if ( drawpoints ) {
1766 GdkPoint trian[3] = { { x, y-(3*tp_size) }, { x-(2*tp_size), y+(2*tp_size) }, {x+(2*tp_size), y+(2*tp_size)} };
1767 vik_viewport_draw_polygon ( dp->vp, main_gc, TRUE, trian, 3 );
1768 }
1769
1770 oldx = x;
1771 oldy = y;
1772
1773 gdouble average_speed = 0.0;
1774 gdouble low_speed = 0.0;
1775 gdouble high_speed = 0.0;
1776 // If necessary calculate these values - which is done only once per track redraw
1777 if ( dp->vtl->drawmode == DRAWMODE_BY_SPEED ) {
1778 // the percentage factor away from the average speed determines transistions between the levels
1779 average_speed = vik_track_get_average_speed_moving(track, dp->vtl->stop_length);
1780 low_speed = average_speed - (average_speed*(dp->vtl->track_draw_speed_factor/100.0));
1781 high_speed = average_speed + (average_speed*(dp->vtl->track_draw_speed_factor/100.0));
1782 }
1783
1784 while ((list = g_list_next(list)))
1785 {
1786 tp = VIK_TRACKPOINT(list->data);
1787 tp_size = (list == dp->vtl->current_tpl) ? tp_size_cur : tp_size_reg;
1788
1789 /* check some stuff -- but only if we're in UTM and there's only ONE ZONE; or lat lon */
1790 if ( (!dp->one_zone && !dp->lat_lon) || /* UTM & zones; do everything */
1791 ( ((!dp->one_zone) || tp->coord.utm_zone == dp->center->utm_zone) && /* only check zones if UTM & one_zone */
1792 tp->coord.east_west < dp->ce2 && tp->coord.east_west > dp->ce1 && /* both UTM and lat lon */
1793 tp->coord.north_south > dp->cn1 && tp->coord.north_south < dp->cn2 ) )
1794 {
1795 vik_viewport_coord_to_screen ( dp->vp, &(tp->coord), &x, &y );
1796
1797 /*
1798 * If points are the same in display coordinates, don't draw.
1799 */
1800 if ( useoldvals && x == oldx && y == oldy )
1801 {
1802 // Still need to process points to ensure 'stops' are drawn if required
1803 if ( drawstops && drawpoints && ! draw_track_outline && list->next &&
1804 (VIK_TRACKPOINT(list->next->data)->timestamp - VIK_TRACKPOINT(list->data)->timestamp > dp->vtl->stop_length) )
1805 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 );
1806
1807 goto skip;
1808 }
1809
1810 VikTrackpoint *tp2 = VIK_TRACKPOINT(list->prev->data);
1811 if ( drawpoints || dp->vtl->drawlines ) {
1812 // setup main_gc for both point and line drawing
1813 if ( !drawing_highlight && (dp->vtl->drawmode == DRAWMODE_BY_SPEED) ) {
1814 main_gc = g_array_index(dp->vtl->track_gc, GdkGC *, track_section_colour_by_speed ( dp->vtl, tp, tp2, average_speed, low_speed, high_speed ) );
1815 }
1816 }
1817
1818 if ( drawpoints && ! draw_track_outline )
1819 {
1820
1821 if ( list->next ) {
1822 /*
1823 * The concept of drawing stops is that a trackpoint
1824 * that is if the next trackpoint has a timestamp far into
1825 * the future, we draw a circle of 6x trackpoint size,
1826 * instead of a rectangle of 2x trackpoint size.
1827 * This is drawn first so the trackpoint will be drawn on top
1828 */
1829 /* stops */
1830 if ( drawstops && VIK_TRACKPOINT(list->next->data)->timestamp - VIK_TRACKPOINT(list->data)->timestamp > dp->vtl->stop_length )
1831 /* Stop point. Draw 6x circle. Always in redish colour */
1832 vik_viewport_draw_arc ( dp->vp, g_array_index(dp->vtl->track_gc, GdkGC *, VIK_TRW_LAYER_TRACK_GC_STOP), TRUE, x-(3*tp_size), y-(3*tp_size), 6*tp_size, 6*tp_size, 0, 360*64 );
1833
1834 /* Regular point - draw 2x square. */
1835 vik_viewport_draw_rectangle ( dp->vp, main_gc, TRUE, x-tp_size, y-tp_size, 2*tp_size, 2*tp_size );
1836 }
1837 else
1838 /* Final point - draw 4x circle. */
1839 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 );
1840 }
1841
1842 if ((!tp->newsegment) && (dp->vtl->drawlines))
1843 {
1844
1845 /* UTM only: zone check */
1846 if ( drawpoints && dp->vtl->coord_mode == VIK_COORD_UTM && tp->coord.utm_zone != dp->center->utm_zone )
1847 draw_utm_skip_insignia ( dp->vp, main_gc, x, y);
1848
1849 if (!useoldvals)
1850 vik_viewport_coord_to_screen ( dp->vp, &(tp2->coord), &oldx, &oldy );
1851
1852 if ( draw_track_outline ) {
1853 vik_viewport_draw_line ( dp->vp, dp->vtl->track_bg_gc, oldx, oldy, x, y);
1854 }
1855 else {
1856
1857 vik_viewport_draw_line ( dp->vp, main_gc, oldx, oldy, x, y);
1858
1859 if ( dp->vtl->drawelevation && list->next && VIK_TRACKPOINT(list->next->data)->altitude != VIK_DEFAULT_ALTITUDE ) {
1860 GdkPoint tmp[4];
1861 #define FIXALTITUDE(what) ((VIK_TRACKPOINT((what))->altitude-min_alt)/alt_diff*DRAW_ELEVATION_FACTOR*dp->vtl->elevation_factor/dp->xmpp)
1862
1863 tmp[0].x = oldx;
1864 tmp[0].y = oldy;
1865 tmp[1].x = oldx;
1866 tmp[1].y = oldy-FIXALTITUDE(list->data);
1867 tmp[2].x = x;
1868 tmp[2].y = y-FIXALTITUDE(list->next->data);
1869 tmp[3].x = x;
1870 tmp[3].y = y;
1871
1872 GdkGC *tmp_gc;
1873 if ( ((oldx - x) > 0 && (oldy - y) > 0) || ((oldx - x) < 0 && (oldy - y) < 0))
1874 tmp_gc = gtk_widget_get_style(GTK_WIDGET(dp->vp))->light_gc[3];
1875 else
1876 tmp_gc = gtk_widget_get_style(GTK_WIDGET(dp->vp))->dark_gc[0];
1877 vik_viewport_draw_polygon ( dp->vp, tmp_gc, TRUE, tmp, 4);
1878
1879 vik_viewport_draw_line ( dp->vp, main_gc, oldx, oldy-FIXALTITUDE(list->data), x, y-FIXALTITUDE(list->next->data));
1880 }
1881 }
1882 }
1883
1884 if ( (!tp->newsegment) && dp->vtl->drawdirections ) {
1885 // Draw an arrow at the mid point to show the direction of the track
1886 // Code is a rework from vikwindow::draw_ruler()
1887 gint midx = (oldx + x) / 2;
1888 gint midy = (oldy + y) / 2;
1889
1890 gdouble len = sqrt ( ((midx-oldx) * (midx-oldx)) + ((midy-oldy) * (midy-oldy)) );
1891 // Avoid divide by zero and ensure at least 1 pixel big
1892 if ( len > 1 ) {
1893 gdouble dx = (oldx - midx) / len;
1894 gdouble dy = (oldy - midy) / len;
1895 vik_viewport_draw_line ( dp->vp, main_gc, midx, midy, midx + (dx * dp->cc + dy * dp->ss), midy + (dy * dp->cc - dx * dp->ss) );
1896 vik_viewport_draw_line ( dp->vp, main_gc, midx, midy, midx + (dx * dp->cc - dy * dp->ss), midy + (dy * dp->cc + dx * dp->ss) );
1897 }
1898 }
1899
1900 skip:
1901 oldx = x;
1902 oldy = y;
1903 useoldvals = TRUE;
1904 }
1905 else {
1906 if (useoldvals && dp->vtl->drawlines && (!tp->newsegment))
1907 {
1908 VikTrackpoint *tp2 = VIK_TRACKPOINT(list->prev->data);
1909 if ( dp->vtl->coord_mode != VIK_COORD_UTM || tp->coord.utm_zone == dp->center->utm_zone )
1910 {
1911 vik_viewport_coord_to_screen ( dp->vp, &(tp->coord), &x, &y );
1912
1913 if ( !drawing_highlight && (dp->vtl->drawmode == DRAWMODE_BY_SPEED) ) {
1914 main_gc = g_array_index(dp->vtl->track_gc, GdkGC *, track_section_colour_by_speed ( dp->vtl, tp, tp2, average_speed, low_speed, high_speed ));
1915 }
1916
1917 /*
1918 * If points are the same in display coordinates, don't draw.
1919 */
1920 if ( x != oldx || y != oldy )
1921 {
1922 if ( draw_track_outline )
1923 vik_viewport_draw_line ( dp->vp, dp->vtl->track_bg_gc, oldx, oldy, x, y);
1924 else
1925 vik_viewport_draw_line ( dp->vp, main_gc, oldx, oldy, x, y);
1926 }
1927 }
1928 else
1929 {
1930 /*
1931 * If points are the same in display coordinates, don't draw.
1932 */
1933 if ( x != oldx && y != oldy )
1934 {
1935 vik_viewport_coord_to_screen ( dp->vp, &(tp2->coord), &x, &y );
1936 draw_utm_skip_insignia ( dp->vp, main_gc, x, y );
1937 }
1938 }
1939 }
1940 useoldvals = FALSE;
1941 }
1942 }
1943
1944 // Labels drawn after the trackpoints, so the labels are on top
1945 if ( dp->vtl->track_draw_labels ) {
1946 if ( track->max_number_dist_labels > 0 ) {
1947 trw_layer_draw_dist_labels ( dp, track, drawing_highlight );
1948 }
1949
1950 if ( track->draw_name_mode != TRACK_DRAWNAME_NO ) {
1951 trw_layer_draw_track_name_labels ( dp, track, drawing_highlight );
1952 }
1953 }
1954 }
1955}
1956
1957static void trw_layer_draw_track_cb ( const gpointer id, VikTrack *track, struct DrawingParams *dp )
1958{
1959 if ( BBOX_INTERSECT ( track->bbox, dp->bbox ) ) {
1960 trw_layer_draw_track ( id, track, dp, FALSE );
1961 }
1962}
1963
1964static void cached_pixbuf_free ( CachedPixbuf *cp )
1965{
1966 g_object_unref ( G_OBJECT(cp->pixbuf) );
1967 g_free ( cp->image );
1968}
1969
1970static gint cached_pixbuf_cmp ( CachedPixbuf *cp, const gchar *name )
1971{
1972 return strcmp ( cp->image, name );
1973}
1974
1975static void trw_layer_draw_waypoint ( const gpointer id, VikWaypoint *wp, struct DrawingParams *dp )
1976{
1977 if ( wp->visible )
1978 if ( (!dp->one_zone && !dp->lat_lon) || ( ( dp->lat_lon || wp->coord.utm_zone == dp->center->utm_zone ) &&
1979 wp->coord.east_west < dp->ce2 && wp->coord.east_west > dp->ce1 &&
1980 wp->coord.north_south > dp->cn1 && wp->coord.north_south < dp->cn2 ) )
1981 {
1982 gint x, y;
1983 vik_viewport_coord_to_screen ( dp->vp, &(wp->coord), &x, &y );
1984
1985 /* if in shrunken_cache, get that. If not, get and add to shrunken_cache */
1986
1987 if ( wp->image && dp->vtl->drawimages )
1988 {
1989 GdkPixbuf *pixbuf = NULL;
1990 GList *l;
1991
1992 if ( dp->vtl->image_alpha == 0)
1993 return;
1994
1995 l = g_list_find_custom ( dp->vtl->image_cache->head, wp->image, (GCompareFunc) cached_pixbuf_cmp );
1996 if ( l )
1997 pixbuf = ((CachedPixbuf *) l->data)->pixbuf;
1998 else
1999 {
2000 gchar *image = wp->image;
2001 GdkPixbuf *regularthumb = a_thumbnails_get ( wp->image );
2002 if ( ! regularthumb )
2003 {
2004 regularthumb = a_thumbnails_get_default (); /* cache one 'not yet loaded' for all thumbs not loaded */
2005 image = "\x12\x00"; /* this shouldn't occur naturally. */
2006 }
2007 if ( regularthumb )
2008 {
2009 CachedPixbuf *cp = NULL;
2010 cp = g_malloc ( sizeof ( CachedPixbuf ) );
2011 if ( dp->vtl->image_size == 128 )
2012 cp->pixbuf = regularthumb;
2013 else
2014 {
2015 cp->pixbuf = a_thumbnails_scale_pixbuf(regularthumb, dp->vtl->image_size, dp->vtl->image_size);
2016 g_assert ( cp->pixbuf );
2017 g_object_unref ( G_OBJECT(regularthumb) );
2018 }
2019 cp->image = g_strdup ( image );
2020
2021 /* needed so 'click picture' tool knows how big the pic is; we don't
2022 * store it in cp because they may have been freed already. */
2023 wp->image_width = gdk_pixbuf_get_width ( cp->pixbuf );
2024 wp->image_height = gdk_pixbuf_get_height ( cp->pixbuf );
2025
2026 g_queue_push_head ( dp->vtl->image_cache, cp );
2027 if ( dp->vtl->image_cache->length > dp->vtl->image_cache_size )
2028 cached_pixbuf_free ( g_queue_pop_tail ( dp->vtl->image_cache ) );
2029
2030 pixbuf = cp->pixbuf;
2031 }
2032 else
2033 {
2034 pixbuf = a_thumbnails_get_default (); /* thumbnail not yet loaded */
2035 }
2036 }
2037 if ( pixbuf )
2038 {
2039 gint w, h;
2040 w = gdk_pixbuf_get_width ( pixbuf );
2041 h = gdk_pixbuf_get_height ( pixbuf );
2042
2043 if ( x+(w/2) > 0 && y+(h/2) > 0 && x-(w/2) < dp->width && y-(h/2) < dp->height ) /* always draw within boundaries */
2044 {
2045 if ( vik_viewport_get_draw_highlight ( dp->vp ) ) {
2046 if ( dp->vtl == vik_window_get_selected_trw_layer ( dp->vw ) ||
2047 dp->vtl->waypoints == vik_window_get_selected_waypoints ( dp->vw ) ||
2048 wp == vik_window_get_selected_waypoint ( dp->vw ) ) {
2049 // Highlighted - so draw a little border around the chosen one
2050 // single line seems a little weak so draw 2 of them
2051 vik_viewport_draw_rectangle (dp->vp, vik_viewport_get_gc_highlight (dp->vp), FALSE,
2052 x - (w/2) - 1, y - (h/2) - 1, w + 2, h + 2 );
2053 vik_viewport_draw_rectangle (dp->vp, vik_viewport_get_gc_highlight (dp->vp), FALSE,
2054 x - (w/2) - 2, y - (h/2) - 2, w + 4, h + 4 );
2055 }
2056 }
2057 if ( dp->vtl->image_alpha == 255 )
2058 vik_viewport_draw_pixbuf ( dp->vp, pixbuf, 0, 0, x - (w/2), y - (h/2), w, h );
2059 else
2060 vik_viewport_draw_pixbuf_with_alpha ( dp->vp, pixbuf, dp->vtl->image_alpha, 0, 0, x - (w/2), y - (h/2), w, h );
2061 }
2062 return; /* if failed to draw picture, default to drawing regular waypoint (below) */
2063 }
2064 }
2065
2066 // Draw appropriate symbol - either symbol image or simple types
2067 if ( dp->vtl->wp_draw_symbols && wp->symbol && wp->symbol_pixbuf ) {
2068 vik_viewport_draw_pixbuf ( dp->vp, wp->symbol_pixbuf, 0, 0, x - gdk_pixbuf_get_width(wp->symbol_pixbuf)/2, y - gdk_pixbuf_get_height(wp->symbol_pixbuf)/2, -1, -1 );
2069 }
2070 else if ( wp == dp->vtl->current_wp ) {
2071 switch ( dp->vtl->wp_symbol ) {
2072 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;
2073 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;
2074 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;
2075 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 );
2076 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 );
2077 }
2078 }
2079 else {
2080 switch ( dp->vtl->wp_symbol ) {
2081 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;
2082 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;
2083 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;
2084 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 );
2085 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;
2086 }
2087 }
2088
2089 if ( dp->vtl->drawlabels )
2090 {
2091 /* thanks to the GPSDrive people (Fritz Ganter et al.) for hints on this part ... yah, I'm too lazy to study documentation */
2092 gint label_x, label_y;
2093 gint width, height;
2094 // Hopefully name won't break the markup (may need to sanitize - g_markup_escape_text())
2095
2096 // Could this stored in the waypoint rather than recreating each pass?
2097 gchar *wp_label_markup = g_strdup_printf ( "<span size=\"%s\">%s</span>", dp->vtl->wp_fsize_str, wp->name );
2098
2099 if ( pango_parse_markup ( wp_label_markup, -1, 0, NULL, NULL, NULL, NULL ) )
2100 pango_layout_set_markup ( dp->vtl->wplabellayout, wp_label_markup, -1 );
2101 else
2102 // Fallback if parse failure
2103 pango_layout_set_text ( dp->vtl->wplabellayout, wp->name, -1 );
2104
2105 g_free ( wp_label_markup );
2106
2107 pango_layout_get_pixel_size ( dp->vtl->wplabellayout, &width, &height );
2108 label_x = x - width/2;
2109 if ( wp->symbol_pixbuf )
2110 label_y = y - height - 2 - gdk_pixbuf_get_height(wp->symbol_pixbuf)/2;
2111 else
2112 label_y = y - dp->vtl->wp_size - height - 2;
2113
2114 /* if highlight mode on, then draw background text in highlight colour */
2115 if ( vik_viewport_get_draw_highlight ( dp->vp ) ) {
2116 if ( dp->vtl == vik_window_get_selected_trw_layer ( dp->vw ) ||
2117 dp->vtl->waypoints == vik_window_get_selected_waypoints ( dp->vw ) ||
2118 wp == vik_window_get_selected_waypoint ( dp->vw ) )
2119 vik_viewport_draw_rectangle ( dp->vp, vik_viewport_get_gc_highlight (dp->vp), TRUE, label_x - 1, label_y-1,width+2,height+2);
2120 else
2121 vik_viewport_draw_rectangle ( dp->vp, dp->vtl->waypoint_bg_gc, TRUE, label_x - 1, label_y-1,width+2,height+2);
2122 }
2123 else {
2124 vik_viewport_draw_rectangle ( dp->vp, dp->vtl->waypoint_bg_gc, TRUE, label_x - 1, label_y-1,width+2,height+2);
2125 }
2126 vik_viewport_draw_layout ( dp->vp, dp->vtl->waypoint_text_gc, label_x, label_y, dp->vtl->wplabellayout );
2127 }
2128 }
2129}
2130
2131static void trw_layer_draw_waypoint_cb ( gpointer id, VikWaypoint *wp, struct DrawingParams *dp )
2132{
2133 if ( BBOX_INTERSECT ( dp->vtl->waypoints_bbox, dp->bbox ) ) {
2134 trw_layer_draw_waypoint ( id, wp, dp );
2135 }
2136}
2137
2138static void trw_layer_draw ( VikTrwLayer *l, gpointer data )
2139{
2140 static struct DrawingParams dp;
2141 g_assert ( l != NULL );
2142
2143 init_drawing_params ( &dp, l, VIK_VIEWPORT(data) );
2144
2145 if ( l->tracks_visible )
2146 g_hash_table_foreach ( l->tracks, (GHFunc) trw_layer_draw_track_cb, &dp );
2147
2148 if ( l->routes_visible )
2149 g_hash_table_foreach ( l->routes, (GHFunc) trw_layer_draw_track_cb, &dp );
2150
2151 if (l->waypoints_visible)
2152 g_hash_table_foreach ( l->waypoints, (GHFunc) trw_layer_draw_waypoint_cb, &dp );
2153}
2154
2155static void trw_layer_free_track_gcs ( VikTrwLayer *vtl )
2156{
2157 int i;
2158 if ( vtl->track_bg_gc )
2159 {
2160 g_object_unref ( vtl->track_bg_gc );
2161 vtl->track_bg_gc = NULL;
2162 }
2163 if ( vtl->track_1color_gc )
2164 {
2165 g_object_unref ( vtl->track_1color_gc );
2166 vtl->track_1color_gc = NULL;
2167 }
2168 if ( vtl->current_track_gc )
2169 {
2170 g_object_unref ( vtl->current_track_gc );
2171 vtl->current_track_gc = NULL;
2172 }
2173 if ( vtl->current_track_newpoint_gc )
2174 {
2175 g_object_unref ( vtl->current_track_newpoint_gc );
2176 vtl->current_track_newpoint_gc = NULL;
2177 }
2178
2179 if ( ! vtl->track_gc )
2180 return;
2181 for ( i = vtl->track_gc->len - 1; i >= 0; i-- )
2182 g_object_unref ( g_array_index ( vtl->track_gc, GObject *, i ) );
2183 g_array_free ( vtl->track_gc, TRUE );
2184 vtl->track_gc = NULL;
2185}
2186
2187static void trw_layer_new_track_gcs ( VikTrwLayer *vtl, VikViewport *vp )
2188{
2189 GdkGC *gc[ VIK_TRW_LAYER_TRACK_GC ];
2190 gint width = vtl->line_thickness;
2191
2192 if ( vtl->track_gc )
2193 trw_layer_free_track_gcs ( vtl );
2194
2195 if ( vtl->track_bg_gc )
2196 g_object_unref ( vtl->track_bg_gc );
2197 vtl->track_bg_gc = vik_viewport_new_gc_from_color ( vp, &(vtl->track_bg_color), width + vtl->bg_line_thickness );
2198
2199 // Ensure new track drawing heeds line thickness setting
2200 // however always have a minium of 2, as 1 pixel is really narrow
2201 gint new_track_width = (vtl->line_thickness < 2) ? 2 : vtl->line_thickness;
2202
2203 if ( vtl->current_track_gc )
2204 g_object_unref ( vtl->current_track_gc );
2205 vtl->current_track_gc = vik_viewport_new_gc ( vp, "#FF0000", new_track_width );
2206 gdk_gc_set_line_attributes ( vtl->current_track_gc, new_track_width, GDK_LINE_ON_OFF_DASH, GDK_CAP_ROUND, GDK_JOIN_ROUND );
2207
2208 // 'newpoint' gc is exactly the same as the current track gc
2209 if ( vtl->current_track_newpoint_gc )
2210 g_object_unref ( vtl->current_track_newpoint_gc );
2211 vtl->current_track_newpoint_gc = vik_viewport_new_gc ( vp, "#FF0000", new_track_width );
2212 gdk_gc_set_line_attributes ( vtl->current_track_newpoint_gc, new_track_width, GDK_LINE_ON_OFF_DASH, GDK_CAP_ROUND, GDK_JOIN_ROUND );
2213
2214 vtl->track_gc = g_array_sized_new ( FALSE, FALSE, sizeof ( GdkGC * ), VIK_TRW_LAYER_TRACK_GC );
2215
2216 gc[VIK_TRW_LAYER_TRACK_GC_STOP] = vik_viewport_new_gc ( vp, "#874200", width );
2217 gc[VIK_TRW_LAYER_TRACK_GC_BLACK] = vik_viewport_new_gc ( vp, "#000000", width ); // black
2218
2219 gc[VIK_TRW_LAYER_TRACK_GC_SLOW] = vik_viewport_new_gc ( vp, "#E6202E", width ); // red-ish
2220 gc[VIK_TRW_LAYER_TRACK_GC_AVER] = vik_viewport_new_gc ( vp, "#D2CD26", width ); // yellow-ish
2221 gc[VIK_TRW_LAYER_TRACK_GC_FAST] = vik_viewport_new_gc ( vp, "#2B8700", width ); // green-ish
2222
2223 gc[VIK_TRW_LAYER_TRACK_GC_SINGLE] = vik_viewport_new_gc_from_color ( vp, &(vtl->track_color), width );
2224
2225 g_array_append_vals ( vtl->track_gc, gc, VIK_TRW_LAYER_TRACK_GC );
2226}
2227
2228static VikTrwLayer* trw_layer_create ( VikViewport *vp )
2229{
2230 VikTrwLayer *rv = trw_layer_new1 ( vp );
2231 vik_layer_rename ( VIK_LAYER(rv), vik_trw_layer_interface.name );
2232
2233 if ( vp == NULL || gtk_widget_get_window(GTK_WIDGET(vp)) == NULL ) {
2234 /* early exit, as the rest is GUI related */
2235 return rv;
2236 }
2237
2238 rv->wplabellayout = gtk_widget_create_pango_layout (GTK_WIDGET(vp), NULL);
2239 pango_layout_set_font_description (rv->wplabellayout, gtk_widget_get_style(GTK_WIDGET(vp))->font_desc);
2240
2241 rv->tracklabellayout = gtk_widget_create_pango_layout (GTK_WIDGET(vp), NULL);
2242 pango_layout_set_font_description (rv->tracklabellayout, gtk_widget_get_style(GTK_WIDGET(vp))->font_desc);
2243
2244 trw_layer_new_track_gcs ( rv, vp );
2245
2246 rv->waypoint_gc = vik_viewport_new_gc_from_color ( vp, &(rv->waypoint_color), 2 );
2247 rv->waypoint_text_gc = vik_viewport_new_gc_from_color ( vp, &(rv->waypoint_text_color), 1 );
2248 rv->waypoint_bg_gc = vik_viewport_new_gc_from_color ( vp, &(rv->waypoint_bg_color), 1 );
2249 gdk_gc_set_function ( rv->waypoint_bg_gc, rv->wpbgand );
2250
2251 rv->coord_mode = vik_viewport_get_coord_mode ( vp );
2252
2253 rv->menu_selection = vik_layer_get_interface(VIK_LAYER(rv)->type)->menu_items_selection;
2254
2255 return rv;
2256}
2257
2258#define SMALL_ICON_SIZE 18
2259/*
2260 * Can accept a null symbol, and may return null value
2261 */
2262GdkPixbuf* get_wp_sym_small ( gchar *symbol )
2263{
2264 GdkPixbuf* wp_icon = a_get_wp_sym (symbol);
2265 // ATM a_get_wp_sym returns a cached icon, with the size dependent on the preferences.
2266 // So needing a small icon for the treeview may need some resizing:
2267 if ( wp_icon && gdk_pixbuf_get_width ( wp_icon ) != SMALL_ICON_SIZE )
2268 wp_icon = gdk_pixbuf_scale_simple ( wp_icon, SMALL_ICON_SIZE, SMALL_ICON_SIZE, GDK_INTERP_BILINEAR );
2269 return wp_icon;
2270}
2271
2272static void trw_layer_realize_track ( gpointer id, VikTrack *track, gpointer pass_along[5] )
2273{
2274 GtkTreeIter *new_iter = g_malloc(sizeof(GtkTreeIter));
2275
2276 GdkPixbuf *pixbuf = NULL;
2277
2278 if ( track->has_color ) {
2279 pixbuf = gdk_pixbuf_new ( GDK_COLORSPACE_RGB, FALSE, 8, SMALL_ICON_SIZE, SMALL_ICON_SIZE );
2280 // Annoyingly the GdkColor.pixel does not give the correct color when passed to gdk_pixbuf_fill (even when alloc'ed)
2281 // Here is some magic found to do the conversion
2282 // http://www.cs.binghamton.edu/~sgreene/cs360-2011s/topics/gtk+-2.20.1/gtk/gtkcolorbutton.c
2283 guint32 pixel = ((track->color.red & 0xff00) << 16) |
2284 ((track->color.green & 0xff00) << 8) |
2285 (track->color.blue & 0xff00);
2286
2287 gdk_pixbuf_fill ( pixbuf, pixel );
2288 }
2289
2290 vik_treeview_add_sublayer ( (VikTreeview *) pass_along[3], (GtkTreeIter *) pass_along[0], (GtkTreeIter *) pass_along[1], track->name, pass_along[2], id, GPOINTER_TO_INT (pass_along[4]), pixbuf, TRUE, TRUE );
2291
2292 if ( pixbuf )
2293 g_object_unref (pixbuf);
2294
2295 *new_iter = *((GtkTreeIter *) pass_along[1]);
2296 if ( track->is_route )
2297 g_hash_table_insert ( VIK_TRW_LAYER(pass_along[2])->routes_iters, id, new_iter );
2298 else
2299 g_hash_table_insert ( VIK_TRW_LAYER(pass_along[2])->tracks_iters, id, new_iter );
2300
2301 if ( ! track->visible )
2302 vik_treeview_item_set_visible ( (VikTreeview *) pass_along[3], (GtkTreeIter *) pass_along[1], FALSE );
2303}
2304
2305static void trw_layer_realize_waypoint ( gpointer id, VikWaypoint *wp, gpointer pass_along[5] )
2306{
2307 GtkTreeIter *new_iter = g_malloc(sizeof(GtkTreeIter));
2308
2309 vik_treeview_add_sublayer ( (VikTreeview *) pass_along[3], (GtkTreeIter *) pass_along[0], (GtkTreeIter *) pass_along[1], wp->name, pass_along[2], id, GPOINTER_TO_UINT (pass_along[4]), get_wp_sym_small (wp->symbol), TRUE, TRUE );
2310
2311 *new_iter = *((GtkTreeIter *) pass_along[1]);
2312 g_hash_table_insert ( VIK_TRW_LAYER(pass_along[2])->waypoints_iters, id, new_iter );
2313
2314 if ( ! wp->visible )
2315 vik_treeview_item_set_visible ( (VikTreeview *) pass_along[3], (GtkTreeIter *) pass_along[1], FALSE );
2316}
2317
2318static void trw_layer_add_sublayer_tracks ( VikTrwLayer *vtl, VikTreeview *vt, GtkTreeIter *layer_iter )
2319{
2320 vik_treeview_add_sublayer ( (VikTreeview *) vt, layer_iter, &(vtl->tracks_iter), _("Tracks"), vtl, NULL, VIK_TRW_LAYER_SUBLAYER_TRACKS, NULL, TRUE, FALSE );
2321}
2322
2323static void trw_layer_add_sublayer_waypoints ( VikTrwLayer *vtl, VikTreeview *vt, GtkTreeIter *layer_iter )
2324{
2325 vik_treeview_add_sublayer ( (VikTreeview *) vt, layer_iter, &(vtl->waypoints_iter), _("Waypoints"), vtl, NULL, VIK_TRW_LAYER_SUBLAYER_WAYPOINTS, NULL, TRUE, FALSE );
2326}
2327
2328static void trw_layer_add_sublayer_routes ( VikTrwLayer *vtl, VikTreeview *vt, GtkTreeIter *layer_iter )
2329{
2330 vik_treeview_add_sublayer ( (VikTreeview *) vt, layer_iter, &(vtl->routes_iter), _("Routes"), vtl, NULL, VIK_TRW_LAYER_SUBLAYER_ROUTES, NULL, TRUE, FALSE );
2331}
2332
2333static void trw_layer_realize ( VikTrwLayer *vtl, VikTreeview *vt, GtkTreeIter *layer_iter )
2334{
2335 GtkTreeIter iter2;
2336 gpointer pass_along[5] = { &(vtl->tracks_iter), &iter2, vtl, vt, GINT_TO_POINTER(VIK_TRW_LAYER_SUBLAYER_TRACK) };
2337
2338 if ( g_hash_table_size (vtl->tracks) > 0 ) {
2339 trw_layer_add_sublayer_tracks ( vtl, vt , layer_iter );
2340
2341 g_hash_table_foreach ( vtl->tracks, (GHFunc) trw_layer_realize_track, pass_along );
2342
2343 vik_treeview_item_set_visible ( vt, &(vtl->tracks_iter), vtl->tracks_visible );
2344 }
2345
2346 if ( g_hash_table_size (vtl->routes) > 0 ) {
2347 trw_layer_add_sublayer_routes ( vtl, vt, layer_iter );
2348
2349 pass_along[0] = &(vtl->routes_iter);
2350 pass_along[4] = GINT_TO_POINTER(VIK_TRW_LAYER_SUBLAYER_ROUTE);
2351
2352 g_hash_table_foreach ( vtl->routes, (GHFunc) trw_layer_realize_track, pass_along );
2353
2354 vik_treeview_item_set_visible ( (VikTreeview *) vt, &(vtl->routes_iter), vtl->routes_visible );
2355 }
2356
2357 if ( g_hash_table_size (vtl->waypoints) > 0 ) {
2358 trw_layer_add_sublayer_waypoints ( vtl, vt, layer_iter );
2359
2360 pass_along[0] = &(vtl->waypoints_iter);
2361 pass_along[4] = GINT_TO_POINTER(VIK_TRW_LAYER_SUBLAYER_WAYPOINT);
2362
2363 g_hash_table_foreach ( vtl->waypoints, (GHFunc) trw_layer_realize_waypoint, pass_along );
2364
2365 vik_treeview_item_set_visible ( (VikTreeview *) vt, &(vtl->waypoints_iter), vtl->waypoints_visible );
2366 }
2367
2368}
2369
2370static gboolean trw_layer_sublayer_toggle_visible ( VikTrwLayer *l, gint subtype, gpointer sublayer )
2371{
2372 switch ( subtype )
2373 {
2374 case VIK_TRW_LAYER_SUBLAYER_TRACKS: return (l->tracks_visible ^= 1);
2375 case VIK_TRW_LAYER_SUBLAYER_WAYPOINTS: return (l->waypoints_visible ^= 1);
2376 case VIK_TRW_LAYER_SUBLAYER_ROUTES: return (l->routes_visible ^= 1);
2377 case VIK_TRW_LAYER_SUBLAYER_TRACK:
2378 {
2379 VikTrack *t = g_hash_table_lookup ( l->tracks, sublayer );
2380 if (t)
2381 return (t->visible ^= 1);
2382 else
2383 return TRUE;
2384 }
2385 case VIK_TRW_LAYER_SUBLAYER_WAYPOINT:
2386 {
2387 VikWaypoint *t = g_hash_table_lookup ( l->waypoints, sublayer );
2388 if (t)
2389 return (t->visible ^= 1);
2390 else
2391 return TRUE;
2392 }
2393 case VIK_TRW_LAYER_SUBLAYER_ROUTE:
2394 {
2395 VikTrack *t = g_hash_table_lookup ( l->routes, sublayer );
2396 if (t)
2397 return (t->visible ^= 1);
2398 else
2399 return TRUE;
2400 }
2401 }
2402 return TRUE;
2403}
2404
2405/*
2406 * Return a property about tracks for this layer
2407 */
2408gint vik_trw_layer_get_property_tracks_line_thickness ( VikTrwLayer *vtl )
2409{
2410 return vtl->line_thickness;
2411}
2412
2413// Structure to hold multiple track information for a layer
2414typedef struct {
2415 gdouble length;
2416 time_t start_time;
2417 time_t end_time;
2418 gint duration;
2419} tooltip_tracks;
2420
2421/*
2422 * Build up layer multiple track information via updating the tooltip_tracks structure
2423 */
2424static void trw_layer_tracks_tooltip ( const gchar *name, VikTrack *tr, tooltip_tracks *tt )
2425{
2426 tt->length = tt->length + vik_track_get_length (tr);
2427
2428 // Ensure times are available
2429 if ( tr->trackpoints &&
2430 VIK_TRACKPOINT(tr->trackpoints->data)->has_timestamp &&
2431 VIK_TRACKPOINT(g_list_last(tr->trackpoints)->data)->has_timestamp ) {
2432
2433 time_t t1, t2;
2434 t1 = VIK_TRACKPOINT(tr->trackpoints->data)->timestamp;
2435 t2 = VIK_TRACKPOINT(g_list_last(tr->trackpoints)->data)->timestamp;
2436
2437 // Assume never actually have a track with a time of 0 (1st Jan 1970)
2438 // Hence initialize to the first 'proper' value
2439 if ( tt->start_time == 0 )
2440 tt->start_time = t1;
2441 if ( tt->end_time == 0 )
2442 tt->end_time = t2;
2443
2444 // Update find the earliest / last times
2445 if ( t1 < tt->start_time )
2446 tt->start_time = t1;
2447 if ( t2 > tt->end_time )
2448 tt->end_time = t2;
2449
2450 // Keep track of total time
2451 // there maybe gaps within a track (eg segments)
2452 // but this should be generally good enough for a simple indicator
2453 tt->duration = tt->duration + (int)(t2-t1);
2454 }
2455}
2456
2457/*
2458 * Generate tooltip text for the layer.
2459 * This is relatively complicated as it considers information for
2460 * no tracks, a single track or multiple tracks
2461 * (which may or may not have timing information)
2462 */
2463static const gchar* trw_layer_layer_tooltip ( VikTrwLayer *vtl )
2464{
2465 gchar tbuf1[32];
2466 gchar tbuf2[64];
2467 gchar tbuf3[64];
2468 gchar tbuf4[10];
2469 tbuf1[0] = '\0';
2470 tbuf2[0] = '\0';
2471 tbuf3[0] = '\0';
2472 tbuf4[0] = '\0';
2473
2474 static gchar tmp_buf[128];
2475 tmp_buf[0] = '\0';
2476
2477 // For compact date format I'm using '%x' [The preferred date representation for the current locale without the time.]
2478
2479 // Safety check - I think these should always be valid
2480 if ( vtl->tracks && vtl->waypoints ) {
2481 tooltip_tracks tt = { 0.0, 0, 0 };
2482 g_hash_table_foreach ( vtl->tracks, (GHFunc) trw_layer_tracks_tooltip, &tt );
2483
2484 GDate* gdate_start = g_date_new ();
2485 g_date_set_time_t (gdate_start, tt.start_time);
2486
2487 GDate* gdate_end = g_date_new ();
2488 g_date_set_time_t (gdate_end, tt.end_time);
2489
2490 if ( g_date_compare (gdate_start, gdate_end) ) {
2491 // Dates differ so print range on separate line
2492 g_date_strftime (tbuf1, sizeof(tbuf1), "%x", gdate_start);
2493 g_date_strftime (tbuf2, sizeof(tbuf2), "%x", gdate_end);
2494 g_snprintf (tbuf3, sizeof(tbuf3), "%s to %s\n", tbuf1, tbuf2);
2495 }
2496 else {
2497 // Same date so just show it and keep rest of text on the same line - provided it's a valid time!
2498 if ( tt.start_time != 0 )
2499 g_date_strftime (tbuf3, sizeof(tbuf3), "%x: ", gdate_start);
2500 }
2501
2502 tbuf2[0] = '\0';
2503 if ( tt.length > 0.0 ) {
2504 gdouble len_in_units;
2505
2506 // Setup info dependent on distance units
2507 if ( a_vik_get_units_distance() == VIK_UNITS_DISTANCE_MILES ) {
2508 g_snprintf (tbuf4, sizeof(tbuf4), "miles");
2509 len_in_units = VIK_METERS_TO_MILES(tt.length);
2510 }
2511 else {
2512 g_snprintf (tbuf4, sizeof(tbuf4), "kms");
2513 len_in_units = tt.length/1000.0;
2514 }
2515
2516 // Timing information if available
2517 tbuf1[0] = '\0';
2518 if ( tt.duration > 0 ) {
2519 g_snprintf (tbuf1, sizeof(tbuf1),
2520 _(" in %d:%02d hrs:mins"),
2521 (int)round(tt.duration/3600), (int)round((tt.duration/60)%60));
2522 }
2523 g_snprintf (tbuf2, sizeof(tbuf2),
2524 _("\n%sTotal Length %.1f %s%s"),
2525 tbuf3, len_in_units, tbuf4, tbuf1);
2526 }
2527
2528 // Put together all the elements to form compact tooltip text
2529 g_snprintf (tmp_buf, sizeof(tmp_buf),
2530 _("Tracks: %d - Waypoints: %d - Routes: %d%s"),
2531 g_hash_table_size (vtl->tracks), g_hash_table_size (vtl->waypoints), g_hash_table_size (vtl->routes), tbuf2);
2532
2533 g_date_free (gdate_start);
2534 g_date_free (gdate_end);
2535
2536 }
2537
2538 return tmp_buf;
2539}
2540
2541static const gchar* trw_layer_sublayer_tooltip ( VikTrwLayer *l, gint subtype, gpointer sublayer )
2542{
2543 switch ( subtype )
2544 {
2545 case VIK_TRW_LAYER_SUBLAYER_TRACKS:
2546 {
2547 // Very simple tooltip - may expand detail in the future...
2548 static gchar tmp_buf[32];
2549 g_snprintf (tmp_buf, sizeof(tmp_buf),
2550 _("Tracks: %d"),
2551 g_hash_table_size (l->tracks));
2552 return tmp_buf;
2553 }
2554 break;
2555 case VIK_TRW_LAYER_SUBLAYER_ROUTES:
2556 {
2557 // Very simple tooltip - may expand detail in the future...
2558 static gchar tmp_buf[32];
2559 g_snprintf (tmp_buf, sizeof(tmp_buf),
2560 _("Routes: %d"),
2561 g_hash_table_size (l->routes));
2562 return tmp_buf;
2563 }
2564 break;
2565
2566 case VIK_TRW_LAYER_SUBLAYER_ROUTE:
2567 // Same tooltip for a route
2568 case VIK_TRW_LAYER_SUBLAYER_TRACK:
2569 {
2570 VikTrack *tr;
2571 if ( subtype == VIK_TRW_LAYER_SUBLAYER_TRACK )
2572 tr = g_hash_table_lookup ( l->tracks, sublayer );
2573 else
2574 tr = g_hash_table_lookup ( l->routes, sublayer );
2575
2576 if ( tr ) {
2577 // Could be a better way of handling strings - but this works...
2578 gchar time_buf1[20];
2579 gchar time_buf2[20];
2580 time_buf1[0] = '\0';
2581 time_buf2[0] = '\0';
2582 static gchar tmp_buf[100];
2583 // Compact info: Short date eg (11/20/99), duration and length
2584 // Hopefully these are the things that are most useful and so promoted into the tooltip
2585 if ( tr->trackpoints && VIK_TRACKPOINT(tr->trackpoints->data)->has_timestamp ) {
2586 // %x The preferred date representation for the current locale without the time.
2587 strftime (time_buf1, sizeof(time_buf1), "%x: ", gmtime(&(VIK_TRACKPOINT(tr->trackpoints->data)->timestamp)));
2588 if ( VIK_TRACKPOINT(g_list_last(tr->trackpoints)->data)->has_timestamp ) {
2589 gint dur = ( (VIK_TRACKPOINT(g_list_last(tr->trackpoints)->data)->timestamp) - (VIK_TRACKPOINT(tr->trackpoints->data)->timestamp) );
2590 if ( dur > 0 )
2591 g_snprintf ( time_buf2, sizeof(time_buf2), _("- %d:%02d hrs:mins"), (int)round(dur/3600), (int)round((dur/60)%60) );
2592 }
2593 }
2594 // Get length and consider the appropriate distance units
2595 gdouble tr_len = vik_track_get_length(tr);
2596 vik_units_distance_t dist_units = a_vik_get_units_distance ();
2597 switch (dist_units) {
2598 case VIK_UNITS_DISTANCE_KILOMETRES:
2599 g_snprintf (tmp_buf, sizeof(tmp_buf), _("%s%.1f km %s"), time_buf1, tr_len/1000.0, time_buf2);
2600 break;
2601 case VIK_UNITS_DISTANCE_MILES:
2602 g_snprintf (tmp_buf, sizeof(tmp_buf), _("%s%.1f miles %s"), time_buf1, VIK_METERS_TO_MILES(tr_len), time_buf2);
2603 break;
2604 default:
2605 break;
2606 }
2607 return tmp_buf;
2608 }
2609 }
2610 break;
2611 case VIK_TRW_LAYER_SUBLAYER_WAYPOINTS:
2612 {
2613 // Very simple tooltip - may expand detail in the future...
2614 static gchar tmp_buf[32];
2615 g_snprintf (tmp_buf, sizeof(tmp_buf),
2616 _("Waypoints: %d"),
2617 g_hash_table_size (l->waypoints));
2618 return tmp_buf;
2619 }
2620 break;
2621 case VIK_TRW_LAYER_SUBLAYER_WAYPOINT:
2622 {
2623 VikWaypoint *w = g_hash_table_lookup ( l->waypoints, sublayer );
2624 // NB It's OK to return NULL
2625 if ( w ) {
2626 if ( w->comment )
2627 return w->comment;
2628 else
2629 return w->description;
2630 }
2631 }
2632 break;
2633 default: break;
2634 }
2635 return NULL;
2636}
2637
2638#define VIK_SETTINGS_TRKPT_SELECTED_STATUSBAR_FORMAT "trkpt_selected_statusbar_format"
2639
2640/**
2641 * set_statusbar_msg_info_trkpt:
2642 *
2643 * Function to show track point information on the statusbar
2644 * Items displayed is controlled by the settings format code
2645 */
2646static void set_statusbar_msg_info_trkpt ( VikTrwLayer *vtl, VikTrackpoint *trkpt )
2647{
2648 gchar *statusbar_format_code = NULL;
2649 gboolean need2free = FALSE;
2650 if ( !a_settings_get_string ( VIK_SETTINGS_TRKPT_SELECTED_STATUSBAR_FORMAT, &statusbar_format_code ) ) {
2651 // Otherwise use default
2652 statusbar_format_code = g_strdup ( "KEATDN" );
2653 need2free = TRUE;
2654 }
2655
2656 gchar *msg = vu_trackpoint_formatted_message ( statusbar_format_code, trkpt, NULL, vtl->current_tp_track );
2657 vik_statusbar_set_message ( vik_window_get_statusbar (VIK_WINDOW(VIK_GTK_WINDOW_FROM_LAYER(vtl))), VIK_STATUSBAR_INFO, msg );
2658 g_free ( msg );
2659
2660 if ( need2free )
2661 g_free ( statusbar_format_code );
2662}
2663
2664/*
2665 * Function to show basic waypoint information on the statusbar
2666 */
2667static void set_statusbar_msg_info_wpt ( VikTrwLayer *vtl, VikWaypoint *wpt )
2668{
2669 gchar tmp_buf1[64];
2670 switch (a_vik_get_units_height ()) {
2671 case VIK_UNITS_HEIGHT_FEET:
2672 g_snprintf(tmp_buf1, sizeof(tmp_buf1), _("Wpt: Alt %dft"), (int)round(VIK_METERS_TO_FEET(wpt->altitude)));
2673 break;
2674 default:
2675 //VIK_UNITS_HEIGHT_METRES:
2676 g_snprintf(tmp_buf1, sizeof(tmp_buf1), _("Wpt: Alt %dm"), (int)round(wpt->altitude));
2677 }
2678
2679 // Position part
2680 // Position is put last, as this bit is most likely not to be seen if the display is not big enough,
2681 // one can easily use the current pointer position to see this if needed
2682 gchar *lat = NULL, *lon = NULL;
2683 static struct LatLon ll;
2684 vik_coord_to_latlon (&(wpt->coord), &ll);
2685 a_coords_latlon_to_string ( &ll, &lat, &lon );
2686
2687 // Combine parts to make overall message
2688 gchar *msg;
2689 if ( wpt->comment )
2690 // Add comment if available
2691 msg = g_strdup_printf ( _("%s | %s %s | Comment: %s"), tmp_buf1, lat, lon, wpt->comment );
2692 else
2693 msg = g_strdup_printf ( _("%s | %s %s"), tmp_buf1, lat, lon );
2694 vik_statusbar_set_message ( vik_window_get_statusbar (VIK_WINDOW(VIK_GTK_WINDOW_FROM_LAYER(vtl))), VIK_STATUSBAR_INFO, msg );
2695 g_free ( lat );
2696 g_free ( lon );
2697 g_free ( msg );
2698}
2699
2700/**
2701 * General layer selection function, find out which bit is selected and take appropriate action
2702 */
2703static gboolean trw_layer_selected ( VikTrwLayer *l, gint subtype, gpointer sublayer, gint type, gpointer vlp )
2704{
2705 // Reset
2706 l->current_wp = NULL;
2707 l->current_wp_id = NULL;
2708 trw_layer_cancel_current_tp ( l, FALSE );
2709
2710 // Clear statusbar
2711 vik_statusbar_set_message ( vik_window_get_statusbar (VIK_WINDOW(VIK_GTK_WINDOW_FROM_LAYER(l))), VIK_STATUSBAR_INFO, "" );
2712
2713 switch ( type )
2714 {
2715 case VIK_TREEVIEW_TYPE_LAYER:
2716 {
2717 vik_window_set_selected_trw_layer ( (VikWindow *)VIK_GTK_WINDOW_FROM_LAYER(l), l );
2718 /* Mark for redraw */
2719 return TRUE;
2720 }
2721 break;
2722
2723 case VIK_TREEVIEW_TYPE_SUBLAYER:
2724 {
2725 switch ( subtype )
2726 {
2727 case VIK_TRW_LAYER_SUBLAYER_TRACKS:
2728 {
2729 vik_window_set_selected_tracks ( (VikWindow *)VIK_GTK_WINDOW_FROM_LAYER(l), l->tracks, l );
2730 /* Mark for redraw */
2731 return TRUE;
2732 }
2733 break;
2734 case VIK_TRW_LAYER_SUBLAYER_TRACK:
2735 {
2736 VikTrack *track = g_hash_table_lookup ( l->tracks, sublayer );
2737 vik_window_set_selected_track ( (VikWindow *)VIK_GTK_WINDOW_FROM_LAYER(l), (gpointer)track, l );
2738 /* Mark for redraw */
2739 return TRUE;
2740 }
2741 break;
2742 case VIK_TRW_LAYER_SUBLAYER_ROUTES:
2743 {
2744 vik_window_set_selected_tracks ( (VikWindow *)VIK_GTK_WINDOW_FROM_LAYER(l), l->routes, l );
2745 /* Mark for redraw */
2746 return TRUE;
2747 }
2748 break;
2749 case VIK_TRW_LAYER_SUBLAYER_ROUTE:
2750 {
2751 VikTrack *track = g_hash_table_lookup ( l->routes, sublayer );
2752 vik_window_set_selected_track ( (VikWindow *)VIK_GTK_WINDOW_FROM_LAYER(l), (gpointer)track, l );
2753 /* Mark for redraw */
2754 return TRUE;
2755 }
2756 break;
2757 case VIK_TRW_LAYER_SUBLAYER_WAYPOINTS:
2758 {
2759 vik_window_set_selected_waypoints ( (VikWindow *)VIK_GTK_WINDOW_FROM_LAYER(l), l->waypoints, l );
2760 /* Mark for redraw */
2761 return TRUE;
2762 }
2763 break;
2764 case VIK_TRW_LAYER_SUBLAYER_WAYPOINT:
2765 {
2766 VikWaypoint *wpt = g_hash_table_lookup ( l->waypoints, sublayer );
2767 if ( wpt ) {
2768 vik_window_set_selected_waypoint ( (VikWindow *)VIK_GTK_WINDOW_FROM_LAYER(l), (gpointer)wpt, l );
2769 // Show some waypoint info
2770 set_statusbar_msg_info_wpt ( l, wpt );
2771 /* Mark for redraw */
2772 return TRUE;
2773 }
2774 }
2775 break;
2776 default:
2777 {
2778 return vik_window_clear_highlight ( (VikWindow *)VIK_GTK_WINDOW_FROM_LAYER(l) );
2779 }
2780 break;
2781 }
2782 return FALSE;
2783 }
2784 break;
2785
2786 default:
2787 return vik_window_clear_highlight ( (VikWindow *)VIK_GTK_WINDOW_FROM_LAYER(l) );
2788 break;
2789 }
2790}
2791
2792GHashTable *vik_trw_layer_get_tracks ( VikTrwLayer *l )
2793{
2794 return l->tracks;
2795}
2796
2797GHashTable *vik_trw_layer_get_routes ( VikTrwLayer *l )
2798{
2799 return l->routes;
2800}
2801
2802GHashTable *vik_trw_layer_get_waypoints ( VikTrwLayer *l )
2803{
2804 return l->waypoints;
2805}
2806
2807GHashTable *vik_trw_layer_get_tracks_iters ( VikTrwLayer *vtl )
2808{
2809 return vtl->tracks_iters;
2810}
2811
2812GHashTable *vik_trw_layer_get_routes_iters ( VikTrwLayer *vtl )
2813{
2814 return vtl->routes_iters;
2815}
2816
2817GHashTable *vik_trw_layer_get_waypoints_iters ( VikTrwLayer *vtl )
2818{
2819 return vtl->waypoints;
2820}
2821
2822gboolean vik_trw_layer_is_empty ( VikTrwLayer *vtl )
2823{
2824 return ! ( g_hash_table_size ( vtl->tracks ) ||
2825 g_hash_table_size ( vtl->routes ) ||
2826 g_hash_table_size ( vtl->waypoints ) );
2827}
2828
2829gboolean vik_trw_layer_get_tracks_visibility ( VikTrwLayer *vtl )
2830{
2831 return vtl->tracks_visible;
2832}
2833
2834gboolean vik_trw_layer_get_routes_visibility ( VikTrwLayer *vtl )
2835{
2836 return vtl->routes_visible;
2837}
2838
2839gboolean vik_trw_layer_get_waypoints_visibility ( VikTrwLayer *vtl )
2840{
2841 return vtl->waypoints_visible;
2842}
2843
2844/*
2845 * ATM use a case sensitive find
2846 * Finds the first one
2847 */
2848static gboolean trw_layer_waypoint_find ( const gpointer id, const VikWaypoint *wp, const gchar *name )
2849{
2850 if ( wp && wp->name )
2851 if ( ! strcmp ( wp->name, name ) )
2852 return TRUE;
2853 return FALSE;
2854}
2855
2856/*
2857 * Get waypoint by name - not guaranteed to be unique
2858 * Finds the first one
2859 */
2860VikWaypoint *vik_trw_layer_get_waypoint ( VikTrwLayer *vtl, const gchar *name )
2861{
2862 return g_hash_table_find ( vtl->waypoints, (GHRFunc) trw_layer_waypoint_find, (gpointer) name );
2863}
2864
2865/*
2866 * ATM use a case sensitive find
2867 * Finds the first one
2868 */
2869static gboolean trw_layer_track_find ( const gpointer id, const VikTrack *trk, const gchar *name )
2870{
2871 if ( trk && trk->name )
2872 if ( ! strcmp ( trk->name, name ) )
2873 return TRUE;
2874 return FALSE;
2875}
2876
2877/*
2878 * Get track by name - not guaranteed to be unique
2879 * Finds the first one
2880 */
2881VikTrack *vik_trw_layer_get_track ( VikTrwLayer *vtl, const gchar *name )
2882{
2883 return g_hash_table_find ( vtl->tracks, (GHRFunc) trw_layer_track_find, (gpointer) name );
2884}
2885
2886/*
2887 * Get route by name - not guaranteed to be unique
2888 * Finds the first one
2889 */
2890VikTrack *vik_trw_layer_get_route ( VikTrwLayer *vtl, const gchar *name )
2891{
2892 return g_hash_table_find ( vtl->routes, (GHRFunc) trw_layer_track_find, (gpointer) name );
2893}
2894
2895static void trw_layer_find_maxmin_tracks ( const gpointer id, const VikTrack *trk, struct LatLon maxmin[2] )
2896{
2897 if ( trk->bbox.north > maxmin[0].lat || maxmin[0].lat == 0.0 )
2898 maxmin[0].lat = trk->bbox.north;
2899 if ( trk->bbox.south < maxmin[1].lat || maxmin[1].lat == 0.0 )
2900 maxmin[1].lat = trk->bbox.south;
2901 if ( trk->bbox.east > maxmin[0].lon || maxmin[0].lon == 0.0 )
2902 maxmin[0].lon = trk->bbox.east;
2903 if ( trk->bbox.west < maxmin[1].lon || maxmin[1].lon == 0.0 )
2904 maxmin[1].lon = trk->bbox.west;
2905}
2906
2907static void trw_layer_find_maxmin (VikTrwLayer *vtl, struct LatLon maxmin[2])
2908{
2909 // Continually reuse maxmin to find the latest maximum and minimum values
2910 // First set to waypoints bounds
2911 maxmin[0].lat = vtl->waypoints_bbox.north;
2912 maxmin[1].lat = vtl->waypoints_bbox.south;
2913 maxmin[0].lon = vtl->waypoints_bbox.east;
2914 maxmin[1].lon = vtl->waypoints_bbox.west;
2915 g_hash_table_foreach ( vtl->tracks, (GHFunc) trw_layer_find_maxmin_tracks, maxmin );
2916 g_hash_table_foreach ( vtl->routes, (GHFunc) trw_layer_find_maxmin_tracks, maxmin );
2917}
2918
2919gboolean vik_trw_layer_find_center ( VikTrwLayer *vtl, VikCoord *dest )
2920{
2921 /* 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... */
2922 struct LatLon maxmin[2] = { {0.0,0.0}, {0.0,0.0} };
2923 trw_layer_find_maxmin (vtl, maxmin);
2924 if (maxmin[0].lat == 0.0 && maxmin[0].lon == 0.0 && maxmin[1].lat == 0.0 && maxmin[1].lon == 0.0)
2925 return FALSE;
2926 else
2927 {
2928 struct LatLon average = { (maxmin[0].lat+maxmin[1].lat)/2, (maxmin[0].lon+maxmin[1].lon)/2 };
2929 vik_coord_load_from_latlon ( dest, vtl->coord_mode, &average );
2930 return TRUE;
2931 }
2932}
2933
2934static void trw_layer_centerize ( gpointer layer_and_vlp[2] )
2935{
2936 VikCoord coord;
2937 if ( vik_trw_layer_find_center ( VIK_TRW_LAYER(layer_and_vlp[0]), &coord ) )
2938 goto_coord ( layer_and_vlp[1], NULL, NULL, &coord );
2939 else
2940 a_dialog_info_msg ( VIK_GTK_WINDOW_FROM_LAYER(layer_and_vlp[0]), _("This layer has no waypoints or trackpoints.") );
2941}
2942
2943void trw_layer_zoom_to_show_latlons ( VikTrwLayer *vtl, VikViewport *vvp, struct LatLon maxmin[2] )
2944{
2945 /* First set the center [in case previously viewing from elsewhere] */
2946 /* Then loop through zoom levels until provided positions are in view */
2947 /* This method is not particularly fast - but should work well enough */
2948 struct LatLon average = { (maxmin[0].lat+maxmin[1].lat)/2, (maxmin[0].lon+maxmin[1].lon)/2 };
2949 VikCoord coord;
2950 vik_coord_load_from_latlon ( &coord, vtl->coord_mode, &average );
2951 vik_viewport_set_center_coord ( vvp, &coord );
2952
2953 /* Convert into definite 'smallest' and 'largest' positions */
2954 struct LatLon minmin;
2955 if ( maxmin[0].lat < maxmin[1].lat )
2956 minmin.lat = maxmin[0].lat;
2957 else
2958 minmin.lat = maxmin[1].lat;
2959
2960 struct LatLon maxmax;
2961 if ( maxmin[0].lon > maxmin[1].lon )
2962 maxmax.lon = maxmin[0].lon;
2963 else
2964 maxmax.lon = maxmin[1].lon;
2965
2966 /* Never zoom in too far - generally not that useful, as too close ! */
2967 /* Always recalculate the 'best' zoom level */
2968 gdouble zoom = 1.0;
2969 vik_viewport_set_zoom ( vvp, zoom );
2970
2971 gdouble min_lat, max_lat, min_lon, max_lon;
2972 /* Should only be a maximum of about 18 iterations from min to max zoom levels */
2973 while ( zoom <= VIK_VIEWPORT_MAX_ZOOM ) {
2974 vik_viewport_get_min_max_lat_lon ( vvp, &min_lat, &max_lat, &min_lon, &max_lon );
2975 /* NB I think the logic used in this test to determine if the bounds is within view
2976 fails if track goes across 180 degrees longitude.
2977 Hopefully that situation is not too common...
2978 Mind you viking doesn't really do edge locations to well anyway */
2979 if ( min_lat < minmin.lat &&
2980 max_lat > minmin.lat &&
2981 min_lon < maxmax.lon &&
2982 max_lon > maxmax.lon )
2983 /* Found within zoom level */
2984 break;
2985
2986 /* Try next */
2987 zoom = zoom * 2;
2988 vik_viewport_set_zoom ( vvp, zoom );
2989 }
2990}
2991
2992gboolean vik_trw_layer_auto_set_view ( VikTrwLayer *vtl, VikViewport *vvp )
2993{
2994 /* TODO: what if there's only one waypoint @ 0,0, it will think nothing found. */
2995 struct LatLon maxmin[2] = { {0.0,0.0}, {0.0,0.0} };
2996 trw_layer_find_maxmin (vtl, maxmin);
2997 if (maxmin[0].lat == 0.0 && maxmin[0].lon == 0.0 && maxmin[1].lat == 0.0 && maxmin[1].lon == 0.0)
2998 return FALSE;
2999 else {
3000 trw_layer_zoom_to_show_latlons ( vtl, vvp, maxmin );
3001 return TRUE;
3002 }
3003}
3004
3005static void trw_layer_auto_view ( gpointer layer_and_vlp[2] )
3006{
3007 if ( vik_trw_layer_auto_set_view ( VIK_TRW_LAYER(layer_and_vlp[0]), vik_layers_panel_get_viewport (VIK_LAYERS_PANEL(layer_and_vlp[1])) ) ) {
3008 vik_layers_panel_emit_update ( VIK_LAYERS_PANEL(layer_and_vlp[1]) );
3009 }
3010 else
3011 a_dialog_info_msg ( VIK_GTK_WINDOW_FROM_LAYER(layer_and_vlp[0]), _("This layer has no waypoints or trackpoints.") );
3012}
3013
3014static void trw_layer_export ( gpointer layer_and_vlp[2], const gchar *title, const gchar* default_name, VikTrack* trk, guint file_type )
3015{
3016 GtkWidget *file_selector;
3017 const gchar *fn;
3018 gboolean failed = FALSE;
3019 file_selector = gtk_file_chooser_dialog_new (title,
3020 NULL,
3021 GTK_FILE_CHOOSER_ACTION_SAVE,
3022 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
3023 GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
3024 NULL);
3025 gchar *cwd = g_get_current_dir();
3026 if ( cwd ) {
3027 gtk_file_chooser_set_current_folder ( GTK_FILE_CHOOSER(file_selector), cwd );
3028 g_free ( cwd );
3029 }
3030
3031 gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER(file_selector), default_name);
3032
3033 while ( gtk_dialog_run ( GTK_DIALOG(file_selector) ) == GTK_RESPONSE_ACCEPT )
3034 {
3035 fn = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER(file_selector) );
3036 if ( g_file_test ( fn, G_FILE_TEST_EXISTS ) == FALSE ||
3037 a_dialog_yes_or_no ( GTK_WINDOW(file_selector), _("The file \"%s\" exists, do you wish to overwrite it?"), a_file_basename ( fn ) ) )
3038 {
3039 gtk_widget_hide ( file_selector );
3040 vik_window_set_busy_cursor ( VIK_WINDOW(VIK_GTK_WINDOW_FROM_LAYER(layer_and_vlp[0])) );
3041 failed = ! a_file_export ( VIK_TRW_LAYER(layer_and_vlp[0]), fn, file_type, trk, TRUE );
3042 vik_window_clear_busy_cursor ( VIK_WINDOW(VIK_GTK_WINDOW_FROM_LAYER(layer_and_vlp[0])) );
3043 break;
3044 }
3045 }
3046 gtk_widget_destroy ( file_selector );
3047 if ( failed )
3048 a_dialog_error_msg ( VIK_GTK_WINDOW_FROM_LAYER(layer_and_vlp[0]), _("The filename you requested could not be opened for writing.") );
3049}
3050
3051static void trw_layer_export_gpspoint ( gpointer layer_and_vlp[2] )
3052{
3053 trw_layer_export ( layer_and_vlp, _("Export Layer"), vik_layer_get_name(VIK_LAYER(layer_and_vlp[0])), NULL, FILE_TYPE_GPSPOINT );
3054}
3055
3056static void trw_layer_export_gpsmapper ( gpointer layer_and_vlp[2] )
3057{
3058 trw_layer_export ( layer_and_vlp, _("Export Layer"), vik_layer_get_name(VIK_LAYER(layer_and_vlp[0])), NULL, FILE_TYPE_GPSMAPPER );
3059}
3060
3061static void trw_layer_export_gpx ( gpointer layer_and_vlp[2] )
3062{
3063 /* Auto append '.gpx' to track name (providing it's not already there) for the default filename */
3064 gchar *auto_save_name = g_strdup ( vik_layer_get_name(VIK_LAYER(layer_and_vlp[0])) );
3065 if ( ! check_file_ext ( auto_save_name, ".gpx" ) )
3066 auto_save_name = g_strconcat ( auto_save_name, ".gpx", NULL );
3067
3068 trw_layer_export ( layer_and_vlp, _("Export Layer"), auto_save_name, NULL, FILE_TYPE_GPX );
3069
3070 g_free ( auto_save_name );
3071}
3072
3073static void trw_layer_export_kml ( gpointer layer_and_vlp[2] )
3074{
3075 /* Auto append '.kml' to the name (providing it's not already there) for the default filename */
3076 gchar *auto_save_name = g_strdup ( vik_layer_get_name(VIK_LAYER(layer_and_vlp[0])) );
3077 if ( ! check_file_ext ( auto_save_name, ".kml" ) )
3078 auto_save_name = g_strconcat ( auto_save_name, ".kml", NULL );
3079
3080 trw_layer_export ( layer_and_vlp, _("Export Layer"), auto_save_name, NULL, FILE_TYPE_KML );
3081
3082 g_free ( auto_save_name );
3083}
3084
3085/**
3086 * Convert the given TRW layer into a temporary GPX file and open it with the specified program
3087 *
3088 */
3089static void trw_layer_export_external_gpx ( gpointer layer_and_vlp[2], const gchar* external_program )
3090{
3091 gchar *name_used = NULL;
3092 int fd;
3093
3094 if ((fd = g_file_open_tmp("tmp-viking.XXXXXX.gpx", &name_used, NULL)) >= 0) {
3095 vik_window_set_busy_cursor ( VIK_WINDOW(VIK_GTK_WINDOW_FROM_LAYER(layer_and_vlp[0])) );
3096 gboolean failed = ! a_file_export ( VIK_TRW_LAYER(layer_and_vlp[0]), name_used, FILE_TYPE_GPX, NULL, TRUE);
3097 vik_window_clear_busy_cursor ( VIK_WINDOW(VIK_GTK_WINDOW_FROM_LAYER(layer_and_vlp[0])) );
3098 if (failed) {
3099 a_dialog_error_msg (VIK_GTK_WINDOW_FROM_LAYER(layer_and_vlp[0]), _("Could not create temporary file for export.") );
3100 }
3101 else {
3102 GError *err = NULL;
3103 gchar *quoted_file = g_shell_quote ( name_used );
3104 gchar *cmd = g_strdup_printf ( "%s %s", external_program, quoted_file );
3105 g_free ( quoted_file );
3106 if ( ! g_spawn_command_line_async ( cmd, &err ) )
3107 {
3108 a_dialog_error_msg_extra ( VIK_GTK_WINDOW_FROM_LAYER( layer_and_vlp[0]), _("Could not launch %s."), external_program );
3109 g_error_free ( err );
3110 }
3111 g_free ( cmd );
3112 }
3113 // Note ATM the 'temporary' file is not deleted, as loading via another program is not instantaneous
3114 //g_remove ( name_used );
3115 // Perhaps should be deleted when the program ends?
3116 // For now leave it to the user to delete it / use system temp cleanup methods.
3117 g_free ( name_used );
3118 }
3119}
3120
3121static void trw_layer_export_external_gpx_1 ( gpointer layer_and_vlp[2] )
3122{
3123 trw_layer_export_external_gpx ( layer_and_vlp, a_vik_get_external_gpx_program_1() );
3124}
3125
3126static void trw_layer_export_external_gpx_2 ( gpointer layer_and_vlp[2] )
3127{
3128 trw_layer_export_external_gpx ( layer_and_vlp, a_vik_get_external_gpx_program_2() );
3129}
3130
3131static void trw_layer_export_gpx_track ( gpointer pass_along[6] )
3132{
3133 gpointer layer_and_vlp[2];
3134 layer_and_vlp[0] = pass_along[0];
3135 layer_and_vlp[1] = pass_along[1];
3136
3137 VikTrwLayer *vtl = VIK_TRW_LAYER(pass_along[0]);
3138 VikTrack *trk;
3139 if ( GPOINTER_TO_INT (pass_along[2]) == VIK_TRW_LAYER_SUBLAYER_ROUTE )
3140 trk = (VikTrack *) g_hash_table_lookup ( vtl->routes, pass_along[3] );
3141 else
3142 trk = (VikTrack *) g_hash_table_lookup ( vtl->tracks, pass_along[3] );
3143
3144 if ( !trk || !trk->name )
3145 return;
3146
3147 /* Auto append '.gpx' to track name (providing it's not already there) for the default filename */
3148 gchar *auto_save_name = g_strdup ( trk->name );
3149 if ( ! check_file_ext ( auto_save_name, ".gpx" ) )
3150 auto_save_name = g_strconcat ( auto_save_name, ".gpx", NULL );
3151
3152 gchar *label = NULL;
3153 if ( GPOINTER_TO_INT (pass_along[2]) == VIK_TRW_LAYER_SUBLAYER_ROUTE )
3154 label = _("Export Route as GPX");
3155 else
3156 label = _("Export Track as GPX");
3157 trw_layer_export ( layer_and_vlp, label, auto_save_name, trk, FILE_TYPE_GPX );
3158
3159 g_free ( auto_save_name );
3160}
3161
3162gboolean trw_layer_waypoint_find_uuid ( const gpointer id, const VikWaypoint *wp, gpointer udata )
3163{
3164 wpu_udata *user_data = udata;
3165 if ( wp == user_data->wp ) {
3166 user_data->uuid = id;
3167 return TRUE;
3168 }
3169 return FALSE;
3170}
3171
3172static void trw_layer_goto_wp ( gpointer layer_and_vlp[2] )
3173{
3174 GtkWidget *dia = gtk_dialog_new_with_buttons (_("Find"),
3175 VIK_GTK_WINDOW_FROM_LAYER(layer_and_vlp[0]),
3176 GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
3177 GTK_STOCK_CANCEL,
3178 GTK_RESPONSE_REJECT,
3179 GTK_STOCK_OK,
3180 GTK_RESPONSE_ACCEPT,
3181 NULL);
3182
3183 GtkWidget *label, *entry;
3184 label = gtk_label_new(_("Waypoint Name:"));
3185 entry = gtk_entry_new();
3186
3187 gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dia))), label, FALSE, FALSE, 0);
3188 gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dia))), entry, FALSE, FALSE, 0);
3189 gtk_widget_show_all ( label );
3190 gtk_widget_show_all ( entry );
3191
3192 gtk_dialog_set_default_response ( GTK_DIALOG(dia), GTK_RESPONSE_ACCEPT );
3193
3194 while ( gtk_dialog_run ( GTK_DIALOG(dia) ) == GTK_RESPONSE_ACCEPT )
3195 {
3196 gchar *name = g_strdup(gtk_entry_get_text(GTK_ENTRY(entry)));
3197 // Find *first* wp with the given name
3198 VikWaypoint *wp = vik_trw_layer_get_waypoint ( VIK_TRW_LAYER(layer_and_vlp[0]), name );
3199
3200 if ( !wp )
3201 a_dialog_error_msg ( VIK_GTK_WINDOW_FROM_LAYER(layer_and_vlp[0]), _("Waypoint not found in this layer.") );
3202 else
3203 {
3204 vik_viewport_set_center_coord ( vik_layers_panel_get_viewport(VIK_LAYERS_PANEL(layer_and_vlp[1])), &(wp->coord) );
3205 vik_layers_panel_emit_update ( VIK_LAYERS_PANEL(layer_and_vlp[1]) );
3206
3207 // Find and select on the side panel
3208 wpu_udata udata;
3209 udata.wp = wp;
3210 udata.uuid = NULL;
3211
3212 // Hmmm, want key of it
3213 gpointer *wpf = g_hash_table_find ( VIK_TRW_LAYER(layer_and_vlp[0])->waypoints, (GHRFunc) trw_layer_waypoint_find_uuid, (gpointer) &udata );
3214
3215 if ( wpf && udata.uuid ) {
3216 GtkTreeIter *it = g_hash_table_lookup ( VIK_TRW_LAYER(layer_and_vlp[0])->waypoints_iters, udata.uuid );
3217 vik_treeview_select_iter ( VIK_LAYER(layer_and_vlp[0])->vt, it, TRUE );
3218 }
3219
3220 break;
3221 }
3222
3223 g_free ( name );
3224
3225 }
3226 gtk_widget_destroy ( dia );
3227}
3228
3229gboolean vik_trw_layer_new_waypoint ( VikTrwLayer *vtl, GtkWindow *w, const VikCoord *def_coord )
3230{
3231 gchar *default_name = highest_wp_number_get(vtl);
3232 VikWaypoint *wp = vik_waypoint_new();
3233 gchar *returned_name;
3234 gboolean updated;
3235 wp->coord = *def_coord;
3236
3237 // Attempt to auto set height if DEM data is available
3238 vik_waypoint_apply_dem_data ( wp, TRUE );
3239
3240 returned_name = a_dialog_waypoint ( w, default_name, vtl, wp, vtl->coord_mode, TRUE, &updated );
3241
3242 if ( returned_name )
3243 {
3244 wp->visible = TRUE;
3245 vik_trw_layer_add_waypoint ( vtl, returned_name, wp );
3246 g_free (default_name);
3247 g_free (returned_name);
3248 return TRUE;
3249 }
3250 g_free (default_name);
3251 vik_waypoint_free(wp);
3252 return FALSE;
3253}
3254
3255static void trw_layer_new_wikipedia_wp_viewport ( gpointer lav[2] )
3256{
3257 struct LatLon maxmin[2] = { {0.0,0.0}, {0.0,0.0} };
3258 VikTrwLayer *vtl = VIK_TRW_LAYER(lav[0]);
3259 VikLayersPanel *vlp = VIK_LAYERS_PANEL(lav[1]);
3260 VikWindow *vw = (VikWindow *)(VIK_GTK_WINDOW_FROM_LAYER(vtl));
3261 VikViewport *vvp = vik_window_viewport(vw);
3262
3263 // Note the order is max part first then min part - thus reverse order of use in min_max function:
3264 vik_viewport_get_min_max_lat_lon ( vvp, &maxmin[1].lat, &maxmin[0].lat, &maxmin[1].lon, &maxmin[0].lon );
3265 a_geonames_wikipedia_box((VikWindow *)(VIK_GTK_WINDOW_FROM_LAYER(vtl)), vtl, maxmin);
3266 trw_layer_calculate_bounds_waypoints ( vtl );
3267 vik_layers_panel_emit_update ( vlp );
3268}
3269
3270static void trw_layer_new_wikipedia_wp_layer ( gpointer lav[2] )
3271{
3272 VikTrwLayer *vtl = VIK_TRW_LAYER(lav[0]);
3273 VikLayersPanel *vlp = VIK_LAYERS_PANEL(lav[1]);
3274 struct LatLon maxmin[2] = { {0.0,0.0}, {0.0,0.0} };
3275
3276 trw_layer_find_maxmin (vtl, maxmin);
3277 a_geonames_wikipedia_box((VikWindow *)(VIK_GTK_WINDOW_FROM_LAYER(vtl)), vtl, maxmin);
3278 trw_layer_calculate_bounds_waypoints ( vtl );
3279 vik_layers_panel_emit_update ( vlp );
3280}
3281
3282#ifdef VIK_CONFIG_GEOTAG
3283static void trw_layer_geotagging_waypoint_mtime_keep ( gpointer pass_along[6] )
3284{
3285 VikWaypoint *wp = g_hash_table_lookup ( VIK_TRW_LAYER(pass_along[0])->waypoints, pass_along[3] );
3286 if ( wp )
3287 // Update directly - not changing the mtime
3288 a_geotag_write_exif_gps ( wp->image, wp->coord, wp->altitude, TRUE );
3289}
3290
3291static void trw_layer_geotagging_waypoint_mtime_update ( gpointer pass_along[6] )
3292{
3293 VikWaypoint *wp = g_hash_table_lookup ( VIK_TRW_LAYER(pass_along[0])->waypoints, pass_along[3] );
3294 if ( wp )
3295 // Update directly
3296 a_geotag_write_exif_gps ( wp->image, wp->coord, wp->altitude, FALSE );
3297}
3298
3299/*
3300 * Use code in separate file for this feature as reasonably complex
3301 */
3302static void trw_layer_geotagging_track ( gpointer pass_along[6] )
3303{
3304 VikTrwLayer *vtl = VIK_TRW_LAYER(pass_along[0]);
3305 VikTrack *track = g_hash_table_lookup ( VIK_TRW_LAYER(pass_along[0])->tracks, pass_along[3] );
3306 // Unset so can be reverified later if necessary
3307 vtl->has_verified_thumbnails = FALSE;
3308
3309 trw_layer_geotag_dialog ( VIK_GTK_WINDOW_FROM_LAYER(vtl),
3310 vtl,
3311 NULL,
3312 track );
3313}
3314
3315static void trw_layer_geotagging_waypoint ( gpointer pass_along[6] )
3316{
3317 VikTrwLayer *vtl = VIK_TRW_LAYER(pass_along[0]);
3318 VikWaypoint *wpt = g_hash_table_lookup ( VIK_TRW_LAYER(pass_along[0])->waypoints, pass_along[3] );
3319
3320 trw_layer_geotag_dialog ( VIK_GTK_WINDOW_FROM_LAYER(vtl),
3321 vtl,
3322 wpt,
3323 NULL );
3324}
3325
3326static void trw_layer_geotagging ( gpointer lav[2] )
3327{
3328 VikTrwLayer *vtl = VIK_TRW_LAYER(lav[0]);
3329 // Unset so can be reverified later if necessary
3330 vtl->has_verified_thumbnails = FALSE;
3331
3332 trw_layer_geotag_dialog ( VIK_GTK_WINDOW_FROM_LAYER(vtl),
3333 vtl,
3334 NULL,
3335 NULL );
3336}
3337#endif
3338
3339// 'Acquires' - Same as in File Menu -> Acquire - applies into the selected TRW Layer //
3340
3341/*
3342 * Acquire into this TRW Layer straight from GPS Device
3343 */
3344static void trw_layer_acquire_gps_cb ( gpointer lav[2] )
3345{
3346 VikTrwLayer *vtl = VIK_TRW_LAYER(lav[0]);
3347 VikLayersPanel *vlp = VIK_LAYERS_PANEL(lav[1]);
3348 VikWindow *vw = (VikWindow *)(VIK_GTK_WINDOW_FROM_LAYER(vtl));
3349 VikViewport *vvp = vik_window_viewport(vw);
3350
3351 vik_datasource_gps_interface.mode = VIK_DATASOURCE_ADDTOLAYER;
3352 a_acquire ( vw, vlp, vvp, &vik_datasource_gps_interface, NULL, NULL );
3353}
3354
3355/*
3356 * Acquire into this TRW Layer from Directions
3357 */
3358static void trw_layer_acquire_routing_cb ( gpointer lav[2] )
3359{
3360 VikTrwLayer *vtl = VIK_TRW_LAYER(lav[0]);
3361 VikLayersPanel *vlp = VIK_LAYERS_PANEL(lav[1]);
3362 VikWindow *vw = (VikWindow *)(VIK_GTK_WINDOW_FROM_LAYER(vtl));
3363 VikViewport *vvp = vik_window_viewport(vw);
3364
3365 a_acquire ( vw, vlp, vvp, &vik_datasource_routing_interface, NULL, NULL );
3366}
3367
3368/*
3369 * Acquire into this TRW Layer from an entered URL
3370 */
3371static void trw_layer_acquire_url_cb ( gpointer lav[2] )
3372{
3373 VikTrwLayer *vtl = VIK_TRW_LAYER(lav[0]);
3374 VikLayersPanel *vlp = VIK_LAYERS_PANEL(lav[1]);
3375 VikWindow *vw = (VikWindow *)(VIK_GTK_WINDOW_FROM_LAYER(vtl));
3376 VikViewport *vvp = vik_window_viewport(vw);
3377
3378 vik_datasource_url_interface.mode = VIK_DATASOURCE_ADDTOLAYER;
3379 a_acquire ( vw, vlp, vvp, &vik_datasource_url_interface, NULL, NULL );
3380}
3381
3382#ifdef VIK_CONFIG_OPENSTREETMAP
3383/*
3384 * Acquire into this TRW Layer from OSM
3385 */
3386static void trw_layer_acquire_osm_cb ( gpointer lav[2] )
3387{
3388 VikTrwLayer *vtl = VIK_TRW_LAYER(lav[0]);
3389 VikLayersPanel *vlp = VIK_LAYERS_PANEL(lav[1]);
3390 VikWindow *vw = (VikWindow *)(VIK_GTK_WINDOW_FROM_LAYER(vtl));
3391 VikViewport *vvp = vik_window_viewport(vw);
3392
3393 a_acquire ( vw, vlp, vvp, &vik_datasource_osm_interface, NULL, NULL );
3394}
3395
3396/**
3397 * Acquire into this TRW Layer from OSM for 'My' Traces
3398 */
3399static void trw_layer_acquire_osm_my_traces_cb ( gpointer lav[2] )
3400{
3401 VikTrwLayer *vtl = VIK_TRW_LAYER(lav[0]);
3402 VikLayersPanel *vlp = VIK_LAYERS_PANEL(lav[1]);
3403 VikWindow *vw = (VikWindow *)(VIK_GTK_WINDOW_FROM_LAYER(vtl));
3404 VikViewport *vvp = vik_window_viewport(vw);
3405
3406 a_acquire ( vw, vlp, vvp, &vik_datasource_osm_my_traces_interface, NULL, NULL );
3407}
3408#endif
3409
3410#ifdef VIK_CONFIG_GEOCACHES
3411/*
3412 * Acquire into this TRW Layer from Geocaching.com
3413 */
3414static void trw_layer_acquire_geocache_cb ( gpointer lav[2] )
3415{
3416 VikTrwLayer *vtl = VIK_TRW_LAYER(lav[0]);
3417 VikLayersPanel *vlp = VIK_LAYERS_PANEL(lav[1]);
3418 VikWindow *vw = (VikWindow *)(VIK_GTK_WINDOW_FROM_LAYER(vtl));
3419 VikViewport *vvp = vik_window_viewport(vw);
3420
3421 a_acquire ( vw, vlp, vvp, &vik_datasource_gc_interface, NULL, NULL );
3422}
3423#endif
3424
3425#ifdef VIK_CONFIG_GEOTAG
3426/*
3427 * Acquire into this TRW Layer from images
3428 */
3429static void trw_layer_acquire_geotagged_cb ( gpointer lav[2] )
3430{
3431 VikTrwLayer *vtl = VIK_TRW_LAYER(lav[0]);
3432 VikLayersPanel *vlp = VIK_LAYERS_PANEL(lav[1]);
3433 VikWindow *vw = (VikWindow *)(VIK_GTK_WINDOW_FROM_LAYER(vtl));
3434 VikViewport *vvp = vik_window_viewport(vw);
3435
3436 vik_datasource_geotag_interface.mode = VIK_DATASOURCE_ADDTOLAYER;
3437 a_acquire ( vw, vlp, vvp, &vik_datasource_geotag_interface, NULL, NULL );
3438
3439 // Reverify thumbnails as they may have changed
3440 vtl->has_verified_thumbnails = FALSE;
3441 trw_layer_verify_thumbnails ( vtl, NULL );
3442}
3443#endif
3444
3445static void trw_layer_gps_upload ( gpointer lav[2] )
3446{
3447 gpointer pass_along[6];
3448 pass_along[0] = lav[0];
3449 pass_along[1] = lav[1];
3450 pass_along[2] = NULL; // No track - operate on the layer
3451 pass_along[3] = NULL;
3452 pass_along[4] = NULL;
3453 pass_along[5] = NULL;
3454
3455 trw_layer_gps_upload_any ( pass_along );
3456}
3457
3458/**
3459 * If pass_along[3] is defined that this will upload just that track
3460 */
3461static void trw_layer_gps_upload_any ( gpointer pass_along[6] )
3462{
3463 VikTrwLayer *vtl = VIK_TRW_LAYER(pass_along[0]);
3464 VikLayersPanel *vlp = VIK_LAYERS_PANEL(pass_along[1]);
3465
3466 // May not actually get a track here as pass_along[2&3] can be null
3467 VikTrack *track = NULL;
3468 vik_gps_xfer_type xfer_type = TRK; // VIK_TRW_LAYER_SUBLAYER_TRACKS = 0 so hard to test different from NULL!
3469 gboolean xfer_all = FALSE;
3470
3471 if ( pass_along[2] ) {
3472 xfer_all = FALSE;
3473 if ( GPOINTER_TO_INT (pass_along[2]) == VIK_TRW_LAYER_SUBLAYER_ROUTE ) {
3474 track = (VikTrack *) g_hash_table_lookup ( vtl->routes, pass_along[3] );
3475 xfer_type = RTE;
3476 }
3477 else if ( GPOINTER_TO_INT (pass_along[2]) == VIK_TRW_LAYER_SUBLAYER_TRACK ) {
3478 track = (VikTrack *) g_hash_table_lookup ( vtl->tracks, pass_along[3] );
3479 xfer_type = TRK;
3480 }
3481 else if ( GPOINTER_TO_INT (pass_along[2]) == VIK_TRW_LAYER_SUBLAYER_WAYPOINTS ) {
3482 xfer_type = WPT;
3483 }
3484 else if ( GPOINTER_TO_INT (pass_along[2]) == VIK_TRW_LAYER_SUBLAYER_ROUTES ) {
3485 xfer_type = RTE;
3486 }
3487 }
3488 else if ( !pass_along[4] )
3489 xfer_all = TRUE; // i.e. whole layer
3490
3491 if (track && !track->visible) {
3492 a_dialog_error_msg ( VIK_GTK_WINDOW_FROM_LAYER(vtl), _("Can not upload invisible track.") );
3493 return;
3494 }
3495
3496 GtkWidget *dialog = gtk_dialog_new_with_buttons ( _("GPS Upload"),
3497 VIK_GTK_WINDOW_FROM_LAYER(pass_along[0]),
3498 GTK_DIALOG_DESTROY_WITH_PARENT,
3499 GTK_STOCK_OK,
3500 GTK_RESPONSE_ACCEPT,
3501 GTK_STOCK_CANCEL,
3502 GTK_RESPONSE_REJECT,
3503 NULL );
3504
3505 gtk_dialog_set_default_response ( GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT );
3506 GtkWidget *response_w = NULL;
3507#if GTK_CHECK_VERSION (2, 20, 0)
3508 response_w = gtk_dialog_get_widget_for_response ( GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT );
3509#endif
3510
3511 if ( response_w )
3512 gtk_widget_grab_focus ( response_w );
3513
3514 gpointer dgs = datasource_gps_setup ( dialog, xfer_type, xfer_all );
3515
3516 if ( gtk_dialog_run ( GTK_DIALOG(dialog) ) != GTK_RESPONSE_ACCEPT ) {
3517 datasource_gps_clean_up ( dgs );
3518 gtk_widget_destroy ( dialog );
3519 return;
3520 }
3521
3522 // Get info from reused datasource dialog widgets
3523 gchar* protocol = datasource_gps_get_protocol ( dgs );
3524 gchar* port = datasource_gps_get_descriptor ( dgs );
3525 // NB don't free the above strings as they're references to values held elsewhere
3526 gboolean do_tracks = datasource_gps_get_do_tracks ( dgs );
3527 gboolean do_routes = datasource_gps_get_do_routes ( dgs );
3528 gboolean do_waypoints = datasource_gps_get_do_waypoints ( dgs );
3529 gboolean turn_off = datasource_gps_get_off ( dgs );
3530
3531 gtk_widget_destroy ( dialog );
3532
3533 // When called from the viewport - work the corresponding layerspanel:
3534 if ( !vlp ) {
3535 vlp = vik_window_layers_panel ( VIK_WINDOW(VIK_GTK_WINDOW_FROM_LAYER(vtl)) );
3536 }
3537
3538 // Apply settings to transfer to the GPS device
3539 vik_gps_comm ( vtl,
3540 track,
3541 GPS_UP,
3542 protocol,
3543 port,
3544 FALSE,
3545 vik_layers_panel_get_viewport (vlp),
3546 vlp,
3547 do_tracks,
3548 do_routes,
3549 do_waypoints,
3550 turn_off );
3551}
3552
3553/*
3554 * Acquire into this TRW Layer from any GPS Babel supported file
3555 */
3556static void trw_layer_acquire_file_cb ( gpointer lav[2] )
3557{
3558 VikTrwLayer *vtl = VIK_TRW_LAYER(lav[0]);
3559 VikLayersPanel *vlp = VIK_LAYERS_PANEL(lav[1]);
3560 VikWindow *vw = (VikWindow *)(VIK_GTK_WINDOW_FROM_LAYER(vtl));
3561 VikViewport *vvp = vik_window_viewport(vw);
3562
3563 a_acquire ( vw, vlp, vvp, &vik_datasource_file_interface, NULL, NULL );
3564}
3565
3566static void trw_layer_new_wp ( gpointer lav[2] )
3567{
3568 VikTrwLayer *vtl = VIK_TRW_LAYER(lav[0]);
3569 VikLayersPanel *vlp = VIK_LAYERS_PANEL(lav[1]);
3570 /* TODO longone: okay, if layer above (aggregate) is invisible but vtl->visible is true, this redraws for no reason.
3571 instead return true if you want to update. */
3572 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 ) {
3573 trw_layer_calculate_bounds_waypoints ( vtl );
3574 vik_layers_panel_emit_update ( vlp );
3575 }
3576}
3577
3578static void new_track_create_common ( VikTrwLayer *vtl, gchar *name )
3579{
3580 vtl->current_track = vik_track_new();
3581 vik_track_set_defaults ( vtl->current_track );
3582 vtl->current_track->visible = TRUE;
3583 if ( vtl->drawmode == DRAWMODE_ALL_SAME_COLOR )
3584 // Create track with the preferred colour from the layer properties
3585 vtl->current_track->color = vtl->track_color;
3586 else
3587 gdk_color_parse ( "#000000", &(vtl->current_track->color) );
3588 vtl->current_track->has_color = TRUE;
3589 vik_trw_layer_add_track ( vtl, name, vtl->current_track );
3590}
3591
3592static void trw_layer_new_track ( gpointer lav[2] )
3593{
3594 VikTrwLayer *vtl = VIK_TRW_LAYER(lav[0]);
3595
3596 if ( ! vtl->current_track ) {
3597 gchar *name = trw_layer_new_unique_sublayer_name ( vtl, VIK_TRW_LAYER_SUBLAYER_TRACK, _("Track")) ;
3598 new_track_create_common ( vtl, name );
3599 g_free ( name );
3600
3601 vik_window_enable_layer_tool ( VIK_WINDOW(VIK_GTK_WINDOW_FROM_LAYER(vtl)), VIK_LAYER_TRW, TOOL_CREATE_TRACK );
3602 }
3603}
3604
3605static void new_route_create_common ( VikTrwLayer *vtl, gchar *name )
3606{
3607 vtl->current_track = vik_track_new();
3608 vik_track_set_defaults ( vtl->current_track );
3609 vtl->current_track->visible = TRUE;
3610 vtl->current_track->is_route = TRUE;
3611 // By default make all routes red
3612 vtl->current_track->has_color = TRUE;
3613 gdk_color_parse ( "red", &vtl->current_track->color );
3614 vik_trw_layer_add_route ( vtl, name, vtl->current_track );
3615}
3616
3617static void trw_layer_new_route ( gpointer lav[2] )
3618{
3619 VikTrwLayer *vtl = VIK_TRW_LAYER(lav[0]);
3620
3621 if ( ! vtl->current_track ) {
3622 gchar *name = trw_layer_new_unique_sublayer_name ( vtl, VIK_TRW_LAYER_SUBLAYER_ROUTE, _("Route")) ;
3623 new_route_create_common ( vtl, name );
3624 g_free ( name );
3625 vik_window_enable_layer_tool ( VIK_WINDOW(VIK_GTK_WINDOW_FROM_LAYER(vtl)), VIK_LAYER_TRW, TOOL_CREATE_ROUTE );
3626 }
3627}
3628
3629static void trw_layer_auto_routes_view ( gpointer lav[2] )
3630{
3631 VikTrwLayer *vtl = VIK_TRW_LAYER(lav[0]);
3632 VikLayersPanel *vlp = VIK_LAYERS_PANEL(lav[1]);
3633
3634 if ( g_hash_table_size (vtl->routes) > 0 ) {
3635 struct LatLon maxmin[2] = { {0,0}, {0,0} };
3636 g_hash_table_foreach ( vtl->routes, (GHFunc) trw_layer_find_maxmin_tracks, maxmin );
3637 trw_layer_zoom_to_show_latlons ( vtl, vik_layers_panel_get_viewport (vlp), maxmin );
3638 vik_layers_panel_emit_update ( vlp );
3639 }
3640}
3641
3642
3643static void trw_layer_finish_track ( gpointer lav[2] )
3644{
3645 VikTrwLayer *vtl = VIK_TRW_LAYER(lav[0]);
3646 vtl->current_track = NULL;
3647 vik_layer_emit_update ( VIK_LAYER(vtl) );
3648}
3649
3650static void trw_layer_auto_tracks_view ( gpointer lav[2] )
3651{
3652 VikTrwLayer *vtl = VIK_TRW_LAYER(lav[0]);
3653 VikLayersPanel *vlp = VIK_LAYERS_PANEL(lav[1]);
3654
3655 if ( g_hash_table_size (vtl->tracks) > 0 ) {
3656 struct LatLon maxmin[2] = { {0,0}, {0,0} };
3657 g_hash_table_foreach ( vtl->tracks, (GHFunc) trw_layer_find_maxmin_tracks, maxmin );
3658 trw_layer_zoom_to_show_latlons ( vtl, vik_layers_panel_get_viewport (vlp), maxmin );
3659 vik_layers_panel_emit_update ( vlp );
3660 }
3661}
3662
3663static void trw_layer_single_waypoint_jump ( const gpointer id, const VikWaypoint *wp, gpointer vvp )
3664{
3665 /* NB do not care if wp is visible or not */
3666 vik_viewport_set_center_coord ( VIK_VIEWPORT(vvp), &(wp->coord) );
3667}
3668
3669static void trw_layer_auto_waypoints_view ( gpointer lav[2] )
3670{
3671 VikTrwLayer *vtl = VIK_TRW_LAYER(lav[0]);
3672 VikLayersPanel *vlp = VIK_LAYERS_PANEL(lav[1]);
3673
3674 /* Only 1 waypoint - jump straight to it */
3675 if ( g_hash_table_size (vtl->waypoints) == 1 ) {
3676 VikViewport *vvp = vik_layers_panel_get_viewport (vlp);
3677 g_hash_table_foreach ( vtl->waypoints, (GHFunc) trw_layer_single_waypoint_jump, (gpointer) vvp );
3678 }
3679 /* If at least 2 waypoints - find center and then zoom to fit */
3680 else if ( g_hash_table_size (vtl->waypoints) > 1 )
3681 {
3682 struct LatLon maxmin[2] = { {0,0}, {0,0} };
3683 maxmin[0].lat = vtl->waypoints_bbox.north;
3684 maxmin[1].lat = vtl->waypoints_bbox.south;
3685 maxmin[0].lon = vtl->waypoints_bbox.east;
3686 maxmin[1].lon = vtl->waypoints_bbox.west;
3687 trw_layer_zoom_to_show_latlons ( vtl, vik_layers_panel_get_viewport (vlp), maxmin );
3688 }
3689
3690 vik_layers_panel_emit_update ( vlp );
3691}
3692
3693static void trw_layer_add_menu_items ( VikTrwLayer *vtl, GtkMenu *menu, gpointer vlp )
3694{
3695 static gpointer pass_along[2];
3696 GtkWidget *item;
3697 GtkWidget *export_submenu;
3698 pass_along[0] = vtl;
3699 pass_along[1] = vlp;
3700
3701 item = gtk_menu_item_new();
3702 gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
3703 gtk_widget_show ( item );
3704
3705 if ( vtl->current_track ) {
3706 if ( vtl->current_track->is_route )
3707 item = gtk_menu_item_new_with_mnemonic ( _("_Finish Route") );
3708 else
3709 item = gtk_menu_item_new_with_mnemonic ( _("_Finish Track") );
3710 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_finish_track), pass_along );
3711 gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
3712 gtk_widget_show ( item );
3713
3714 // Add separator
3715 item = gtk_menu_item_new ();
3716 gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
3717 gtk_widget_show ( item );
3718 }
3719
3720 /* Now with icons */
3721 item = gtk_image_menu_item_new_with_mnemonic ( _("_View Layer") );
3722 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_ZOOM_FIT, GTK_ICON_SIZE_MENU) );
3723 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_auto_view), pass_along );
3724 gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
3725 gtk_widget_show ( item );
3726
3727 GtkWidget *view_submenu = gtk_menu_new();
3728 item = gtk_image_menu_item_new_with_mnemonic ( _("V_iew") );
3729 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_FIND, GTK_ICON_SIZE_MENU) );
3730 gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
3731 gtk_widget_show ( item );
3732 gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), view_submenu );
3733
3734 item = gtk_menu_item_new_with_mnemonic ( _("View All _Tracks") );
3735 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_auto_tracks_view), pass_along );
3736 gtk_menu_shell_append (GTK_MENU_SHELL (view_submenu), item);
3737 gtk_widget_show ( item );
3738
3739 item = gtk_menu_item_new_with_mnemonic ( _("View All _Routes") );
3740 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_auto_routes_view), pass_along );
3741 gtk_menu_shell_append (GTK_MENU_SHELL (view_submenu), item);
3742 gtk_widget_show ( item );
3743
3744 item = gtk_menu_item_new_with_mnemonic ( _("View All _Waypoints") );
3745 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_auto_waypoints_view), pass_along );
3746 gtk_menu_shell_append (GTK_MENU_SHELL (view_submenu), item);
3747 gtk_widget_show ( item );
3748
3749 item = gtk_image_menu_item_new_with_mnemonic ( _("_Goto Center of Layer") );
3750 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_JUMP_TO, GTK_ICON_SIZE_MENU) );
3751 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_centerize), pass_along );
3752 gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
3753 gtk_widget_show ( item );
3754
3755 item = gtk_menu_item_new_with_mnemonic ( _("Goto _Waypoint...") );
3756 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_goto_wp), pass_along );
3757 gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
3758 gtk_widget_show ( item );
3759
3760 export_submenu = gtk_menu_new ();
3761 item = gtk_image_menu_item_new_with_mnemonic ( _("_Export Layer") );
3762 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_HARDDISK, GTK_ICON_SIZE_MENU) );
3763 gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
3764 gtk_widget_show ( item );
3765 gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), export_submenu );
3766
3767 item = gtk_menu_item_new_with_mnemonic ( _("Export as GPS_Point...") );
3768 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_export_gpspoint), pass_along );
3769 gtk_menu_shell_append (GTK_MENU_SHELL (export_submenu), item);
3770 gtk_widget_show ( item );
3771
3772 item = gtk_menu_item_new_with_mnemonic ( _("Export as GPS_Mapper...") );
3773 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_export_gpsmapper), pass_along );
3774 gtk_menu_shell_append (GTK_MENU_SHELL (export_submenu), item);
3775 gtk_widget_show ( item );
3776
3777 item = gtk_menu_item_new_with_mnemonic ( _("Export as _GPX...") );
3778 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_export_gpx), pass_along );
3779 gtk_menu_shell_append (GTK_MENU_SHELL (export_submenu), item);
3780 gtk_widget_show ( item );
3781
3782 item = gtk_menu_item_new_with_mnemonic ( _("Export as _KML...") );
3783 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_export_kml), pass_along );
3784 gtk_menu_shell_append (GTK_MENU_SHELL (export_submenu), item);
3785 gtk_widget_show ( item );
3786
3787 gchar* external1 = g_strconcat ( _("Open with External Program_1: "), a_vik_get_external_gpx_program_1(), NULL );
3788 item = gtk_menu_item_new_with_mnemonic ( external1 );
3789 g_free ( external1 );
3790 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_export_external_gpx_1), pass_along );
3791 gtk_menu_shell_append (GTK_MENU_SHELL (export_submenu), item);
3792 gtk_widget_show ( item );
3793
3794 gchar* external2 = g_strconcat ( _("Open with External Program_2: "), a_vik_get_external_gpx_program_2(), NULL );
3795 item = gtk_menu_item_new_with_mnemonic ( external2 );
3796 g_free ( external2 );
3797 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_export_external_gpx_2), pass_along );
3798 gtk_menu_shell_append (GTK_MENU_SHELL (export_submenu), item);
3799 gtk_widget_show ( item );
3800
3801 GtkWidget *new_submenu = gtk_menu_new();
3802 item = gtk_image_menu_item_new_with_mnemonic ( _("_New") );
3803 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_NEW, GTK_ICON_SIZE_MENU) );
3804 gtk_menu_shell_append(GTK_MENU_SHELL (menu), item);
3805 gtk_widget_show(item);
3806 gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), new_submenu);
3807
3808 item = gtk_image_menu_item_new_with_mnemonic ( _("New _Waypoint...") );
3809 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_NEW, GTK_ICON_SIZE_MENU) );
3810 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_new_wp), pass_along );
3811 gtk_menu_shell_append (GTK_MENU_SHELL (new_submenu), item);
3812 gtk_widget_show ( item );
3813
3814 item = gtk_image_menu_item_new_with_mnemonic ( _("New _Track") );
3815 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_NEW, GTK_ICON_SIZE_MENU) );
3816 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_new_track), pass_along );
3817 gtk_menu_shell_append (GTK_MENU_SHELL (new_submenu), item);
3818 gtk_widget_show ( item );
3819 // Make it available only when a new track *not* already in progress
3820 gtk_widget_set_sensitive ( item, ! (gboolean)GPOINTER_TO_INT(vtl->current_track) );
3821
3822 item = gtk_image_menu_item_new_with_mnemonic ( _("New _Route") );
3823 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_NEW, GTK_ICON_SIZE_MENU) );
3824 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_new_route), pass_along );
3825 gtk_menu_shell_append (GTK_MENU_SHELL (new_submenu), item);
3826 gtk_widget_show ( item );
3827 // Make it available only when a new track *not* already in progress
3828 gtk_widget_set_sensitive ( item, ! (gboolean)GPOINTER_TO_INT(vtl->current_track) );
3829
3830#ifdef VIK_CONFIG_GEOTAG
3831 item = gtk_menu_item_new_with_mnemonic ( _("Geotag _Images...") );
3832 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_geotagging), pass_along );
3833 gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
3834 gtk_widget_show ( item );
3835#endif
3836
3837 GtkWidget *acquire_submenu = gtk_menu_new ();
3838 item = gtk_image_menu_item_new_with_mnemonic ( _("_Acquire") );
3839 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_GO_DOWN, GTK_ICON_SIZE_MENU) );
3840 gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
3841 gtk_widget_show ( item );
3842 gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), acquire_submenu );
3843
3844 item = gtk_menu_item_new_with_mnemonic ( _("From _GPS...") );
3845 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_acquire_gps_cb), pass_along );
3846 gtk_menu_shell_append (GTK_MENU_SHELL (acquire_submenu), item);
3847 gtk_widget_show ( item );
3848
3849 /* FIXME: only add menu when at least a routing engine has support for Directions */
3850 item = gtk_menu_item_new_with_mnemonic ( _("From _Directions...") );
3851 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_acquire_routing_cb), pass_along );
3852 gtk_menu_shell_append (GTK_MENU_SHELL (acquire_submenu), item);
3853 gtk_widget_show ( item );
3854
3855#ifdef VIK_CONFIG_OPENSTREETMAP
3856 item = gtk_menu_item_new_with_mnemonic ( _("From _OSM Traces...") );
3857 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_acquire_osm_cb), pass_along );
3858 gtk_menu_shell_append (GTK_MENU_SHELL (acquire_submenu), item);
3859 gtk_widget_show ( item );
3860
3861 item = gtk_menu_item_new_with_mnemonic ( _("From _My OSM Traces...") );
3862 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_acquire_osm_my_traces_cb), pass_along );
3863 gtk_menu_shell_append (GTK_MENU_SHELL (acquire_submenu), item);
3864 gtk_widget_show ( item );
3865#endif
3866
3867 item = gtk_menu_item_new_with_mnemonic ( _("From _URL...") );
3868 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_acquire_url_cb), pass_along );
3869 gtk_menu_shell_append (GTK_MENU_SHELL (acquire_submenu), item);
3870 gtk_widget_show ( item );
3871
3872#ifdef VIK_CONFIG_GEONAMES
3873 GtkWidget *wikipedia_submenu = gtk_menu_new();
3874 item = gtk_image_menu_item_new_with_mnemonic ( _("From _Wikipedia Waypoints") );
3875 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_ADD, GTK_ICON_SIZE_MENU) );
3876 gtk_menu_shell_append(GTK_MENU_SHELL (acquire_submenu), item);
3877 gtk_widget_show(item);
3878 gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), wikipedia_submenu);
3879
3880 item = gtk_image_menu_item_new_with_mnemonic ( _("Within _Layer Bounds") );
3881 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_ZOOM_FIT, GTK_ICON_SIZE_MENU) );
3882 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_new_wikipedia_wp_layer), pass_along );
3883 gtk_menu_shell_append (GTK_MENU_SHELL (wikipedia_submenu), item);
3884 gtk_widget_show ( item );
3885
3886 item = gtk_image_menu_item_new_with_mnemonic ( _("Within _Current View") );
3887 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_ZOOM_100, GTK_ICON_SIZE_MENU) );
3888 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_new_wikipedia_wp_viewport), pass_along );
3889 gtk_menu_shell_append (GTK_MENU_SHELL (wikipedia_submenu), item);
3890 gtk_widget_show ( item );
3891#endif
3892
3893#ifdef VIK_CONFIG_GEOCACHES
3894 item = gtk_menu_item_new_with_mnemonic ( _("From Geo_caching...") );
3895 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_acquire_geocache_cb), pass_along );
3896 gtk_menu_shell_append (GTK_MENU_SHELL (acquire_submenu), item);
3897 gtk_widget_show ( item );
3898#endif
3899
3900#ifdef VIK_CONFIG_GEOTAG
3901 item = gtk_menu_item_new_with_mnemonic ( _("From Geotagged _Images...") );
3902 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_acquire_geotagged_cb), pass_along );
3903 gtk_menu_shell_append (GTK_MENU_SHELL (acquire_submenu), item);
3904 gtk_widget_show ( item );
3905#endif
3906
3907 item = gtk_menu_item_new_with_mnemonic ( _("From _File...") );
3908 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_acquire_file_cb), pass_along );
3909 gtk_menu_shell_append (GTK_MENU_SHELL (acquire_submenu), item);
3910 gtk_widget_set_tooltip_text (item, _("Import File With GPS_Babel..."));
3911 gtk_widget_show ( item );
3912
3913 vik_ext_tool_datasources_add_menu_items_to_menu ( VIK_WINDOW(VIK_GTK_WINDOW_FROM_LAYER(vtl)), GTK_MENU (acquire_submenu) );
3914
3915 GtkWidget *upload_submenu = gtk_menu_new ();
3916 item = gtk_image_menu_item_new_with_mnemonic ( _("_Upload") );
3917 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_GO_UP, GTK_ICON_SIZE_MENU) );
3918 gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
3919 gtk_widget_show ( item );
3920 gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), upload_submenu );
3921
3922 item = gtk_image_menu_item_new_with_mnemonic ( _("Upload to _GPS...") );
3923 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_GO_FORWARD, GTK_ICON_SIZE_MENU) );
3924 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_gps_upload), pass_along );
3925 gtk_menu_shell_append (GTK_MENU_SHELL (upload_submenu), item);
3926 gtk_widget_show ( item );
3927
3928#ifdef VIK_CONFIG_OPENSTREETMAP
3929 item = gtk_image_menu_item_new_with_mnemonic ( _("Upload to _OSM...") );
3930 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_GO_UP, GTK_ICON_SIZE_MENU) );
3931 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(osm_traces_upload_cb), pass_along );
3932 gtk_menu_shell_append (GTK_MENU_SHELL (upload_submenu), item);
3933 gtk_widget_show ( item );
3934#endif
3935
3936 GtkWidget *delete_submenu = gtk_menu_new ();
3937 item = gtk_image_menu_item_new_with_mnemonic ( _("De_lete") );
3938 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_REMOVE, GTK_ICON_SIZE_MENU) );
3939 gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
3940 gtk_widget_show ( item );
3941 gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), delete_submenu );
3942
3943 item = gtk_image_menu_item_new_with_mnemonic ( _("Delete All _Tracks") );
3944 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_REMOVE, GTK_ICON_SIZE_MENU) );
3945 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_delete_all_tracks), pass_along );
3946 gtk_menu_shell_append ( GTK_MENU_SHELL(delete_submenu), item );
3947 gtk_widget_show ( item );
3948
3949 item = gtk_image_menu_item_new_with_mnemonic ( _("Delete Tracks _From Selection...") );
3950 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_INDEX, GTK_ICON_SIZE_MENU) );
3951 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_delete_tracks_from_selection), pass_along );
3952 gtk_menu_shell_append ( GTK_MENU_SHELL(delete_submenu), item );
3953 gtk_widget_show ( item );
3954
3955 item = gtk_image_menu_item_new_with_mnemonic ( _("Delete _All Routes") );
3956 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_REMOVE, GTK_ICON_SIZE_MENU) );
3957 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_delete_all_routes), pass_along );
3958 gtk_menu_shell_append ( GTK_MENU_SHELL(delete_submenu), item );
3959 gtk_widget_show ( item );
3960
3961 item = gtk_image_menu_item_new_with_mnemonic ( _("_Delete Routes From Selection...") );
3962 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_INDEX, GTK_ICON_SIZE_MENU) );
3963 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_delete_routes_from_selection), pass_along );
3964 gtk_menu_shell_append ( GTK_MENU_SHELL(delete_submenu), item );
3965 gtk_widget_show ( item );
3966
3967 item = gtk_image_menu_item_new_with_mnemonic ( _("Delete All _Waypoints") );
3968 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_REMOVE, GTK_ICON_SIZE_MENU) );
3969 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_delete_all_waypoints), pass_along );
3970 gtk_menu_shell_append ( GTK_MENU_SHELL(delete_submenu), item );
3971 gtk_widget_show ( item );
3972
3973 item = gtk_image_menu_item_new_with_mnemonic ( _("Delete Waypoints From _Selection...") );
3974 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_INDEX, GTK_ICON_SIZE_MENU) );
3975 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_delete_waypoints_from_selection), pass_along );
3976 gtk_menu_shell_append ( GTK_MENU_SHELL(delete_submenu), item );
3977 gtk_widget_show ( item );
3978
3979 item = a_acquire_trwlayer_menu ( VIK_WINDOW(VIK_GTK_WINDOW_FROM_LAYER(vtl)), vlp,
3980 vik_layers_panel_get_viewport(VIK_LAYERS_PANEL(vlp)), vtl );
3981 if ( item ) {
3982 gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
3983 gtk_widget_show ( item );
3984 }
3985
3986 item = a_acquire_trwlayer_track_menu ( VIK_WINDOW(VIK_GTK_WINDOW_FROM_LAYER(vtl)), vlp,
3987 vik_layers_panel_get_viewport(VIK_LAYERS_PANEL(vlp)), vtl );
3988 if ( item ) {
3989 gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
3990 gtk_widget_show ( item );
3991 }
3992
3993 item = gtk_image_menu_item_new_with_mnemonic ( _("Track _List...") );
3994 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_INDEX, GTK_ICON_SIZE_MENU) );
3995 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_track_list_dialog), pass_along );
3996 gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
3997 gtk_widget_show ( item );
3998 gtk_widget_set_sensitive ( item, (gboolean)(g_hash_table_size (vtl->tracks)+g_hash_table_size (vtl->routes)) );
3999
4000 item = gtk_image_menu_item_new_with_mnemonic ( _("_Waypoint List...") );
4001 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_INDEX, GTK_ICON_SIZE_MENU) );
4002 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_waypoint_list_dialog), pass_along );
4003 gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
4004 gtk_widget_show ( item );
4005 gtk_widget_set_sensitive ( item, (gboolean)(g_hash_table_size (vtl->waypoints)) );
4006}
4007
4008// Fake Waypoint UUIDs vi simple increasing integer
4009static guint wp_uuid = 0;
4010
4011void vik_trw_layer_add_waypoint ( VikTrwLayer *vtl, gchar *name, VikWaypoint *wp )
4012{
4013 wp_uuid++;
4014
4015 vik_waypoint_set_name (wp, name);
4016
4017 if ( VIK_LAYER(vtl)->realized )
4018 {
4019 // Do we need to create the sublayer:
4020 if ( g_hash_table_size (vtl->waypoints) == 0 ) {
4021 trw_layer_add_sublayer_waypoints ( vtl, VIK_LAYER(vtl)->vt, &(VIK_LAYER(vtl)->iter) );
4022 }
4023
4024 GtkTreeIter *iter = g_malloc(sizeof(GtkTreeIter));
4025
4026 // Visibility column always needed for waypoints
4027 vik_treeview_add_sublayer ( VIK_LAYER(vtl)->vt, &(vtl->waypoints_iter), iter, name, vtl, GUINT_TO_POINTER(wp_uuid), VIK_TRW_LAYER_SUBLAYER_WAYPOINT, get_wp_sym_small (wp->symbol), TRUE, TRUE );
4028
4029 // Actual setting of visibility dependent on the waypoint
4030 vik_treeview_item_set_visible ( VIK_LAYER(vtl)->vt, iter, wp->visible );
4031
4032 g_hash_table_insert ( vtl->waypoints_iters, GUINT_TO_POINTER(wp_uuid), iter );
4033
4034 // Sort now as post_read is not called on a realized waypoint
4035 vik_treeview_sort_children ( VIK_LAYER(vtl)->vt, &(vtl->waypoints_iter), vtl->wp_sort_order );
4036 }
4037
4038 highest_wp_number_add_wp(vtl, name);
4039 g_hash_table_insert ( vtl->waypoints, GUINT_TO_POINTER(wp_uuid), wp );
4040
4041}
4042
4043// Fake Track UUIDs vi simple increasing integer
4044static guint tr_uuid = 0;
4045
4046void vik_trw_layer_add_track ( VikTrwLayer *vtl, gchar *name, VikTrack *t )
4047{
4048 tr_uuid++;
4049
4050 vik_track_set_name (t, name);
4051
4052 if ( VIK_LAYER(vtl)->realized )
4053 {
4054 // Do we need to create the sublayer:
4055 if ( g_hash_table_size (vtl->tracks) == 0 ) {
4056 trw_layer_add_sublayer_tracks ( vtl, VIK_LAYER(vtl)->vt, &(VIK_LAYER(vtl)->iter) );
4057 }
4058
4059 GtkTreeIter *iter = g_malloc(sizeof(GtkTreeIter));
4060 // Visibility column always needed for tracks
4061 vik_treeview_add_sublayer ( VIK_LAYER(vtl)->vt, &(vtl->tracks_iter), iter, name, vtl, GUINT_TO_POINTER(tr_uuid), VIK_TRW_LAYER_SUBLAYER_TRACK, NULL, TRUE, TRUE );
4062
4063 // Actual setting of visibility dependent on the track
4064 vik_treeview_item_set_visible ( VIK_LAYER(vtl)->vt, iter, t->visible );
4065
4066 g_hash_table_insert ( vtl->tracks_iters, GUINT_TO_POINTER(tr_uuid), iter );
4067
4068 // Sort now as post_read is not called on a realized track
4069 vik_treeview_sort_children ( VIK_LAYER(vtl)->vt, &(vtl->tracks_iter), vtl->track_sort_order );
4070 }
4071
4072 g_hash_table_insert ( vtl->tracks, GUINT_TO_POINTER(tr_uuid), t );
4073
4074 trw_layer_update_treeview ( vtl, t );
4075}
4076
4077// Fake Route UUIDs vi simple increasing integer
4078static guint rt_uuid = 0;
4079
4080void vik_trw_layer_add_route ( VikTrwLayer *vtl, gchar *name, VikTrack *t )
4081{
4082 rt_uuid++;
4083
4084 vik_track_set_name (t, name);
4085
4086 if ( VIK_LAYER(vtl)->realized )
4087 {
4088 // Do we need to create the sublayer:
4089 if ( g_hash_table_size (vtl->routes) == 0 ) {
4090 trw_layer_add_sublayer_routes ( vtl, VIK_LAYER(vtl)->vt, &(VIK_LAYER(vtl)->iter) );
4091 }
4092
4093 GtkTreeIter *iter = g_malloc(sizeof(GtkTreeIter));
4094 // Visibility column always needed for routes
4095 vik_treeview_add_sublayer ( VIK_LAYER(vtl)->vt, &(vtl->routes_iter), iter, name, vtl, GUINT_TO_POINTER(rt_uuid), VIK_TRW_LAYER_SUBLAYER_ROUTE, NULL, TRUE, TRUE );
4096 // Actual setting of visibility dependent on the route
4097 vik_treeview_item_set_visible ( VIK_LAYER(vtl)->vt, iter, t->visible );
4098
4099 g_hash_table_insert ( vtl->routes_iters, GUINT_TO_POINTER(rt_uuid), iter );
4100
4101 // Sort now as post_read is not called on a realized route
4102 vik_treeview_sort_children ( VIK_LAYER(vtl)->vt, &(vtl->routes_iter), vtl->track_sort_order );
4103 }
4104
4105 g_hash_table_insert ( vtl->routes, GUINT_TO_POINTER(rt_uuid), t );
4106
4107 trw_layer_update_treeview ( vtl, t );
4108}
4109
4110/* to be called whenever a track has been deleted or may have been changed. */
4111void trw_layer_cancel_tps_of_track ( VikTrwLayer *vtl, VikTrack *trk )
4112{
4113 if (vtl->current_tp_track == trk )
4114 trw_layer_cancel_current_tp ( vtl, FALSE );
4115}
4116
4117/**
4118 * Normally this is done to due the waypoint size preference having changed
4119 */
4120void vik_trw_layer_reset_waypoints ( VikTrwLayer *vtl )
4121{
4122 GHashTableIter iter;
4123 gpointer key, value;
4124
4125 // Foreach waypoint
4126 g_hash_table_iter_init ( &iter, vtl->waypoints );
4127 while ( g_hash_table_iter_next ( &iter, &key, &value ) ) {
4128 VikWaypoint *wp = VIK_WAYPOINT(value);
4129 if ( wp->symbol ) {
4130 // Reapply symbol setting to update the pixbuf
4131 gchar *tmp_symbol = g_strdup ( wp->symbol );
4132 vik_waypoint_set_symbol ( wp, tmp_symbol );
4133 g_free ( tmp_symbol );
4134 }
4135 }
4136}
4137
4138/**
4139 * trw_layer_new_unique_sublayer_name:
4140 *
4141 * Allocates a unique new name
4142 */
4143gchar *trw_layer_new_unique_sublayer_name (VikTrwLayer *vtl, gint sublayer_type, const gchar *name)
4144{
4145 gint i = 2;
4146 gchar *newname = g_strdup(name);
4147
4148 gpointer id = NULL;
4149 do {
4150 id = NULL;
4151 switch ( sublayer_type ) {
4152 case VIK_TRW_LAYER_SUBLAYER_TRACK:
4153 id = (gpointer) vik_trw_layer_get_track ( vtl, newname );
4154 break;
4155 case VIK_TRW_LAYER_SUBLAYER_WAYPOINT:
4156 id = (gpointer) vik_trw_layer_get_waypoint ( vtl, newname );
4157 break;
4158 default:
4159 id = (gpointer) vik_trw_layer_get_route ( vtl, newname );
4160 break;
4161 }
4162 // If found a name already in use try adding 1 to it and we try again
4163 if ( id ) {
4164 gchar *new_newname = g_strdup_printf("%s#%d", name, i);
4165 g_free(newname);
4166 newname = new_newname;
4167 i++;
4168 }
4169 } while ( id != NULL);
4170
4171 return newname;
4172}
4173
4174void vik_trw_layer_filein_add_waypoint ( VikTrwLayer *vtl, gchar *name, VikWaypoint *wp )
4175{
4176 // No more uniqueness of name forced when loading from a file
4177 // This now makes this function a little redunant as we just flow the parameters through
4178 vik_trw_layer_add_waypoint ( vtl, name, wp );
4179}
4180
4181void vik_trw_layer_filein_add_track ( VikTrwLayer *vtl, gchar *name, VikTrack *tr )
4182{
4183 if ( vtl->route_finder_append && vtl->route_finder_current_track ) {
4184 vik_track_remove_dup_points ( tr ); /* make "double point" track work to undo */
4185 vik_track_steal_and_append_trackpoints ( vtl->route_finder_current_track, tr );
4186 vik_track_free ( tr );
4187 vtl->route_finder_append = FALSE; /* this means we have added it */
4188 } else {
4189
4190 // No more uniqueness of name forced when loading from a file
4191 if ( tr->is_route )
4192 vik_trw_layer_add_route ( vtl, name, tr );
4193 else
4194 vik_trw_layer_add_track ( vtl, name, tr );
4195
4196 if ( vtl->route_finder_check_added_track ) {
4197 vik_track_remove_dup_points ( tr ); /* make "double point" track work to undo */
4198 vtl->route_finder_added_track = tr;
4199 }
4200 }
4201}
4202
4203static void trw_layer_enum_item ( gpointer id, GList **tr, GList **l )
4204{
4205 *l = g_list_append(*l, id);
4206}
4207
4208/*
4209 * Move an item from one TRW layer to another TRW layer
4210 */
4211static void trw_layer_move_item ( VikTrwLayer *vtl_src, VikTrwLayer *vtl_dest, gpointer id, gint type )
4212{
4213 // TODO reconsider strategy when moving within layer (if anything...)
4214 gboolean rename = ( vtl_src != vtl_dest );
4215 if ( ! rename )
4216 return;
4217
4218 if (type == VIK_TRW_LAYER_SUBLAYER_TRACK) {
4219 VikTrack *trk = g_hash_table_lookup ( vtl_src->tracks, id );
4220
4221 gchar *newname;
4222 if ( rename )
4223 newname = trw_layer_new_unique_sublayer_name ( vtl_dest, type, trk->name );
4224 else
4225 newname = g_strdup ( trk->name );
4226
4227 VikTrack *trk2 = vik_track_copy ( trk, TRUE );
4228 vik_trw_layer_add_track ( vtl_dest, newname, trk2 );
4229 g_free ( newname );
4230 vik_trw_layer_delete_track ( vtl_src, trk );
4231 }
4232
4233 if (type == VIK_TRW_LAYER_SUBLAYER_ROUTE) {
4234 VikTrack *trk = g_hash_table_lookup ( vtl_src->routes, id );
4235
4236 gchar *newname;
4237 if ( rename )
4238 newname = trw_layer_new_unique_sublayer_name ( vtl_dest, type, trk->name );
4239 else
4240 newname = g_strdup ( trk->name );
4241
4242 VikTrack *trk2 = vik_track_copy ( trk, TRUE );
4243 vik_trw_layer_add_route ( vtl_dest, newname, trk2 );
4244 g_free ( newname );
4245 vik_trw_layer_delete_route ( vtl_src, trk );
4246 }
4247
4248 if (type == VIK_TRW_LAYER_SUBLAYER_WAYPOINT) {
4249 VikWaypoint *wp = g_hash_table_lookup ( vtl_src->waypoints, id );
4250
4251 gchar *newname;
4252 if ( rename )
4253 newname = trw_layer_new_unique_sublayer_name ( vtl_dest, type, wp->name );
4254 else
4255 newname = g_strdup ( wp->name );
4256
4257 VikWaypoint *wp2 = vik_waypoint_copy ( wp );
4258 vik_trw_layer_add_waypoint ( vtl_dest, newname, wp2 );
4259 g_free ( newname );
4260 trw_layer_delete_waypoint ( vtl_src, wp );
4261
4262 // Recalculate bounds even if not renamed as maybe dragged between layers
4263 trw_layer_calculate_bounds_waypoints ( vtl_dest );
4264 trw_layer_calculate_bounds_waypoints ( vtl_src );
4265 }
4266}
4267
4268static void trw_layer_drag_drop_request ( VikTrwLayer *vtl_src, VikTrwLayer *vtl_dest, GtkTreeIter *src_item_iter, GtkTreePath *dest_path )
4269{
4270 VikTreeview *vt = VIK_LAYER(vtl_src)->vt;
4271 gint type = vik_treeview_item_get_data(vt, src_item_iter);
4272
4273 if (!vik_treeview_item_get_pointer(vt, src_item_iter)) {
4274 GList *items = NULL;
4275 GList *iter;
4276
4277 if (type==VIK_TRW_LAYER_SUBLAYER_TRACKS) {
4278 g_hash_table_foreach ( vtl_src->tracks, (GHFunc)trw_layer_enum_item, &items);
4279 }
4280 if (type==VIK_TRW_LAYER_SUBLAYER_WAYPOINTS) {
4281 g_hash_table_foreach ( vtl_src->waypoints, (GHFunc)trw_layer_enum_item, &items);
4282 }
4283 if (type==VIK_TRW_LAYER_SUBLAYER_ROUTES) {
4284 g_hash_table_foreach ( vtl_src->routes, (GHFunc)trw_layer_enum_item, &items);
4285 }
4286
4287 iter = items;
4288 while (iter) {
4289 if (type==VIK_TRW_LAYER_SUBLAYER_TRACKS) {
4290 trw_layer_move_item ( vtl_src, vtl_dest, iter->data, VIK_TRW_LAYER_SUBLAYER_TRACK);
4291 } else if (type==VIK_TRW_LAYER_SUBLAYER_ROUTES) {
4292 trw_layer_move_item ( vtl_src, vtl_dest, iter->data, VIK_TRW_LAYER_SUBLAYER_ROUTE);
4293 } else {
4294 trw_layer_move_item ( vtl_src, vtl_dest, iter->data, VIK_TRW_LAYER_SUBLAYER_WAYPOINT);
4295 }
4296 iter = iter->next;
4297 }
4298 if (items)
4299 g_list_free(items);
4300 } else {
4301 gchar *name = vik_treeview_item_get_pointer(vt, src_item_iter);
4302 trw_layer_move_item(vtl_src, vtl_dest, name, type);
4303 }
4304}
4305
4306gboolean trw_layer_track_find_uuid ( const gpointer id, const VikTrack *trk, gpointer udata )
4307{
4308 trku_udata *user_data = udata;
4309 if ( trk == user_data->trk ) {
4310 user_data->uuid = id;
4311 return TRUE;
4312 }
4313 return FALSE;
4314}
4315
4316gboolean vik_trw_layer_delete_track ( VikTrwLayer *vtl, VikTrack *trk )
4317{
4318 gboolean was_visible = FALSE;
4319
4320 if ( trk && trk->name ) {
4321
4322 if ( trk == vtl->current_track ) {
4323 vtl->current_track = NULL;
4324 vtl->current_tp_track = NULL;
4325 vtl->current_tp_id = NULL;
4326 vtl->moving_tp = FALSE;
4327 }
4328
4329 was_visible = trk->visible;
4330
4331 if ( trk == vtl->route_finder_current_track )
4332 vtl->route_finder_current_track = NULL;
4333
4334 if ( trk == vtl->route_finder_added_track )
4335 vtl->route_finder_added_track = NULL;
4336
4337 trku_udata udata;
4338 udata.trk = trk;
4339 udata.uuid = NULL;
4340
4341 // Hmmm, want key of it
4342 gpointer *trkf = g_hash_table_find ( vtl->tracks, (GHRFunc) trw_layer_track_find_uuid, &udata );
4343
4344 if ( trkf && udata.uuid ) {
4345 /* could be current_tp, so we have to check */
4346 trw_layer_cancel_tps_of_track ( vtl, trk );
4347
4348 GtkTreeIter *it = g_hash_table_lookup ( vtl->tracks_iters, udata.uuid );
4349
4350 if ( it ) {
4351 vik_treeview_item_delete ( VIK_LAYER(vtl)->vt, it );
4352 g_hash_table_remove ( vtl->tracks_iters, udata.uuid );
4353 g_hash_table_remove ( vtl->tracks, udata.uuid );
4354
4355 // If last sublayer, then remove sublayer container
4356 if ( g_hash_table_size (vtl->tracks) == 0 ) {
4357 vik_treeview_item_delete ( VIK_LAYER(vtl)->vt, &(vtl->tracks_iter) );
4358 }
4359 }
4360 }
4361 }
4362 return was_visible;
4363}
4364
4365gboolean vik_trw_layer_delete_route ( VikTrwLayer *vtl, VikTrack *trk )
4366{
4367 gboolean was_visible = FALSE;
4368
4369 if ( trk && trk->name ) {
4370
4371 if ( trk == vtl->current_track ) {
4372 vtl->current_track = NULL;
4373 vtl->current_tp_track = NULL;
4374 vtl->current_tp_id = NULL;
4375 vtl->moving_tp = FALSE;
4376 }
4377
4378 was_visible = trk->visible;
4379
4380 if ( trk == vtl->route_finder_current_track )
4381 vtl->route_finder_current_track = NULL;
4382
4383 if ( trk == vtl->route_finder_added_track )
4384 vtl->route_finder_added_track = NULL;
4385
4386 trku_udata udata;
4387 udata.trk = trk;
4388 udata.uuid = NULL;
4389
4390 // Hmmm, want key of it
4391 gpointer *trkf = g_hash_table_find ( vtl->routes, (GHRFunc) trw_layer_track_find_uuid, &udata );
4392
4393 if ( trkf && udata.uuid ) {
4394 /* could be current_tp, so we have to check */
4395 trw_layer_cancel_tps_of_track ( vtl, trk );
4396
4397 GtkTreeIter *it = g_hash_table_lookup ( vtl->routes_iters, udata.uuid );
4398
4399 if ( it ) {
4400 vik_treeview_item_delete ( VIK_LAYER(vtl)->vt, it );
4401 g_hash_table_remove ( vtl->routes_iters, udata.uuid );
4402 g_hash_table_remove ( vtl->routes, udata.uuid );
4403
4404 // If last sublayer, then remove sublayer container
4405 if ( g_hash_table_size (vtl->routes) == 0 ) {
4406 vik_treeview_item_delete ( VIK_LAYER(vtl)->vt, &(vtl->routes_iter) );
4407 }
4408 }
4409 }
4410 }
4411 return was_visible;
4412}
4413
4414static gboolean trw_layer_delete_waypoint ( VikTrwLayer *vtl, VikWaypoint *wp )
4415{
4416 gboolean was_visible = FALSE;
4417
4418 if ( wp && wp->name ) {
4419
4420 if ( wp == vtl->current_wp ) {
4421 vtl->current_wp = NULL;
4422 vtl->current_wp_id = NULL;
4423 vtl->moving_wp = FALSE;
4424 }
4425
4426 was_visible = wp->visible;
4427
4428 wpu_udata udata;
4429 udata.wp = wp;
4430 udata.uuid = NULL;
4431
4432 // Hmmm, want key of it
4433 gpointer *wpf = g_hash_table_find ( vtl->waypoints, (GHRFunc) trw_layer_waypoint_find_uuid, (gpointer) &udata );
4434
4435 if ( wpf && udata.uuid ) {
4436 GtkTreeIter *it = g_hash_table_lookup ( vtl->waypoints_iters, udata.uuid );
4437
4438 if ( it ) {
4439 vik_treeview_item_delete ( VIK_LAYER(vtl)->vt, it );
4440 g_hash_table_remove ( vtl->waypoints_iters, udata.uuid );
4441
4442 highest_wp_number_remove_wp(vtl, wp->name);
4443 g_hash_table_remove ( vtl->waypoints, udata.uuid ); // last because this frees the name
4444
4445 // If last sublayer, then remove sublayer container
4446 if ( g_hash_table_size (vtl->waypoints) == 0 ) {
4447 vik_treeview_item_delete ( VIK_LAYER(vtl)->vt, &(vtl->waypoints_iter) );
4448 }
4449 }
4450 }
4451
4452 }
4453
4454 return was_visible;
4455}
4456
4457// Only for temporary use by trw_layer_delete_waypoint_by_name
4458static gboolean trw_layer_waypoint_find_uuid_by_name ( const gpointer id, const VikWaypoint *wp, gpointer udata )
4459{
4460 wpu_udata *user_data = udata;
4461 if ( ! strcmp ( wp->name, user_data->wp->name ) ) {
4462 user_data->uuid = id;
4463 return TRUE;
4464 }
4465 return FALSE;
4466}
4467
4468/*
4469 * Delete a waypoint by the given name
4470 * NOTE: ATM this will delete the first encountered Waypoint with the specified name
4471 * as there be multiple waypoints with the same name
4472 */
4473static gboolean trw_layer_delete_waypoint_by_name ( VikTrwLayer *vtl, const gchar *name )
4474{
4475 wpu_udata udata;
4476 // Fake a waypoint with the given name
4477 udata.wp = vik_waypoint_new ();
4478 vik_waypoint_set_name (udata.wp, name);
4479 // Currently only the name is used in this waypoint find function
4480 udata.uuid = NULL;
4481
4482 // Hmmm, want key of it
4483 gpointer *wpf = g_hash_table_find ( vtl->waypoints, (GHRFunc) trw_layer_waypoint_find_uuid_by_name, (gpointer) &udata );
4484
4485 vik_waypoint_free (udata.wp);
4486
4487 if ( wpf && udata.uuid )
4488 return trw_layer_delete_waypoint (vtl, g_hash_table_lookup ( vtl->waypoints, udata.uuid ));
4489 else
4490 return FALSE;
4491}
4492
4493typedef struct {
4494 VikTrack *trk; // input
4495 gpointer uuid; // output
4496} tpu_udata;
4497
4498// Only for temporary use by trw_layer_delete_track_by_name
4499static gboolean trw_layer_track_find_uuid_by_name ( const gpointer id, const VikTrack *trk, gpointer udata )
4500{
4501 tpu_udata *user_data = udata;
4502 if ( ! strcmp ( trk->name, user_data->trk->name ) ) {
4503 user_data->uuid = id;
4504 return TRUE;
4505 }
4506 return FALSE;
4507}
4508
4509/*
4510 * Delete a track by the given name
4511 * NOTE: ATM this will delete the first encountered Track with the specified name
4512 * as there may be multiple tracks with the same name within the specified hash table
4513 */
4514static gboolean trw_layer_delete_track_by_name ( VikTrwLayer *vtl, const gchar *name, GHashTable *ht_tracks )
4515{
4516 tpu_udata udata;
4517 // Fake a track with the given name
4518 udata.trk = vik_track_new ();
4519 vik_track_set_name (udata.trk, name);
4520 // Currently only the name is used in this waypoint find function
4521 udata.uuid = NULL;
4522
4523 // Hmmm, want key of it
4524 gpointer *trkf = g_hash_table_find ( ht_tracks, (GHRFunc) trw_layer_track_find_uuid_by_name, &udata );
4525
4526 vik_track_free (udata.trk);
4527
4528 if ( trkf && udata.uuid ) {
4529 // This could be a little better written...
4530 if ( vtl->tracks == ht_tracks )
4531 return vik_trw_layer_delete_track (vtl, g_hash_table_lookup ( ht_tracks, udata.uuid ));
4532 if ( vtl->routes == ht_tracks )
4533 return vik_trw_layer_delete_route (vtl, g_hash_table_lookup ( ht_tracks, udata.uuid ));
4534 return FALSE;
4535 }
4536 else
4537 return FALSE;
4538}
4539
4540static void remove_item_from_treeview ( const gpointer id, GtkTreeIter *it, VikTreeview * vt )
4541{
4542 vik_treeview_item_delete (vt, it );
4543}
4544
4545void vik_trw_layer_delete_all_routes ( VikTrwLayer *vtl )
4546{
4547
4548 vtl->current_track = NULL;
4549 vtl->route_finder_current_track = NULL;
4550 vtl->route_finder_added_track = NULL;
4551 if (vtl->current_tp_track)
4552 trw_layer_cancel_current_tp(vtl, FALSE);
4553
4554 g_hash_table_foreach(vtl->routes_iters, (GHFunc) remove_item_from_treeview, VIK_LAYER(vtl)->vt);
4555 g_hash_table_remove_all(vtl->routes_iters);
4556 g_hash_table_remove_all(vtl->routes);
4557
4558 vik_treeview_item_delete ( VIK_LAYER(vtl)->vt, &(vtl->routes_iter) );
4559
4560 vik_layer_emit_update ( VIK_LAYER(vtl) );
4561}
4562
4563void vik_trw_layer_delete_all_tracks ( VikTrwLayer *vtl )
4564{
4565
4566 vtl->current_track = NULL;
4567 vtl->route_finder_current_track = NULL;
4568 vtl->route_finder_added_track = NULL;
4569 if (vtl->current_tp_track)
4570 trw_layer_cancel_current_tp(vtl, FALSE);
4571
4572 g_hash_table_foreach(vtl->tracks_iters, (GHFunc) remove_item_from_treeview, VIK_LAYER(vtl)->vt);
4573 g_hash_table_remove_all(vtl->tracks_iters);
4574 g_hash_table_remove_all(vtl->tracks);
4575
4576 vik_treeview_item_delete ( VIK_LAYER(vtl)->vt, &(vtl->tracks_iter) );
4577
4578 vik_layer_emit_update ( VIK_LAYER(vtl) );
4579}
4580
4581void vik_trw_layer_delete_all_waypoints ( VikTrwLayer *vtl )
4582{
4583 vtl->current_wp = NULL;
4584 vtl->current_wp_id = NULL;
4585 vtl->moving_wp = FALSE;
4586
4587 highest_wp_number_reset(vtl);
4588
4589 g_hash_table_foreach(vtl->waypoints_iters, (GHFunc) remove_item_from_treeview, VIK_LAYER(vtl)->vt);
4590 g_hash_table_remove_all(vtl->waypoints_iters);
4591 g_hash_table_remove_all(vtl->waypoints);
4592
4593 vik_treeview_item_delete ( VIK_LAYER(vtl)->vt, &(vtl->waypoints_iter) );
4594
4595 vik_layer_emit_update ( VIK_LAYER(vtl) );
4596}
4597
4598static void trw_layer_delete_all_tracks ( gpointer lav[2] )
4599{
4600 VikTrwLayer *vtl = VIK_TRW_LAYER(lav[0]);
4601 // Get confirmation from the user
4602 if ( a_dialog_yes_or_no ( VIK_GTK_WINDOW_FROM_LAYER(vtl),
4603 _("Are you sure you want to delete all tracks in %s?"),
4604 vik_layer_get_name ( VIK_LAYER(vtl) ) ) )
4605 vik_trw_layer_delete_all_tracks (vtl);
4606}
4607
4608static void trw_layer_delete_all_routes ( gpointer lav[2] )
4609{
4610 VikTrwLayer *vtl = VIK_TRW_LAYER(lav[0]);
4611 // Get confirmation from the user
4612 if ( a_dialog_yes_or_no ( VIK_GTK_WINDOW_FROM_LAYER(vtl),
4613 _("Are you sure you want to delete all routes in %s?"),
4614 vik_layer_get_name ( VIK_LAYER(vtl) ) ) )
4615 vik_trw_layer_delete_all_routes (vtl);
4616}
4617
4618static void trw_layer_delete_all_waypoints ( gpointer lav[2] )
4619{
4620 VikTrwLayer *vtl = VIK_TRW_LAYER(lav[0]);
4621 // Get confirmation from the user
4622 if ( a_dialog_yes_or_no ( VIK_GTK_WINDOW_FROM_LAYER(vtl),
4623 _("Are you sure you want to delete all waypoints in %s?"),
4624 vik_layer_get_name ( VIK_LAYER(vtl) ) ) )
4625 vik_trw_layer_delete_all_waypoints (vtl);
4626}
4627
4628static void trw_layer_delete_item ( gpointer pass_along[6] )
4629{
4630 VikTrwLayer *vtl = VIK_TRW_LAYER(pass_along[0]);
4631 gboolean was_visible = FALSE;
4632 if ( GPOINTER_TO_INT (pass_along[2]) == VIK_TRW_LAYER_SUBLAYER_WAYPOINT )
4633 {
4634 VikWaypoint *wp = g_hash_table_lookup ( vtl->waypoints, pass_along[3] );
4635 if ( wp && wp->name ) {
4636 if ( GPOINTER_TO_INT ( pass_along[4]) )
4637 // Get confirmation from the user
4638 // Maybe this Waypoint Delete should be optional as is it could get annoying...
4639 if ( ! a_dialog_yes_or_no ( VIK_GTK_WINDOW_FROM_LAYER(vtl),
4640 _("Are you sure you want to delete the waypoint \"%s\"?"),
4641 wp->name ) )
4642 return;
4643 was_visible = trw_layer_delete_waypoint ( vtl, wp );
4644 }
4645 }
4646 else if ( GPOINTER_TO_INT (pass_along[2]) == VIK_TRW_LAYER_SUBLAYER_TRACK )
4647 {
4648 VikTrack *trk = g_hash_table_lookup ( vtl->tracks, pass_along[3] );
4649 if ( trk && trk->name ) {
4650 if ( GPOINTER_TO_INT ( pass_along[4]) )
4651 // Get confirmation from the user
4652 if ( ! a_dialog_yes_or_no ( VIK_GTK_WINDOW_FROM_LAYER(vtl),
4653 _("Are you sure you want to delete the track \"%s\"?"),
4654 trk->name ) )
4655 return;
4656 was_visible = vik_trw_layer_delete_track ( vtl, trk );
4657 }
4658 }
4659 else
4660 {
4661 VikTrack *trk = g_hash_table_lookup ( vtl->routes, pass_along[3] );
4662 if ( trk && trk->name ) {
4663 if ( GPOINTER_TO_INT ( pass_along[4]) )
4664 // Get confirmation from the user
4665 if ( ! a_dialog_yes_or_no ( VIK_GTK_WINDOW_FROM_LAYER(vtl),
4666 _("Are you sure you want to delete the route \"%s\"?"),
4667 trk->name ) )
4668 return;
4669 was_visible = vik_trw_layer_delete_route ( vtl, trk );
4670 }
4671 }
4672 if ( was_visible )
4673 vik_layer_emit_update ( VIK_LAYER(vtl) );
4674}
4675
4676/**
4677 * Rename waypoint and maintain corresponding name of waypoint in the treeview
4678 */
4679void trw_layer_waypoint_rename ( VikTrwLayer *vtl, VikWaypoint *wp, const gchar *new_name )
4680{
4681 vik_waypoint_set_name ( wp, new_name );
4682
4683 // Now update the treeview as well
4684 wpu_udata udataU;
4685 udataU.wp = wp;
4686 udataU.uuid = NULL;
4687
4688 // Need key of it for treeview update
4689 gpointer *wpf = g_hash_table_find ( vtl->waypoints, (GHRFunc) trw_layer_waypoint_find_uuid, &udataU );
4690
4691 if ( wpf && udataU.uuid ) {
4692 GtkTreeIter *it = g_hash_table_lookup ( vtl->waypoints_iters, udataU.uuid );
4693
4694 if ( it ) {
4695 vik_treeview_item_set_name ( VIK_LAYER(vtl)->vt, it, new_name );
4696 vik_treeview_sort_children ( VIK_LAYER(vtl)->vt, &(vtl->waypoints_iter), vtl->wp_sort_order );
4697 }
4698 }
4699}
4700
4701/**
4702 * Maintain icon of waypoint in the treeview
4703 */
4704void trw_layer_waypoint_reset_icon ( VikTrwLayer *vtl, VikWaypoint *wp )
4705{
4706 // update the treeview
4707 wpu_udata udataU;
4708 udataU.wp = wp;
4709 udataU.uuid = NULL;
4710
4711 // Need key of it for treeview update
4712 gpointer *wpf = g_hash_table_find ( vtl->waypoints, (GHRFunc) trw_layer_waypoint_find_uuid, &udataU );
4713
4714 if ( wpf && udataU.uuid ) {
4715 GtkTreeIter *it = g_hash_table_lookup ( vtl->waypoints_iters, udataU.uuid );
4716
4717 if ( it ) {
4718 vik_treeview_item_set_icon ( VIK_LAYER(vtl)->vt, it, get_wp_sym_small (wp->symbol) );
4719 }
4720 }
4721}
4722
4723static void trw_layer_properties_item ( gpointer pass_along[7] )
4724{
4725 VikTrwLayer *vtl = VIK_TRW_LAYER(pass_along[0]);
4726 if ( GPOINTER_TO_INT (pass_along[2]) == VIK_TRW_LAYER_SUBLAYER_WAYPOINT )
4727 {
4728 VikWaypoint *wp = g_hash_table_lookup ( vtl->waypoints, pass_along[3] ); // sublayer
4729
4730 if ( wp && wp->name )
4731 {
4732 gboolean updated = FALSE;
4733 gchar *new_name = a_dialog_waypoint ( VIK_GTK_WINDOW_FROM_LAYER(vtl), wp->name, vtl, wp, vtl->coord_mode, FALSE, &updated );
4734 if ( new_name )
4735 trw_layer_waypoint_rename ( vtl, wp, new_name );
4736
4737 if ( updated && pass_along[6] )
4738 vik_treeview_item_set_icon ( VIK_LAYER(vtl)->vt, pass_along[6], get_wp_sym_small (wp->symbol) );
4739
4740 if ( updated && VIK_LAYER(vtl)->visible )
4741 vik_layer_emit_update ( VIK_LAYER(vtl) );
4742 }
4743 }
4744 else
4745 {
4746 VikTrack *tr;
4747 if ( GPOINTER_TO_INT (pass_along[2]) == VIK_TRW_LAYER_SUBLAYER_TRACK )
4748 tr = g_hash_table_lookup ( vtl->tracks, pass_along[3] );
4749 else
4750 tr = g_hash_table_lookup ( vtl->routes, pass_along[3] );
4751
4752 if ( tr && tr->name )
4753 {
4754 vik_trw_layer_propwin_run ( VIK_GTK_WINDOW_FROM_LAYER(vtl),
4755 vtl,
4756 tr,
4757 pass_along[1], /* vlp */
4758 pass_along[5], /* vvp */
4759 FALSE );
4760 }
4761 }
4762}
4763
4764/**
4765 * trw_layer_track_statistics:
4766 *
4767 * Show track statistics.
4768 * ATM jump to the stats page in the properties
4769 * TODO: consider separating the stats into an individual dialog?
4770 */
4771static void trw_layer_track_statistics ( gpointer pass_along[7] )
4772{
4773 VikTrwLayer *vtl = VIK_TRW_LAYER(pass_along[0]);
4774 VikTrack *trk;
4775 if ( GPOINTER_TO_INT (pass_along[2]) == VIK_TRW_LAYER_SUBLAYER_TRACK )
4776 trk = g_hash_table_lookup ( vtl->tracks, pass_along[3] );
4777 else
4778 trk = g_hash_table_lookup ( vtl->routes, pass_along[3] );
4779
4780 if ( trk && trk->name ) {
4781 vik_trw_layer_propwin_run ( VIK_GTK_WINDOW_FROM_LAYER(vtl),
4782 vtl,
4783 trk,
4784 pass_along[1], // vlp
4785 pass_along[5], // vvp
4786 TRUE );
4787 }
4788}
4789
4790/*
4791 * Update the treeview of the track id - primarily to update the icon
4792 */
4793void trw_layer_update_treeview ( VikTrwLayer *vtl, VikTrack *trk )
4794{
4795 trku_udata udata;
4796 udata.trk = trk;
4797 udata.uuid = NULL;
4798
4799 gpointer *trkf = NULL;
4800 if ( trk->is_route )
4801 trkf = g_hash_table_find ( vtl->routes, (GHRFunc) trw_layer_track_find_uuid, &udata );
4802 else
4803 trkf = g_hash_table_find ( vtl->tracks, (GHRFunc) trw_layer_track_find_uuid, &udata );
4804
4805 if ( trkf && udata.uuid ) {
4806
4807 GtkTreeIter *iter = NULL;
4808 if ( trk->is_route )
4809 iter = g_hash_table_lookup ( vtl->routes_iters, udata.uuid );
4810 else
4811 iter = g_hash_table_lookup ( vtl->tracks_iters, udata.uuid );
4812
4813 if ( iter ) {
4814 // TODO: Make this a function
4815 GdkPixbuf *pixbuf = gdk_pixbuf_new ( GDK_COLORSPACE_RGB, FALSE, 8, 18, 18);
4816 guint32 pixel = ((trk->color.red & 0xff00) << 16) |
4817 ((trk->color.green & 0xff00) << 8) |
4818 (trk->color.blue & 0xff00);
4819 gdk_pixbuf_fill ( pixbuf, pixel );
4820 vik_treeview_item_set_icon ( VIK_LAYER(vtl)->vt, iter, pixbuf );
4821 g_object_unref (pixbuf);
4822 }
4823
4824 }
4825}
4826
4827/*
4828 Parameter 1 -> VikLayersPanel
4829 Parameter 2 -> VikLayer
4830 Parameter 3 -> VikViewport
4831*/
4832static void goto_coord ( gpointer *vlp, gpointer vl, gpointer vvp, const VikCoord *coord )
4833{
4834 if ( vlp ) {
4835 vik_viewport_set_center_coord ( vik_layers_panel_get_viewport (VIK_LAYERS_PANEL(vlp)), coord );
4836 vik_layers_panel_emit_update ( VIK_LAYERS_PANEL(vlp) );
4837 }
4838 else {
4839 /* since vlp not set, vl & vvp should be valid instead! */
4840 if ( vl && vvp ) {
4841 vik_viewport_set_center_coord ( VIK_VIEWPORT(vvp), coord );
4842 vik_layer_emit_update ( VIK_LAYER(vl) );
4843 }
4844 }
4845}
4846
4847static void trw_layer_goto_track_startpoint ( gpointer pass_along[6] )
4848{
4849 VikTrwLayer *vtl = (VikTrwLayer *)pass_along[0];
4850 VikTrack *track;
4851 if ( GPOINTER_TO_INT (pass_along[2]) == VIK_TRW_LAYER_SUBLAYER_ROUTE )
4852 track = (VikTrack *) g_hash_table_lookup ( vtl->routes, pass_along[3] );
4853 else
4854 track = (VikTrack *) g_hash_table_lookup ( vtl->tracks, pass_along[3] );
4855
4856 if ( track && track->trackpoints )
4857 goto_coord ( pass_along[1], pass_along[0], pass_along[5], &(((VikTrackpoint *) track->trackpoints->data)->coord) );
4858}
4859
4860static void trw_layer_goto_track_center ( gpointer pass_along[6] )
4861{
4862 VikTrwLayer *vtl = (VikTrwLayer *)pass_along[0];
4863 VikTrack *track;
4864 if ( GPOINTER_TO_INT (pass_along[2]) == VIK_TRW_LAYER_SUBLAYER_ROUTE )
4865 track = (VikTrack *) g_hash_table_lookup ( vtl->routes, pass_along[3] );
4866 else
4867 track = (VikTrack *) g_hash_table_lookup ( vtl->tracks, pass_along[3] );
4868
4869 if ( track && track->trackpoints )
4870 {
4871 struct LatLon average, maxmin[2] = { {0,0}, {0,0} };
4872 VikCoord coord;
4873 trw_layer_find_maxmin_tracks ( NULL, track, maxmin );
4874 average.lat = (maxmin[0].lat+maxmin[1].lat)/2;
4875 average.lon = (maxmin[0].lon+maxmin[1].lon)/2;
4876 vik_coord_load_from_latlon ( &coord, vtl->coord_mode, &average );
4877 goto_coord ( pass_along[1], pass_along[0], pass_along[5], &coord);
4878 }
4879}
4880
4881static void trw_layer_convert_track_route ( gpointer pass_along[6] )
4882{
4883 VikTrwLayer *vtl = (VikTrwLayer *)pass_along[0];
4884 VikTrack *trk;
4885 if ( GPOINTER_TO_INT (pass_along[2]) == VIK_TRW_LAYER_SUBLAYER_ROUTE )
4886 trk = (VikTrack *) g_hash_table_lookup ( vtl->routes, pass_along[3] );
4887 else
4888 trk = (VikTrack *) g_hash_table_lookup ( vtl->tracks, pass_along[3] );
4889
4890 if ( !trk )
4891 return;
4892
4893 // Converting a track to a route can be a bit more complicated,
4894 // so give a chance to change our minds:
4895 if ( !trk->is_route &&
4896 ( ( vik_track_get_segment_count ( trk ) > 1 ) ||
4897 ( vik_track_get_average_speed ( trk ) > 0.0 ) ) ) {
4898
4899 if ( ! a_dialog_yes_or_no ( VIK_GTK_WINDOW_FROM_LAYER(vtl),
4900 _("Converting a track to a route removes extra track data such as segments, timestamps, etc...\nDo you want to continue?"), NULL ) )
4901 return;
4902}
4903
4904 // Copy it
4905 VikTrack *trk_copy = vik_track_copy ( trk, TRUE );
4906
4907 // Convert
4908 trk_copy->is_route = !trk_copy->is_route;
4909
4910 // ATM can't set name to self - so must create temporary copy
4911 gchar *name = g_strdup ( trk_copy->name );
4912
4913 // Delete old one and then add new one
4914 if ( trk->is_route ) {
4915 vik_trw_layer_delete_route ( vtl, trk );
4916 vik_trw_layer_add_track ( vtl, name, trk_copy );
4917 }
4918 else {
4919 // Extra route conversion bits...
4920 vik_track_merge_segments ( trk_copy );
4921 vik_track_to_routepoints ( trk_copy );
4922
4923 vik_trw_layer_delete_track ( vtl, trk );
4924 vik_trw_layer_add_route ( vtl, name, trk_copy );
4925 }
4926 g_free ( name );
4927
4928 // Update in case color of track / route changes when moving between sublayers
4929 vik_layer_emit_update ( VIK_LAYER(pass_along[0]) );
4930}
4931
4932static void trw_layer_anonymize_times ( gpointer pass_along[6] )
4933{
4934 VikTrwLayer *vtl = (VikTrwLayer *)pass_along[0];
4935 VikTrack *track;
4936 if ( GPOINTER_TO_INT (pass_along[2]) == VIK_TRW_LAYER_SUBLAYER_ROUTE )
4937 track = (VikTrack *) g_hash_table_lookup ( vtl->routes, pass_along[3] );
4938 else
4939 track = (VikTrack *) g_hash_table_lookup ( vtl->tracks, pass_along[3] );
4940
4941 if ( track )
4942 vik_track_anonymize_times ( track );
4943}
4944
4945static void trw_layer_extend_track_end ( gpointer pass_along[6] )
4946{
4947 VikTrwLayer *vtl = VIK_TRW_LAYER(pass_along[0]);
4948 VikTrack *track;
4949 if ( GPOINTER_TO_INT (pass_along[2]) == VIK_TRW_LAYER_SUBLAYER_ROUTE )
4950 track = (VikTrack *) g_hash_table_lookup ( vtl->routes, pass_along[3] );
4951 else
4952 track = (VikTrack *) g_hash_table_lookup ( vtl->tracks, pass_along[3] );
4953
4954 if ( !track )
4955 return;
4956
4957 vtl->current_track = track;
4958 vik_window_enable_layer_tool ( VIK_WINDOW(VIK_GTK_WINDOW_FROM_LAYER(vtl)), VIK_LAYER_TRW, track->is_route ? TOOL_CREATE_ROUTE : TOOL_CREATE_TRACK);
4959
4960 if ( track->trackpoints )
4961 goto_coord ( pass_along[1], pass_along[0], pass_along[5], &(((VikTrackpoint *)g_list_last(track->trackpoints)->data)->coord) );
4962}
4963
4964/**
4965 * extend a track using route finder
4966 */
4967static void trw_layer_extend_track_end_route_finder ( gpointer pass_along[6] )
4968{
4969 VikTrwLayer *vtl = VIK_TRW_LAYER(pass_along[0]);
4970 VikTrack *track = g_hash_table_lookup ( VIK_TRW_LAYER(pass_along[0])->routes, pass_along[3] );
4971 if ( !track )
4972 return;
4973 if ( !track->trackpoints )
4974 return;
4975 VikCoord last_coord = (((VikTrackpoint *)g_list_last(track->trackpoints)->data)->coord);
4976
4977 vik_window_enable_layer_tool ( VIK_WINDOW(VIK_GTK_WINDOW_FROM_LAYER(vtl)), VIK_LAYER_TRW, TOOL_ROUTE_FINDER );
4978 vtl->route_finder_coord = last_coord;
4979 vtl->route_finder_current_track = track;
4980 vtl->route_finder_started = TRUE;
4981
4982 if ( track->trackpoints )
4983 goto_coord ( pass_along[1], pass_along[0], pass_along[5], &last_coord) ;
4984
4985}
4986
4987/**
4988 *
4989 */
4990static gboolean trw_layer_dem_test ( VikTrwLayer *vtl, VikLayersPanel *vlp )
4991{
4992 // If have a vlp then perform a basic test to see if any DEM info available...
4993 if ( vlp ) {
4994 GList *dems = vik_layers_panel_get_all_layers_of_type (vlp, VIK_LAYER_DEM, TRUE); // Includes hidden DEM layer types
4995
4996 if ( !g_list_length(dems) ) {
4997 a_dialog_error_msg (VIK_GTK_WINDOW_FROM_LAYER(vtl), _("No DEM layers available, thus no DEM values can be applied.") );
4998 return FALSE;
4999 }
5000 }
5001 return TRUE;
5002}
5003
5004/**
5005 * apply_dem_data_common:
5006 *
5007 * A common function for applying the DEM values and reporting the results.
5008 */
5009static void apply_dem_data_common ( VikTrwLayer *vtl, VikLayersPanel *vlp, VikTrack *track, gboolean skip_existing_elevations )
5010{
5011 if ( !trw_layer_dem_test ( vtl, vlp ) )
5012 return;
5013
5014 gulong changed = vik_track_apply_dem_data ( track, skip_existing_elevations );
5015 // Inform user how much was changed
5016 gchar str[64];
5017 const gchar *tmp_str = ngettext("%ld point adjusted", "%ld points adjusted", changed);
5018 g_snprintf(str, 64, tmp_str, changed);
5019 a_dialog_info_msg (VIK_GTK_WINDOW_FROM_LAYER(vtl), str);
5020}
5021
5022static void trw_layer_apply_dem_data_all ( gpointer pass_along[6] )
5023{
5024 VikTrwLayer *vtl = (VikTrwLayer *)pass_along[0];
5025 VikTrack *track;
5026 if ( GPOINTER_TO_INT (pass_along[2]) == VIK_TRW_LAYER_SUBLAYER_ROUTE )
5027 track = (VikTrack *) g_hash_table_lookup ( vtl->routes, pass_along[3] );
5028 else
5029 track = (VikTrack *) g_hash_table_lookup ( vtl->tracks, pass_along[3] );
5030
5031 if ( track )
5032 apply_dem_data_common ( vtl, pass_along[1], track, FALSE );
5033}
5034
5035static void trw_layer_apply_dem_data_only_missing ( gpointer pass_along[6] )
5036{
5037 VikTrwLayer *vtl = (VikTrwLayer *)pass_along[0];
5038 VikTrack *track;
5039 if ( GPOINTER_TO_INT (pass_along[2]) == VIK_TRW_LAYER_SUBLAYER_ROUTE )
5040 track = (VikTrack *) g_hash_table_lookup ( vtl->routes, pass_along[3] );
5041 else
5042 track = (VikTrack *) g_hash_table_lookup ( vtl->tracks, pass_along[3] );
5043
5044 if ( track )
5045 apply_dem_data_common ( vtl, pass_along[1], track, TRUE );
5046}
5047
5048/**
5049 * smooth_it:
5050 *
5051 * A common function for applying the elevation smoothing and reporting the results.
5052 */
5053static void smooth_it ( VikTrwLayer *vtl, VikTrack *track, gboolean flat )
5054{
5055 gulong changed = vik_track_smooth_missing_elevation_data ( track, flat );
5056 // Inform user how much was changed
5057 gchar str[64];
5058 const gchar *tmp_str = ngettext("%ld point adjusted", "%ld points adjusted", changed);
5059 g_snprintf(str, 64, tmp_str, changed);
5060 a_dialog_info_msg (VIK_GTK_WINDOW_FROM_LAYER(vtl), str);
5061}
5062
5063/**
5064 *
5065 */
5066static void trw_layer_missing_elevation_data_interp ( gpointer pass_along[6] )
5067{
5068 VikTrwLayer *vtl = (VikTrwLayer *)pass_along[0];
5069 VikTrack *track;
5070 if ( GPOINTER_TO_INT (pass_along[2]) == VIK_TRW_LAYER_SUBLAYER_ROUTE )
5071 track = (VikTrack *) g_hash_table_lookup ( vtl->routes, pass_along[3] );
5072 else
5073 track = (VikTrack *) g_hash_table_lookup ( vtl->tracks, pass_along[3] );
5074
5075 if ( !track )
5076 return;
5077
5078 smooth_it ( vtl, track, FALSE );
5079}
5080
5081static void trw_layer_missing_elevation_data_flat ( gpointer pass_along[6] )
5082{
5083 VikTrwLayer *vtl = (VikTrwLayer *)pass_along[0];
5084 VikTrack *track;
5085 if ( GPOINTER_TO_INT (pass_along[2]) == VIK_TRW_LAYER_SUBLAYER_ROUTE )
5086 track = (VikTrack *) g_hash_table_lookup ( vtl->routes, pass_along[3] );
5087 else
5088 track = (VikTrack *) g_hash_table_lookup ( vtl->tracks, pass_along[3] );
5089
5090 if ( !track )
5091 return;
5092
5093 smooth_it ( vtl, track, TRUE );
5094}
5095
5096/**
5097 * Commonal helper function
5098 */
5099static void wp_changed_message ( VikTrwLayer *vtl, gint changed )
5100{
5101 gchar str[64];
5102 const gchar *tmp_str = ngettext("%ld waypoint changed", "%ld waypoints changed", changed);
5103 g_snprintf(str, 64, tmp_str, changed);
5104 a_dialog_info_msg (VIK_GTK_WINDOW_FROM_LAYER(vtl), str);
5105}
5106
5107static void trw_layer_apply_dem_data_wpt_all ( gpointer pass_along[6] )
5108{
5109 VikTrwLayer *vtl = (VikTrwLayer *)pass_along[0];
5110 VikLayersPanel *vlp = (VikLayersPanel *)pass_along[1];
5111
5112 if ( !trw_layer_dem_test ( vtl, vlp ) )
5113 return;
5114
5115 gint changed = 0;
5116 if ( GPOINTER_TO_INT (pass_along[2]) == VIK_TRW_LAYER_SUBLAYER_WAYPOINT ) {
5117 // Single Waypoint
5118 VikWaypoint *wp = (VikWaypoint *) g_hash_table_lookup ( vtl->waypoints, pass_along[3] );
5119 if ( wp )
5120 changed = (gint)vik_waypoint_apply_dem_data ( wp, FALSE );
5121 }
5122 else {
5123 // All waypoints
5124 GHashTableIter iter;
5125 gpointer key, value;
5126
5127 g_hash_table_iter_init ( &iter, vtl->waypoints );
5128 while ( g_hash_table_iter_next (&iter, &key, &value) ) {
5129 VikWaypoint *wp = VIK_WAYPOINT(value);
5130 changed = changed + (gint)vik_waypoint_apply_dem_data ( wp, FALSE );
5131 }
5132 }
5133 wp_changed_message ( vtl, changed );
5134}
5135
5136static void trw_layer_apply_dem_data_wpt_only_missing ( gpointer pass_along[6] )
5137{
5138 VikTrwLayer *vtl = (VikTrwLayer *)pass_along[0];
5139 VikLayersPanel *vlp = (VikLayersPanel *)pass_along[1];
5140
5141 if ( !trw_layer_dem_test ( vtl, vlp ) )
5142 return;
5143
5144 gint changed = 0;
5145 if ( GPOINTER_TO_INT (pass_along[2]) == VIK_TRW_LAYER_SUBLAYER_WAYPOINT ) {
5146 // Single Waypoint
5147 VikWaypoint *wp = (VikWaypoint *) g_hash_table_lookup ( vtl->waypoints, pass_along[3] );
5148 if ( wp )
5149 changed = (gint)vik_waypoint_apply_dem_data ( wp, TRUE );
5150 }
5151 else {
5152 // All waypoints
5153 GHashTableIter iter;
5154 gpointer key, value;
5155
5156 g_hash_table_iter_init ( &iter, vtl->waypoints );
5157 while ( g_hash_table_iter_next (&iter, &key, &value) ) {
5158 VikWaypoint *wp = VIK_WAYPOINT(value);
5159 changed = changed + (gint)vik_waypoint_apply_dem_data ( wp, TRUE );
5160 }
5161 }
5162 wp_changed_message ( vtl, changed );
5163}
5164
5165static void trw_layer_goto_track_endpoint ( gpointer pass_along[6] )
5166{
5167 VikTrwLayer *vtl = (VikTrwLayer *)pass_along[0];
5168 VikTrack *track;
5169 if ( GPOINTER_TO_INT (pass_along[2]) == VIK_TRW_LAYER_SUBLAYER_ROUTE )
5170 track = (VikTrack *) g_hash_table_lookup ( vtl->routes, pass_along[3] );
5171 else
5172 track = (VikTrack *) g_hash_table_lookup ( vtl->tracks, pass_along[3] );
5173
5174 if ( !track )
5175 return;
5176
5177 GList *trps = track->trackpoints;
5178 if ( !trps )
5179 return;
5180 trps = g_list_last(trps);
5181 goto_coord ( pass_along[1], pass_along[0], pass_along[5], &(((VikTrackpoint *) trps->data)->coord));
5182}
5183
5184static void trw_layer_goto_track_max_speed ( gpointer pass_along[6] )
5185{
5186 VikTrwLayer *vtl = (VikTrwLayer *)pass_along[0];
5187 VikTrack *track;
5188 if ( GPOINTER_TO_INT (pass_along[2]) == VIK_TRW_LAYER_SUBLAYER_ROUTE )
5189 track = (VikTrack *) g_hash_table_lookup ( vtl->routes, pass_along[3] );
5190 else
5191 track = (VikTrack *) g_hash_table_lookup ( vtl->tracks, pass_along[3] );
5192
5193 if ( !track )
5194 return;
5195
5196 VikTrackpoint* vtp = vik_track_get_tp_by_max_speed ( track );
5197 if ( !vtp )
5198 return;
5199 goto_coord ( pass_along[1], pass_along[0], pass_along[5], &(vtp->coord));
5200}
5201
5202static void trw_layer_goto_track_max_alt ( gpointer pass_along[6] )
5203{
5204 VikTrwLayer *vtl = (VikTrwLayer *)pass_along[0];
5205 VikTrack *track;
5206 if ( GPOINTER_TO_INT (pass_along[2]) == VIK_TRW_LAYER_SUBLAYER_ROUTE )
5207 track = (VikTrack *) g_hash_table_lookup ( vtl->routes, pass_along[3] );
5208 else
5209 track = (VikTrack *) g_hash_table_lookup ( vtl->tracks, pass_along[3] );
5210
5211 if ( !track )
5212 return;
5213
5214 VikTrackpoint* vtp = vik_track_get_tp_by_max_alt ( track );
5215 if ( !vtp )
5216 return;
5217 goto_coord ( pass_along[1], pass_along[0], pass_along[5], &(vtp->coord));
5218}
5219
5220static void trw_layer_goto_track_min_alt ( gpointer pass_along[6] )
5221{
5222 VikTrwLayer *vtl = (VikTrwLayer *)pass_along[0];
5223 VikTrack *track;
5224 if ( GPOINTER_TO_INT (pass_along[2]) == VIK_TRW_LAYER_SUBLAYER_ROUTE )
5225 track = (VikTrack *) g_hash_table_lookup ( vtl->routes, pass_along[3] );
5226 else
5227 track = (VikTrack *) g_hash_table_lookup ( vtl->tracks, pass_along[3] );
5228
5229 if ( !track )
5230 return;
5231
5232 VikTrackpoint* vtp = vik_track_get_tp_by_min_alt ( track );
5233 if ( !vtp )
5234 return;
5235 goto_coord ( pass_along[1], pass_along[0], pass_along[5], &(vtp->coord));
5236}
5237
5238/*
5239 * Automatically change the viewport to center on the track and zoom to see the extent of the track
5240 */
5241static void trw_layer_auto_track_view ( gpointer pass_along[6] )
5242{
5243 VikTrwLayer *vtl = VIK_TRW_LAYER(pass_along[0]);
5244 VikTrack *trk;
5245 if ( GPOINTER_TO_INT (pass_along[2]) == VIK_TRW_LAYER_SUBLAYER_ROUTE )
5246 trk = (VikTrack *) g_hash_table_lookup ( vtl->routes, pass_along[3] );
5247 else
5248 trk = (VikTrack *) g_hash_table_lookup ( vtl->tracks, pass_along[3] );
5249
5250 if ( trk && trk->trackpoints )
5251 {
5252 struct LatLon maxmin[2] = { {0,0}, {0,0} };
5253 trw_layer_find_maxmin_tracks ( NULL, trk, maxmin );
5254 trw_layer_zoom_to_show_latlons ( vtl, pass_along[5], maxmin );
5255 if ( pass_along[1] )
5256 vik_layers_panel_emit_update ( VIK_LAYERS_PANEL(pass_along[1]) );
5257 else
5258 vik_layer_emit_update ( VIK_LAYER(vtl) );
5259 }
5260}
5261
5262/*
5263 * Refine the selected track/route with a routing engine.
5264 * The routing engine is selected by the user, when requestiong the job.
5265 */
5266static void trw_layer_route_refine ( gpointer pass_along[6] )
5267{
5268 static gint last_engine = 0;
5269 VikTrwLayer *vtl = VIK_TRW_LAYER(pass_along[0]);
5270 VikTrack *trk;
5271
5272 if ( GPOINTER_TO_INT (pass_along[2]) == VIK_TRW_LAYER_SUBLAYER_ROUTE )
5273 trk = (VikTrack *) g_hash_table_lookup ( vtl->routes, pass_along[3] );
5274 else
5275 trk = (VikTrack *) g_hash_table_lookup ( vtl->tracks, pass_along[3] );
5276
5277 if ( trk && trk->trackpoints )
5278 {
5279 /* Check size of the route */
5280 int nb = vik_track_get_tp_count(trk);
5281 if (nb > 100) {
5282 GtkWidget *dialog = gtk_message_dialog_new (VIK_GTK_WINDOW_FROM_LAYER (vtl),
5283 GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
5284 GTK_MESSAGE_WARNING,
5285 GTK_BUTTONS_OK_CANCEL,
5286 _("Refining a track with many points (%d) is unlikely to yield sensible results. Do you want to Continue?"),
5287 nb);
5288 gint response = gtk_dialog_run ( GTK_DIALOG(dialog) );
5289 gtk_widget_destroy ( dialog );
5290 if (response != GTK_RESPONSE_OK )
5291 return;
5292 }
5293 /* Select engine from dialog */
5294 GtkWidget *dialog = gtk_dialog_new_with_buttons (_("Refine Route with Routing Engine..."),
5295 VIK_GTK_WINDOW_FROM_LAYER (vtl),
5296 GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
5297 GTK_STOCK_CANCEL,
5298 GTK_RESPONSE_REJECT,
5299 GTK_STOCK_OK,
5300 GTK_RESPONSE_ACCEPT,
5301 NULL);
5302 GtkWidget *label = gtk_label_new ( _("Select routing engine") );
5303 gtk_widget_show_all(label);
5304
5305 gtk_box_pack_start ( GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), label, TRUE, TRUE, 0 );
5306
5307 GtkWidget * combo = vik_routing_ui_selector_new ( (Predicate)vik_routing_engine_supports_refine, NULL );
5308 gtk_combo_box_set_active (GTK_COMBO_BOX (combo), last_engine);
5309 gtk_widget_show_all(combo);
5310
5311 gtk_box_pack_start ( GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), combo, TRUE, TRUE, 0 );
5312
5313 gtk_dialog_set_default_response ( GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT );
5314
5315 if ( gtk_dialog_run ( GTK_DIALOG(dialog) ) == GTK_RESPONSE_ACCEPT )
5316 {
5317 /* Dialog validated: retrieve selected engine and do the job */
5318 last_engine = gtk_combo_box_get_active ( GTK_COMBO_BOX(combo) );
5319 VikRoutingEngine *routing = vik_routing_ui_selector_get_nth (combo, last_engine);
5320
5321 /* Change cursor */
5322 vik_window_set_busy_cursor ( VIK_WINDOW(VIK_GTK_WINDOW_FROM_LAYER(pass_along[0])) );
5323
5324 /* Force saving track */
5325 /* FIXME: remove or rename this hack */
5326 vtl->route_finder_check_added_track = TRUE;
5327
5328 /* the job */
5329 vik_routing_engine_refine (routing, vtl, trk);
5330
5331 /* FIXME: remove or rename this hack */
5332 if ( vtl->route_finder_added_track )
5333 vik_track_calculate_bounds ( vtl->route_finder_added_track );
5334
5335 vtl->route_finder_added_track = NULL;
5336 vtl->route_finder_check_added_track = FALSE;
5337
5338 vik_layer_emit_update ( VIK_LAYER(vtl) );
5339
5340 /* Restore cursor */
5341 vik_window_clear_busy_cursor ( VIK_WINDOW(VIK_GTK_WINDOW_FROM_LAYER(pass_along[0])) );
5342 }
5343 gtk_widget_destroy ( dialog );
5344 }
5345}
5346
5347static void trw_layer_edit_trackpoint ( gpointer pass_along[6] )
5348{
5349 VikTrwLayer *vtl = VIK_TRW_LAYER(pass_along[0]);
5350 trw_layer_tpwin_init ( vtl );
5351}
5352
5353/*************************************
5354 * merge/split by time routines
5355 *************************************/
5356
5357/* called for each key in track hash table.
5358 * If the current track has the same time stamp type, add it to the result,
5359 * except the one pointed by "exclude".
5360 * set exclude to NULL if there is no exclude to check.
5361 * Note that the result is in reverse (for performance reasons).
5362 */
5363typedef struct {
5364 GList **result;
5365 GList *exclude;
5366 gboolean with_timestamps;
5367} twt_udata;
5368static void find_tracks_with_timestamp_type(gpointer key, gpointer value, gpointer udata)
5369{
5370 twt_udata *user_data = udata;
5371 VikTrackpoint *p1, *p2;
5372
5373 if (VIK_TRACK(value)->trackpoints == user_data->exclude) {
5374 return;
5375 }
5376
5377 if (VIK_TRACK(value)->trackpoints) {
5378 p1 = VIK_TRACKPOINT(VIK_TRACK(value)->trackpoints->data);
5379 p2 = VIK_TRACKPOINT(g_list_last(VIK_TRACK(value)->trackpoints)->data);
5380
5381 if ( user_data->with_timestamps ) {
5382 if (!p1->has_timestamp || !p2->has_timestamp) {
5383 return;
5384 }
5385 }
5386 else {
5387 // Don't add tracks with timestamps when getting non timestamp tracks
5388 if (p1->has_timestamp || p2->has_timestamp) {
5389 return;
5390 }
5391 }
5392 }
5393
5394 *(user_data->result) = g_list_prepend(*(user_data->result), key);
5395}
5396
5397/* called for each key in track hash table. if original track user_data[1] is close enough
5398 * to the passed one, add it to list in user_data[0]
5399 */
5400static void find_nearby_tracks_by_time (gpointer key, gpointer value, gpointer user_data)
5401{
5402 time_t t1, t2;
5403 VikTrackpoint *p1, *p2;
5404 VikTrack *trk = VIK_TRACK(value);
5405
5406 GList **nearby_tracks = ((gpointer *)user_data)[0];
5407 GList *tpoints = ((gpointer *)user_data)[1];
5408
5409 /* outline:
5410 * detect reasons for not merging, and return
5411 * if no reason is found not to merge, then do it.
5412 */
5413
5414 // Exclude the original track from the compiled list
5415 if (trk->trackpoints == tpoints) {
5416 return;
5417 }
5418
5419 t1 = VIK_TRACKPOINT(g_list_first(tpoints)->data)->timestamp;
5420 t2 = VIK_TRACKPOINT(g_list_last(tpoints)->data)->timestamp;
5421
5422 if (trk->trackpoints) {
5423 p1 = VIK_TRACKPOINT(g_list_first(trk->trackpoints)->data);
5424 p2 = VIK_TRACKPOINT(g_list_last(trk->trackpoints)->data);
5425
5426 if (!p1->has_timestamp || !p2->has_timestamp) {
5427 //g_print("no timestamp\n");
5428 return;
5429 }
5430
5431 guint threshold = GPOINTER_TO_UINT (((gpointer *)user_data)[2]);
5432 //g_print("Got track named %s, times %d, %d\n", trk->name, p1->timestamp, p2->timestamp);
5433 if (! (abs(t1 - p2->timestamp) < threshold ||
5434 /* p1 p2 t1 t2 */
5435 abs(p1->timestamp - t2) < threshold)
5436 /* t1 t2 p1 p2 */
5437 ) {
5438 return;
5439 }
5440 }
5441
5442 *nearby_tracks = g_list_prepend(*nearby_tracks, value);
5443}
5444
5445/* comparison function used to sort tracks; a and b are hash table keys */
5446/* Not actively used - can be restored if needed
5447static gint track_compare(gconstpointer a, gconstpointer b, gpointer user_data)
5448{
5449 GHashTable *tracks = user_data;
5450 time_t t1, t2;
5451
5452 t1 = VIK_TRACKPOINT(VIK_TRACK(g_hash_table_lookup(tracks, a))->trackpoints->data)->timestamp;
5453 t2 = VIK_TRACKPOINT(VIK_TRACK(g_hash_table_lookup(tracks, b))->trackpoints->data)->timestamp;
5454
5455 if (t1 < t2) return -1;
5456 if (t1 > t2) return 1;
5457 return 0;
5458}
5459*/
5460
5461/* comparison function used to sort trackpoints */
5462static gint trackpoint_compare(gconstpointer a, gconstpointer b)
5463{
5464 time_t t1 = VIK_TRACKPOINT(a)->timestamp, t2 = VIK_TRACKPOINT(b)->timestamp;
5465
5466 if (t1 < t2) return -1;
5467 if (t1 > t2) return 1;
5468 return 0;
5469}
5470
5471/**
5472 * comparison function which can be used to sort tracks or waypoints by name
5473 */
5474static gint sort_alphabetically (gconstpointer a, gconstpointer b, gpointer user_data)
5475{
5476 const gchar* namea = (const gchar*) a;
5477 const gchar* nameb = (const gchar*) b;
5478 if ( namea == NULL || nameb == NULL)
5479 return 0;
5480 else
5481 // Same sort method as used in the vik_treeview_*_alphabetize functions
5482 return strcmp ( namea, nameb );
5483}
5484
5485/**
5486 * Attempt to merge selected track with other tracks specified by the user
5487 * Tracks to merge with must be of the same 'type' as the selected track -
5488 * either all with timestamps, or all without timestamps
5489 */
5490static void trw_layer_merge_with_other ( gpointer pass_along[6] )
5491{
5492 VikTrwLayer *vtl = (VikTrwLayer *)pass_along[0];
5493 GList *other_tracks = NULL;
5494 GHashTable *ght_tracks;
5495 if ( GPOINTER_TO_INT (pass_along[2]) == VIK_TRW_LAYER_SUBLAYER_ROUTE )
5496 ght_tracks = vtl->routes;
5497 else
5498 ght_tracks = vtl->tracks;
5499
5500 VikTrack *track = (VikTrack *) g_hash_table_lookup ( ght_tracks, pass_along[3] );
5501
5502 if ( !track )
5503 return;
5504
5505 if ( !track->trackpoints )
5506 return;
5507
5508 twt_udata udata;
5509 udata.result = &other_tracks;
5510 udata.exclude = track->trackpoints;
5511 // Allow merging with 'similar' time type time tracks
5512 // i.e. either those times, or those without
5513 udata.with_timestamps = (VIK_TRACKPOINT(track->trackpoints->data)->has_timestamp);
5514
5515 g_hash_table_foreach(ght_tracks, find_tracks_with_timestamp_type, (gpointer)&udata);
5516 other_tracks = g_list_reverse(other_tracks);
5517
5518 if ( !other_tracks ) {
5519 if ( udata.with_timestamps )
5520 a_dialog_error_msg(VIK_GTK_WINDOW_FROM_LAYER(vtl), _("Failed. No other tracks with timestamps in this layer found"));
5521 else
5522 a_dialog_error_msg(VIK_GTK_WINDOW_FROM_LAYER(vtl), _("Failed. No other tracks without timestamps in this layer found"));
5523 return;
5524 }
5525
5526 // Sort alphabetically for user presentation
5527 // Convert into list of names for usage with dialog function
5528 // TODO: Need to consider how to work best when we can have multiple tracks the same name...
5529 GList *other_tracks_names = NULL;
5530 GList *iter = g_list_first ( other_tracks );
5531 while ( iter ) {
5532 other_tracks_names = g_list_append ( other_tracks_names, VIK_TRACK(g_hash_table_lookup (ght_tracks, iter->data))->name );
5533 iter = g_list_next ( iter );
5534 }
5535
5536 other_tracks_names = g_list_sort_with_data (other_tracks_names, sort_alphabetically, NULL);
5537
5538 GList *merge_list = a_dialog_select_from_list(VIK_GTK_WINDOW_FROM_LAYER(vtl),
5539 other_tracks_names,
5540 TRUE,
5541 _("Merge with..."),
5542 track->is_route ? _("Select route to merge with") : _("Select track to merge with"));
5543 g_list_free(other_tracks);
5544 g_list_free(other_tracks_names);
5545
5546 if (merge_list)
5547 {
5548 GList *l;
5549 for (l = merge_list; l != NULL; l = g_list_next(l)) {
5550 VikTrack *merge_track;
5551 if ( track->is_route )
5552 merge_track = vik_trw_layer_get_route ( vtl, l->data );
5553 else
5554 merge_track = vik_trw_layer_get_track ( vtl, l->data );
5555
5556 if (merge_track) {
5557 vik_track_steal_and_append_trackpoints ( track, merge_track );
5558 if ( track->is_route )
5559 vik_trw_layer_delete_route (vtl, merge_track);
5560 else
5561 vik_trw_layer_delete_track (vtl, merge_track);
5562 track->trackpoints = g_list_sort(track->trackpoints, trackpoint_compare);
5563 }
5564 }
5565 for (l = merge_list; l != NULL; l = g_list_next(l))
5566 g_free(l->data);
5567 g_list_free(merge_list);
5568
5569 vik_layer_emit_update( VIK_LAYER(vtl) );
5570 }
5571}
5572
5573// c.f. trw_layer_sorted_track_id_by_name_list
5574// but don't add the specified track to the list (normally current track)
5575static void trw_layer_sorted_track_id_by_name_list_exclude_self (const gpointer id, const VikTrack *trk, gpointer udata)
5576{
5577 twt_udata *user_data = udata;
5578
5579 // Skip self
5580 if (trk->trackpoints == user_data->exclude) {
5581 return;
5582 }
5583
5584 // Sort named list alphabetically
5585 *(user_data->result) = g_list_insert_sorted_with_data (*(user_data->result), trk->name, sort_alphabetically, NULL);
5586}
5587
5588/**
5589 * Join - this allows combining 'tracks' and 'track routes'
5590 * i.e. doesn't care about whether tracks have consistent timestamps
5591 * ATM can only append one track at a time to the currently selected track
5592 */
5593static void trw_layer_append_track ( gpointer pass_along[6] )
5594{
5595
5596 VikTrwLayer *vtl = (VikTrwLayer *)pass_along[0];
5597 VikTrack *trk;
5598 GHashTable *ght_tracks;
5599 if ( GPOINTER_TO_INT (pass_along[2]) == VIK_TRW_LAYER_SUBLAYER_ROUTE )
5600 ght_tracks = vtl->routes;
5601 else
5602 ght_tracks = vtl->tracks;
5603
5604 trk = (VikTrack *) g_hash_table_lookup ( ght_tracks, pass_along[3] );
5605
5606 if ( !trk )
5607 return;
5608
5609 GList *other_tracks_names = NULL;
5610
5611 // Sort alphabetically for user presentation
5612 // Convert into list of names for usage with dialog function
5613 // TODO: Need to consider how to work best when we can have multiple tracks the same name...
5614 twt_udata udata;
5615 udata.result = &other_tracks_names;
5616 udata.exclude = trk->trackpoints;
5617
5618 g_hash_table_foreach(ght_tracks, (GHFunc) trw_layer_sorted_track_id_by_name_list_exclude_self, (gpointer)&udata);
5619
5620 // Note the limit to selecting one track only
5621 // this is to control the ordering of appending tracks, i.e. the selected track always goes after the current track
5622 // (otherwise with multiple select the ordering would not be controllable by the user - automatically being alphabetically)
5623 GList *append_list = a_dialog_select_from_list(VIK_GTK_WINDOW_FROM_LAYER(vtl),
5624 other_tracks_names,
5625 FALSE,
5626 trk->is_route ? _("Append Route"): _("Append Track"),
5627 trk->is_route ? _("Select the route to append after the current route") :
5628 _("Select the track to append after the current track") );
5629
5630 g_list_free(other_tracks_names);
5631
5632 // It's a list, but shouldn't contain more than one other track!
5633 if ( append_list ) {
5634 GList *l;
5635 for (l = append_list; l != NULL; l = g_list_next(l)) {
5636 // TODO: at present this uses the first track found by name,
5637 // which with potential multiple same named tracks may not be the one selected...
5638 VikTrack *append_track;
5639 if ( trk->is_route )
5640 append_track = vik_trw_layer_get_route ( vtl, l->data );
5641 else
5642 append_track = vik_trw_layer_get_track ( vtl, l->data );
5643
5644 if ( append_track ) {
5645 vik_track_steal_and_append_trackpoints ( trk, append_track );
5646 if ( trk->is_route )
5647 vik_trw_layer_delete_route (vtl, append_track);
5648 else
5649 vik_trw_layer_delete_track (vtl, append_track);
5650 }
5651 }
5652 for (l = append_list; l != NULL; l = g_list_next(l))
5653 g_free(l->data);
5654 g_list_free(append_list);
5655
5656 vik_layer_emit_update( VIK_LAYER(vtl) );
5657 }
5658}
5659
5660/**
5661 * Very similar to trw_layer_append_track for joining
5662 * but this allows selection from the 'other' list
5663 * If a track is selected, then is shows routes and joins the selected one
5664 * If a route is selected, then is shows tracks and joins the selected one
5665 */
5666static void trw_layer_append_other ( gpointer pass_along[6] )
5667{
5668
5669 VikTrwLayer *vtl = (VikTrwLayer *)pass_along[0];
5670 VikTrack *trk;
5671 GHashTable *ght_mykind, *ght_others;
5672 if ( GPOINTER_TO_INT (pass_along[2]) == VIK_TRW_LAYER_SUBLAYER_ROUTE ) {
5673 ght_mykind = vtl->routes;
5674 ght_others = vtl->tracks;
5675 }
5676 else {
5677 ght_mykind = vtl->tracks;
5678 ght_others = vtl->routes;
5679 }
5680
5681 trk = (VikTrack *) g_hash_table_lookup ( ght_mykind, pass_along[3] );
5682
5683 if ( !trk )
5684 return;
5685
5686 GList *other_tracks_names = NULL;
5687
5688 // Sort alphabetically for user presentation
5689 // Convert into list of names for usage with dialog function
5690 // TODO: Need to consider how to work best when we can have multiple tracks the same name...
5691 twt_udata udata;
5692 udata.result = &other_tracks_names;
5693 udata.exclude = trk->trackpoints;
5694
5695 g_hash_table_foreach(ght_others, (GHFunc) trw_layer_sorted_track_id_by_name_list_exclude_self, (gpointer)&udata);
5696
5697 // Note the limit to selecting one track only
5698 // this is to control the ordering of appending tracks, i.e. the selected track always goes after the current track
5699 // (otherwise with multiple select the ordering would not be controllable by the user - automatically being alphabetically)
5700 GList *append_list = a_dialog_select_from_list(VIK_GTK_WINDOW_FROM_LAYER(vtl),
5701 other_tracks_names,
5702 FALSE,
5703 trk->is_route ? _("Append Track"): _("Append Route"),
5704 trk->is_route ? _("Select the track to append after the current route") :
5705 _("Select the route to append after the current track") );
5706
5707 g_list_free(other_tracks_names);
5708
5709 // It's a list, but shouldn't contain more than one other track!
5710 if ( append_list ) {
5711 GList *l;
5712 for (l = append_list; l != NULL; l = g_list_next(l)) {
5713 // TODO: at present this uses the first track found by name,
5714 // which with potential multiple same named tracks may not be the one selected...
5715
5716 // Get FROM THE OTHER TYPE list
5717 VikTrack *append_track;
5718 if ( trk->is_route )
5719 append_track = vik_trw_layer_get_track ( vtl, l->data );
5720 else
5721 append_track = vik_trw_layer_get_route ( vtl, l->data );
5722
5723 if ( append_track ) {
5724
5725 if ( !append_track->is_route &&
5726 ( ( vik_track_get_segment_count ( append_track ) > 1 ) ||
5727 ( vik_track_get_average_speed ( append_track ) > 0.0 ) ) ) {
5728
5729 if ( a_dialog_yes_or_no ( VIK_GTK_WINDOW_FROM_LAYER(vtl),
5730 _("Converting a track to a route removes extra track data such as segments, timestamps, etc...\nDo you want to continue?"), NULL ) ) {
5731 vik_track_merge_segments ( append_track );
5732 vik_track_to_routepoints ( append_track );
5733 }
5734 else {
5735 break;
5736 }
5737 }
5738
5739 vik_track_steal_and_append_trackpoints ( trk, append_track );
5740
5741 // Delete copied which is FROM THE OTHER TYPE list
5742 if ( trk->is_route )
5743 vik_trw_layer_delete_track (vtl, append_track);
5744 else
5745 vik_trw_layer_delete_route (vtl, append_track);
5746 }
5747 }
5748 for (l = append_list; l != NULL; l = g_list_next(l))
5749 g_free(l->data);
5750 g_list_free(append_list);
5751 vik_layer_emit_update( VIK_LAYER(vtl) );
5752 }
5753}
5754
5755/* merge by segments */
5756static void trw_layer_merge_by_segment ( gpointer pass_along[6] )
5757{
5758 VikTrwLayer *vtl = (VikTrwLayer *)pass_along[0];
5759 VikTrack *trk = (VikTrack *) g_hash_table_lookup ( vtl->tracks, pass_along[3] );
5760 guint segments = vik_track_merge_segments ( trk );
5761 // NB currently no need to redraw as segments not actually shown on the display
5762 // However inform the user of what happened:
5763 gchar str[64];
5764 const gchar *tmp_str = ngettext("%d segment merged", "%d segments merged", segments);
5765 g_snprintf(str, 64, tmp_str, segments);
5766 a_dialog_info_msg (VIK_GTK_WINDOW_FROM_LAYER(vtl), str );
5767}
5768
5769/* merge by time routine */
5770static void trw_layer_merge_by_timestamp ( gpointer pass_along[6] )
5771{
5772 VikTrwLayer *vtl = (VikTrwLayer *)pass_along[0];
5773
5774 //time_t t1, t2;
5775
5776 GList *tracks_with_timestamp = NULL;
5777 VikTrack *orig_trk = (VikTrack *) g_hash_table_lookup ( vtl->tracks, pass_along[3] );
5778 if (orig_trk->trackpoints &&
5779 !VIK_TRACKPOINT(orig_trk->trackpoints->data)->has_timestamp) {
5780 a_dialog_error_msg(VIK_GTK_WINDOW_FROM_LAYER(vtl), _("Failed. This track does not have timestamp"));
5781 return;
5782 }
5783
5784 twt_udata udata;
5785 udata.result = &tracks_with_timestamp;
5786 udata.exclude = orig_trk->trackpoints;
5787 udata.with_timestamps = TRUE;
5788 g_hash_table_foreach(vtl->tracks, find_tracks_with_timestamp_type, (gpointer)&udata);
5789 tracks_with_timestamp = g_list_reverse(tracks_with_timestamp);
5790
5791 if (!tracks_with_timestamp) {
5792 a_dialog_error_msg(VIK_GTK_WINDOW_FROM_LAYER(vtl), _("Failed. No other track in this layer has timestamp"));
5793 return;
5794 }
5795 g_list_free(tracks_with_timestamp);
5796
5797 static guint threshold_in_minutes = 1;
5798 if (!a_dialog_time_threshold(VIK_GTK_WINDOW_FROM_LAYER(vtl),
5799 _("Merge Threshold..."),
5800 _("Merge when time between tracks less than:"),
5801 &threshold_in_minutes)) {
5802 return;
5803 }
5804
5805 // keep attempting to merge all tracks until no merges within the time specified is possible
5806 gboolean attempt_merge = TRUE;
5807 GList *nearby_tracks = NULL;
5808 GList *trps;
5809 static gpointer params[3];
5810
5811 while ( attempt_merge ) {
5812
5813 // Don't try again unless tracks have changed
5814 attempt_merge = FALSE;
5815
5816 trps = orig_trk->trackpoints;
5817 if ( !trps )
5818 return;
5819
5820 if (nearby_tracks) {
5821 g_list_free(nearby_tracks);
5822 nearby_tracks = NULL;
5823 }
5824
5825 //t1 = ((VikTrackpoint *)trps->data)->timestamp;
5826 //t2 = ((VikTrackpoint *)g_list_last(trps)->data)->timestamp;
5827
5828 /* g_print("Original track times: %d and %d\n", t1, t2); */
5829 params[0] = &nearby_tracks;
5830 params[1] = (gpointer)trps;
5831 params[2] = GUINT_TO_POINTER (threshold_in_minutes*60); // In seconds
5832
5833 /* get a list of adjacent-in-time tracks */
5834 g_hash_table_foreach(vtl->tracks, find_nearby_tracks_by_time, params);
5835
5836 /* merge them */
5837 GList *l = nearby_tracks;
5838 while ( l ) {
5839 /*
5840#define get_first_trackpoint(x) VIK_TRACKPOINT(VIK_TRACK(x)->trackpoints->data)
5841#define get_last_trackpoint(x) VIK_TRACKPOINT(g_list_last(VIK_TRACK(x)->trackpoints)->data)
5842 time_t t1, t2;
5843 t1 = get_first_trackpoint(l)->timestamp;
5844 t2 = get_last_trackpoint(l)->timestamp;
5845#undef get_first_trackpoint
5846#undef get_last_trackpoint
5847 g_print(" %20s: track %d - %d\n", VIK_TRACK(l->data)->name, (int)t1, (int)t2);
5848 */
5849
5850 /* remove trackpoints from merged track, delete track */
5851 vik_track_steal_and_append_trackpoints ( orig_trk, VIK_TRACK(l->data) );
5852 vik_trw_layer_delete_track (vtl, VIK_TRACK(l->data));
5853
5854 // Tracks have changed, therefore retry again against all the remaining tracks
5855 attempt_merge = TRUE;
5856
5857 l = g_list_next(l);
5858 }
5859
5860 orig_trk->trackpoints = g_list_sort(orig_trk->trackpoints, trackpoint_compare);
5861 }
5862
5863 g_list_free(nearby_tracks);
5864
5865 vik_layer_emit_update( VIK_LAYER(vtl) );
5866}
5867
5868/**
5869 * Split a track at the currently selected trackpoint
5870 */
5871static void trw_layer_split_at_selected_trackpoint ( VikTrwLayer *vtl, gint subtype )
5872{
5873 if ( !vtl->current_tpl )
5874 return;
5875
5876 if ( vtl->current_tpl->next && vtl->current_tpl->prev ) {
5877 gchar *name = trw_layer_new_unique_sublayer_name(vtl, subtype, vtl->current_tp_track->name);
5878 if ( name ) {
5879 VikTrack *tr = vik_track_copy ( vtl->current_tp_track, FALSE );
5880 GList *newglist = g_list_alloc ();
5881 newglist->prev = NULL;
5882 newglist->next = vtl->current_tpl->next;
5883 newglist->data = vik_trackpoint_copy(VIK_TRACKPOINT(vtl->current_tpl->data));
5884 tr->trackpoints = newglist;
5885
5886 vtl->current_tpl->next->prev = newglist; /* end old track here */
5887 vtl->current_tpl->next = NULL;
5888
5889 // Bounds of the selected track changed due to the split
5890 vik_track_calculate_bounds ( vtl->current_tp_track );
5891
5892 vtl->current_tpl = newglist; /* change tp to first of new track. */
5893 vtl->current_tp_track = tr;
5894
5895 if ( tr->is_route )
5896 vik_trw_layer_add_route ( vtl, name, tr );
5897 else
5898 vik_trw_layer_add_track ( vtl, name, tr );
5899
5900 // Bounds of the new track created by the split
5901 vik_track_calculate_bounds ( tr );
5902
5903 trku_udata udata;
5904 udata.trk = tr;
5905 udata.uuid = NULL;
5906
5907 // Also need id of newly created track
5908 gpointer *trkf;
5909 if ( tr->is_route )
5910 trkf = g_hash_table_find ( vtl->routes, (GHRFunc) trw_layer_track_find_uuid, &udata );
5911 else
5912 trkf = g_hash_table_find ( vtl->tracks, (GHRFunc) trw_layer_track_find_uuid, &udata );
5913
5914 if ( trkf && udata.uuid )
5915 vtl->current_tp_id = udata.uuid;
5916 else
5917 vtl->current_tp_id = NULL;
5918
5919 vik_layer_emit_update(VIK_LAYER(vtl));
5920 }
5921 g_free ( name );
5922 }
5923}
5924
5925/* split by time routine */
5926static void trw_layer_split_by_timestamp ( gpointer pass_along[6] )
5927{
5928 VikTrwLayer *vtl = (VikTrwLayer *)pass_along[0];
5929 VikTrack *track = (VikTrack *) g_hash_table_lookup ( vtl->tracks, pass_along[3] );
5930 GList *trps = track->trackpoints;
5931 GList *iter;
5932 GList *newlists = NULL;
5933 GList *newtps = NULL;
5934 static guint thr = 1;
5935
5936 time_t ts, prev_ts;
5937
5938 if ( !trps )
5939 return;
5940
5941 if (!a_dialog_time_threshold(VIK_GTK_WINDOW_FROM_LAYER(pass_along[0]),
5942 _("Split Threshold..."),
5943 _("Split when time between trackpoints exceeds:"),
5944 &thr)) {
5945 return;
5946 }
5947
5948 /* iterate through trackpoints, and copy them into new lists without touching original list */
5949 prev_ts = VIK_TRACKPOINT(trps->data)->timestamp;
5950 iter = trps;
5951
5952 while (iter) {
5953 ts = VIK_TRACKPOINT(iter->data)->timestamp;
5954
5955 // Check for unordered time points - this is quite a rare occurence - unless one has reversed a track.
5956 if (ts < prev_ts) {
5957 gchar tmp_str[64];
5958 strftime ( tmp_str, sizeof(tmp_str), "%c", localtime(&ts) );
5959 if ( a_dialog_yes_or_no ( VIK_GTK_WINDOW_FROM_LAYER(vtl),
5960 _("Can not split track due to trackpoints not ordered in time - such as at %s.\n\nGoto this trackpoint?"),
5961 tmp_str ) ) {
5962 goto_coord ( pass_along[1], vtl, pass_along[5], &(VIK_TRACKPOINT(iter->data)->coord) );
5963 }
5964 return;
5965 }
5966
5967 if (ts - prev_ts > thr*60) {
5968 /* flush accumulated trackpoints into new list */
5969 newlists = g_list_append(newlists, g_list_reverse(newtps));
5970 newtps = NULL;
5971 }
5972
5973 /* accumulate trackpoint copies in newtps, in reverse order */
5974 newtps = g_list_prepend(newtps, vik_trackpoint_copy(VIK_TRACKPOINT(iter->data)));
5975 prev_ts = ts;
5976 iter = g_list_next(iter);
5977 }
5978 if (newtps) {
5979 newlists = g_list_append(newlists, g_list_reverse(newtps));
5980 }
5981
5982 /* put lists of trackpoints into tracks */
5983 iter = newlists;
5984 // Only bother updating if the split results in new tracks
5985 if (g_list_length (newlists) > 1) {
5986 while (iter) {
5987 gchar *new_tr_name;
5988 VikTrack *tr;
5989
5990 tr = vik_track_copy ( track, FALSE );
5991 tr->trackpoints = (GList *)(iter->data);
5992
5993 new_tr_name = trw_layer_new_unique_sublayer_name ( vtl, VIK_TRW_LAYER_SUBLAYER_TRACK, track->name);
5994 vik_trw_layer_add_track(vtl, new_tr_name, tr);
5995 /* g_print("adding track %s, times %d - %d\n", new_tr_name, VIK_TRACKPOINT(tr->trackpoints->data)->timestamp,
5996 VIK_TRACKPOINT(g_list_last(tr->trackpoints)->data)->timestamp);*/
5997 g_free ( new_tr_name );
5998 vik_track_calculate_bounds ( tr );
5999 iter = g_list_next(iter);
6000 }
6001 // Remove original track and then update the display
6002 vik_trw_layer_delete_track (vtl, track);
6003 vik_layer_emit_update(VIK_LAYER(pass_along[0]));
6004 }
6005 g_list_free(newlists);
6006}
6007
6008/**
6009 * Split a track by the number of points as specified by the user
6010 */
6011static void trw_layer_split_by_n_points ( gpointer pass_along[6] )
6012{
6013 VikTrwLayer *vtl = (VikTrwLayer *)pass_along[0];
6014 VikTrack *track;
6015 if ( GPOINTER_TO_INT (pass_along[2]) == VIK_TRW_LAYER_SUBLAYER_ROUTE )
6016 track = (VikTrack *) g_hash_table_lookup ( vtl->routes, pass_along[3] );
6017 else
6018 track = (VikTrack *) g_hash_table_lookup ( vtl->tracks, pass_along[3] );
6019
6020 if ( !track )
6021 return;
6022
6023 // Check valid track
6024 GList *trps = track->trackpoints;
6025 if ( !trps )
6026 return;
6027
6028 gint points = a_dialog_get_positive_number(VIK_GTK_WINDOW_FROM_LAYER(pass_along[0]),
6029 _("Split Every Nth Point"),
6030 _("Split on every Nth point:"),
6031 250, // Default value as per typical limited track capacity of various GPS devices
6032 2, // Min
6033 65536, // Max
6034 5); // Step
6035 // Was a valid number returned?
6036 if (!points)
6037 return;
6038
6039 // Now split...
6040 GList *iter;
6041 GList *newlists = NULL;
6042 GList *newtps = NULL;
6043 gint count = 0;
6044 iter = trps;
6045
6046 while (iter) {
6047 /* accumulate trackpoint copies in newtps, in reverse order */
6048 newtps = g_list_prepend(newtps, vik_trackpoint_copy(VIK_TRACKPOINT(iter->data)));
6049 count++;
6050 if (count >= points) {
6051 /* flush accumulated trackpoints into new list */
6052 newlists = g_list_append(newlists, g_list_reverse(newtps));
6053 newtps = NULL;
6054 count = 0;
6055 }
6056 iter = g_list_next(iter);
6057 }
6058
6059 // If there is a remaining chunk put that into the new split list
6060 // This may well be the whole track if no split points were encountered
6061 if (newtps) {
6062 newlists = g_list_append(newlists, g_list_reverse(newtps));
6063 }
6064
6065 /* put lists of trackpoints into tracks */
6066 iter = newlists;
6067 // Only bother updating if the split results in new tracks
6068 if (g_list_length (newlists) > 1) {
6069 while (iter) {
6070 gchar *new_tr_name;
6071 VikTrack *tr;
6072
6073 tr = vik_track_copy ( track, FALSE );
6074 tr->trackpoints = (GList *)(iter->data);
6075
6076 if ( track->is_route ) {
6077 new_tr_name = trw_layer_new_unique_sublayer_name ( vtl, VIK_TRW_LAYER_SUBLAYER_ROUTE, track->name);
6078 vik_trw_layer_add_route(vtl, new_tr_name, tr);
6079 }
6080 else {
6081 new_tr_name = trw_layer_new_unique_sublayer_name ( vtl, VIK_TRW_LAYER_SUBLAYER_TRACK, track->name);
6082 vik_trw_layer_add_track(vtl, new_tr_name, tr);
6083 }
6084 g_free ( new_tr_name );
6085 vik_track_calculate_bounds ( tr );
6086
6087 iter = g_list_next(iter);
6088 }
6089 // Remove original track and then update the display
6090 if ( track->is_route )
6091 vik_trw_layer_delete_route (vtl, track);
6092 else
6093 vik_trw_layer_delete_track (vtl, track);
6094 vik_layer_emit_update(VIK_LAYER(pass_along[0]));
6095 }
6096 g_list_free(newlists);
6097}
6098
6099/**
6100 * Split a track at the currently selected trackpoint
6101 */
6102static void trw_layer_split_at_trackpoint ( gpointer pass_along[6] )
6103{
6104 VikTrwLayer *vtl = (VikTrwLayer *)pass_along[0];
6105 gint subtype = GPOINTER_TO_INT (pass_along[2]);
6106 trw_layer_split_at_selected_trackpoint ( vtl, subtype );
6107}
6108
6109/**
6110 * Split a track by its segments
6111 * Routes do not have segments so don't call this for routes
6112 */
6113static void trw_layer_split_segments ( gpointer pass_along[6] )
6114{
6115 VikTrwLayer *vtl = (VikTrwLayer *)pass_along[0];
6116 VikTrack *trk = g_hash_table_lookup ( vtl->tracks, pass_along[3] );
6117
6118 if ( !trk )
6119 return;
6120
6121 guint ntracks;
6122
6123 VikTrack **tracks = vik_track_split_into_segments (trk, &ntracks);
6124 gchar *new_tr_name;
6125 guint i;
6126 for ( i = 0; i < ntracks; i++ ) {
6127 if ( tracks[i] ) {
6128 new_tr_name = trw_layer_new_unique_sublayer_name ( vtl, VIK_TRW_LAYER_SUBLAYER_TRACK, trk->name);
6129 vik_trw_layer_add_track ( vtl, new_tr_name, tracks[i] );
6130 g_free ( new_tr_name );
6131 }
6132 }
6133 if ( tracks ) {
6134 g_free ( tracks );
6135 // Remove original track
6136 vik_trw_layer_delete_track ( vtl, trk );
6137 vik_layer_emit_update ( VIK_LAYER(vtl) );
6138 }
6139 else {
6140 a_dialog_error_msg (VIK_GTK_WINDOW_FROM_LAYER(vtl), _("Can not split track as it has no segments"));
6141 }
6142}
6143/* end of split/merge routines */
6144
6145static void trw_layer_trackpoint_selected_delete ( VikTrwLayer *vtl, VikTrack *trk )
6146{
6147 GList *new_tpl;
6148
6149 // Find available adjacent trackpoint
6150 if ( (new_tpl = vtl->current_tpl->next) || (new_tpl = vtl->current_tpl->prev) ) {
6151 if ( VIK_TRACKPOINT(vtl->current_tpl->data)->newsegment && vtl->current_tpl->next )
6152 VIK_TRACKPOINT(vtl->current_tpl->next->data)->newsegment = TRUE; /* don't concat segments on del */
6153
6154 // Delete current trackpoint
6155 vik_trackpoint_free ( vtl->current_tpl->data );
6156 trk->trackpoints = g_list_delete_link ( trk->trackpoints, vtl->current_tpl );
6157
6158 // Set to current to the available adjacent trackpoint
6159 vtl->current_tpl = new_tpl;
6160
6161 if ( vtl->current_tp_track ) {
6162 vik_track_calculate_bounds ( vtl->current_tp_track );
6163 }
6164 }
6165 else {
6166 // Delete current trackpoint
6167 vik_trackpoint_free ( vtl->current_tpl->data );
6168 trk->trackpoints = g_list_delete_link ( trk->trackpoints, vtl->current_tpl );
6169 trw_layer_cancel_current_tp ( vtl, FALSE );
6170 }
6171}
6172
6173/**
6174 * Delete the selected point
6175 */
6176static void trw_layer_delete_point_selected ( gpointer pass_along[6] )
6177{
6178 VikTrwLayer *vtl = (VikTrwLayer *)pass_along[0];
6179 VikTrack *trk;
6180 if ( GPOINTER_TO_INT (pass_along[2]) == VIK_TRW_LAYER_SUBLAYER_ROUTE )
6181 trk = (VikTrack *) g_hash_table_lookup ( vtl->routes, pass_along[3] );
6182 else
6183 trk = (VikTrack *) g_hash_table_lookup ( vtl->tracks, pass_along[3] );
6184
6185 if ( !trk )
6186 return;
6187
6188 if ( !vtl->current_tpl )
6189 return;
6190
6191 trw_layer_trackpoint_selected_delete ( vtl, trk );
6192
6193 // Track has been updated so update tps:
6194 trw_layer_cancel_tps_of_track ( vtl, trk );
6195
6196 vik_layer_emit_update ( VIK_LAYER(vtl) );
6197}
6198
6199/**
6200 * Delete adjacent track points at the same position
6201 * AKA Delete Dulplicates on the Properties Window
6202 */
6203static void trw_layer_delete_points_same_position ( gpointer pass_along[6] )
6204{
6205 VikTrwLayer *vtl = (VikTrwLayer *)pass_along[0];
6206 VikTrack *trk;
6207 if ( GPOINTER_TO_INT (pass_along[2]) == VIK_TRW_LAYER_SUBLAYER_ROUTE )
6208 trk = (VikTrack *) g_hash_table_lookup ( vtl->routes, pass_along[3] );
6209 else
6210 trk = (VikTrack *) g_hash_table_lookup ( vtl->tracks, pass_along[3] );
6211
6212 if ( !trk )
6213 return;
6214
6215 gulong removed = vik_track_remove_dup_points ( trk );
6216
6217 // Track has been updated so update tps:
6218 trw_layer_cancel_tps_of_track ( vtl, trk );
6219
6220 // Inform user how much was deleted as it's not obvious from the normal view
6221 gchar str[64];
6222 const gchar *tmp_str = ngettext("Deleted %ld point", "Deleted %ld points", removed);
6223 g_snprintf(str, 64, tmp_str, removed);
6224 a_dialog_info_msg (VIK_GTK_WINDOW_FROM_LAYER(vtl), str);
6225
6226 vik_layer_emit_update ( VIK_LAYER(vtl) );
6227}
6228
6229/**
6230 * Delete adjacent track points with the same timestamp
6231 * Normally new tracks that are 'routes' won't have any timestamps so should be OK to clean up the track
6232 */
6233static void trw_layer_delete_points_same_time ( gpointer pass_along[6] )
6234{
6235 VikTrwLayer *vtl = (VikTrwLayer *)pass_along[0];
6236 VikTrack *trk;
6237 if ( GPOINTER_TO_INT (pass_along[2]) == VIK_TRW_LAYER_SUBLAYER_ROUTE )
6238 trk = (VikTrack *) g_hash_table_lookup ( vtl->routes, pass_along[3] );
6239 else
6240 trk = (VikTrack *) g_hash_table_lookup ( vtl->tracks, pass_along[3] );
6241
6242 if ( !trk )
6243 return;
6244
6245 gulong removed = vik_track_remove_same_time_points ( trk );
6246
6247 // Track has been updated so update tps:
6248 trw_layer_cancel_tps_of_track ( vtl, trk );
6249
6250 // Inform user how much was deleted as it's not obvious from the normal view
6251 gchar str[64];
6252 const gchar *tmp_str = ngettext("Deleted %ld point", "Deleted %ld points", removed);
6253 g_snprintf(str, 64, tmp_str, removed);
6254 a_dialog_info_msg (VIK_GTK_WINDOW_FROM_LAYER(vtl), str);
6255
6256 vik_layer_emit_update ( VIK_LAYER(vtl) );
6257}
6258
6259/**
6260 * Insert a point
6261 */
6262static void trw_layer_insert_point_after ( gpointer pass_along[6] )
6263{
6264 VikTrwLayer *vtl = (VikTrwLayer *)pass_along[0];
6265 VikTrack *track;
6266 if ( GPOINTER_TO_INT (pass_along[2]) == VIK_TRW_LAYER_SUBLAYER_ROUTE )
6267 track = (VikTrack *) g_hash_table_lookup ( vtl->routes, pass_along[3] );
6268 else
6269 track = (VikTrack *) g_hash_table_lookup ( vtl->tracks, pass_along[3] );
6270
6271 if ( ! track )
6272 return;
6273
6274 trw_layer_insert_tp_beside_current_tp ( vtl, FALSE );
6275
6276 vik_layer_emit_update ( VIK_LAYER(vtl) );
6277}
6278
6279static void trw_layer_insert_point_before ( gpointer pass_along[6] )
6280{
6281 VikTrwLayer *vtl = (VikTrwLayer *)pass_along[0];
6282 VikTrack *track;
6283 if ( GPOINTER_TO_INT (pass_along[2]) == VIK_TRW_LAYER_SUBLAYER_ROUTE )
6284 track = (VikTrack *) g_hash_table_lookup ( vtl->routes, pass_along[3] );
6285 else
6286 track = (VikTrack *) g_hash_table_lookup ( vtl->tracks, pass_along[3] );
6287
6288 if ( ! track )
6289 return;
6290
6291 trw_layer_insert_tp_beside_current_tp ( vtl, TRUE );
6292
6293 vik_layer_emit_update ( VIK_LAYER(vtl) );
6294}
6295
6296/**
6297 * Reverse a track
6298 */
6299static void trw_layer_reverse ( gpointer pass_along[6] )
6300{
6301 VikTrwLayer *vtl = (VikTrwLayer *)pass_along[0];
6302 VikTrack *track;
6303 if ( GPOINTER_TO_INT (pass_along[2]) == VIK_TRW_LAYER_SUBLAYER_ROUTE )
6304 track = (VikTrack *) g_hash_table_lookup ( vtl->routes, pass_along[3] );
6305 else
6306 track = (VikTrack *) g_hash_table_lookup ( vtl->tracks, pass_along[3] );
6307
6308 if ( ! track )
6309 return;
6310
6311 vik_track_reverse ( track );
6312
6313 vik_layer_emit_update ( VIK_LAYER(pass_along[0]) );
6314}
6315
6316/**
6317 * Similar to trw_layer_enum_item, but this uses a sorted method
6318 */
6319/* Currently unused
6320static void trw_layer_sorted_name_list(gpointer key, gpointer value, gpointer udata)
6321{
6322 GList **list = (GList**)udata;
6323 // *list = g_list_prepend(*all, key); //unsorted method
6324 // Sort named list alphabetically
6325 *list = g_list_insert_sorted_with_data (*list, key, sort_alphabetically, NULL);
6326}
6327*/
6328
6329/**
6330 * Now Waypoint specific sort
6331 */
6332static void trw_layer_sorted_wp_id_by_name_list (const gpointer id, const VikWaypoint *wp, gpointer udata)
6333{
6334 GList **list = (GList**)udata;
6335 // Sort named list alphabetically
6336 *list = g_list_insert_sorted_with_data (*list, wp->name, sort_alphabetically, NULL);
6337}
6338
6339/**
6340 * Track specific sort
6341 */
6342static void trw_layer_sorted_track_id_by_name_list (const gpointer id, const VikTrack *trk, gpointer udata)
6343{
6344 GList **list = (GList**)udata;
6345 // Sort named list alphabetically
6346 *list = g_list_insert_sorted_with_data (*list, trk->name, sort_alphabetically, NULL);
6347}
6348
6349
6350typedef struct {
6351 gboolean has_same_track_name;
6352 const gchar *same_track_name;
6353} same_track_name_udata;
6354
6355static gint check_tracks_for_same_name ( gconstpointer aa, gconstpointer bb, gpointer udata )
6356{
6357 const gchar* namea = (const gchar*) aa;
6358 const gchar* nameb = (const gchar*) bb;
6359
6360 // the test
6361 gint result = strcmp ( namea, nameb );
6362
6363 if ( result == 0 ) {
6364 // Found two names the same
6365 same_track_name_udata *user_data = udata;
6366 user_data->has_same_track_name = TRUE;
6367 user_data->same_track_name = namea;
6368 }
6369
6370 // Leave ordering the same
6371 return 0;
6372}
6373
6374/**
6375 * Find out if any tracks have the same name in this hash table
6376 */
6377static gboolean trw_layer_has_same_track_names ( GHashTable *ht_tracks )
6378{
6379 // Sort items by name, then compare if any next to each other are the same
6380
6381 GList *track_names = NULL;
6382 g_hash_table_foreach ( ht_tracks, (GHFunc) trw_layer_sorted_track_id_by_name_list, &track_names );
6383
6384 // No tracks
6385 if ( ! track_names )
6386 return FALSE;
6387
6388 same_track_name_udata udata;
6389 udata.has_same_track_name = FALSE;
6390
6391 // Use sort routine to traverse list comparing items
6392 // Don't care how this list ends up ordered ( doesn't actually change ) - care about the returned status
6393 GList *dummy_list = g_list_sort_with_data ( track_names, check_tracks_for_same_name, &udata );
6394 // Still no tracks...
6395 if ( ! dummy_list )
6396 return FALSE;
6397
6398 return udata.has_same_track_name;
6399}
6400
6401/**
6402 * Force unqiue track names for the track table specified
6403 * Note the panel is a required parameter to enable the update of the names displayed
6404 * Specify if on tracks or else on routes
6405 */
6406static void vik_trw_layer_uniquify_tracks ( VikTrwLayer *vtl, VikLayersPanel *vlp, GHashTable *track_table, gboolean ontrack )
6407{
6408 // . Search list for an instance of repeated name
6409 // . get track of this name
6410 // . create new name
6411 // . rename track & update equiv. treeview iter
6412 // . repeat until all different
6413
6414 same_track_name_udata udata;
6415
6416 GList *track_names = NULL;
6417 udata.has_same_track_name = FALSE;
6418 udata.same_track_name = NULL;
6419
6420 g_hash_table_foreach ( track_table, (GHFunc) trw_layer_sorted_track_id_by_name_list, &track_names );
6421
6422 // No tracks
6423 if ( ! track_names )
6424 return;
6425
6426 GList *dummy_list1 = g_list_sort_with_data ( track_names, check_tracks_for_same_name, &udata );
6427
6428 // Still no tracks...
6429 if ( ! dummy_list1 )
6430 return;
6431
6432 while ( udata.has_same_track_name ) {
6433
6434 // Find a track with the same name
6435 VikTrack *trk;
6436 if ( ontrack )
6437 trk = vik_trw_layer_get_track ( vtl, (gpointer) udata.same_track_name );
6438 else
6439 trk = vik_trw_layer_get_route ( vtl, (gpointer) udata.same_track_name );
6440
6441 if ( ! trk ) {
6442 // Broken :(
6443 g_critical("Houston, we've had a problem.");
6444 vik_statusbar_set_message ( vik_window_get_statusbar (VIK_WINDOW(VIK_GTK_WINDOW_FROM_LAYER(vtl))), VIK_STATUSBAR_INFO,
6445 _("Internal Error in vik_trw_layer_uniquify_tracks") );
6446 return;
6447 }
6448
6449 // Rename it
6450 gchar *newname = trw_layer_new_unique_sublayer_name ( vtl, VIK_TRW_LAYER_SUBLAYER_TRACK, udata.same_track_name );
6451 vik_track_set_name ( trk, newname );
6452
6453 trku_udata udataU;
6454 udataU.trk = trk;
6455 udataU.uuid = NULL;
6456
6457 // Need want key of it for treeview update
6458 gpointer *trkf = g_hash_table_find ( track_table, (GHRFunc) trw_layer_track_find_uuid, &udataU );
6459
6460 if ( trkf && udataU.uuid ) {
6461
6462 GtkTreeIter *it;
6463 if ( ontrack )
6464 it = g_hash_table_lookup ( vtl->tracks_iters, udataU.uuid );
6465 else
6466 it = g_hash_table_lookup ( vtl->routes_iters, udataU.uuid );
6467
6468 if ( it ) {
6469 vik_treeview_item_set_name ( VIK_LAYER(vtl)->vt, it, newname );
6470 if ( ontrack )
6471 vik_treeview_sort_children ( VIK_LAYER(vtl)->vt, &(vtl->tracks_iter), vtl->wp_sort_order );
6472 else
6473 vik_treeview_sort_children ( VIK_LAYER(vtl)->vt, &(vtl->routes_iter), vtl->wp_sort_order );
6474 }
6475 }
6476
6477 // Start trying to find same names again...
6478 track_names = NULL;
6479 g_hash_table_foreach ( track_table, (GHFunc) trw_layer_sorted_track_id_by_name_list, &track_names );
6480 udata.has_same_track_name = FALSE;
6481 GList *dummy_list2 = g_list_sort_with_data ( track_names, check_tracks_for_same_name, &udata );
6482
6483 // No tracks any more - give up searching
6484 if ( ! dummy_list2 )
6485 udata.has_same_track_name = FALSE;
6486 }
6487
6488 // Update
6489 vik_layers_panel_emit_update ( vlp );
6490}
6491
6492static void trw_layer_sort_order_a2z ( gpointer pass_along[6] )
6493{
6494 VikTrwLayer *vtl = VIK_TRW_LAYER(pass_along[0]);
6495 GtkTreeIter *iter;
6496
6497 switch (GPOINTER_TO_INT (pass_along[2])) {
6498 case VIK_TRW_LAYER_SUBLAYER_TRACKS:
6499 iter = &(vtl->tracks_iter);
6500 vtl->track_sort_order = VL_SO_ALPHABETICAL_ASCENDING;
6501 break;
6502 case VIK_TRW_LAYER_SUBLAYER_ROUTES:
6503 iter = &(vtl->routes_iter);
6504 vtl->track_sort_order = VL_SO_ALPHABETICAL_ASCENDING;
6505 break;
6506 default: // VIK_TRW_LAYER_SUBLAYER_WAYPOINTS:
6507 iter = &(vtl->waypoints_iter);
6508 vtl->wp_sort_order = VL_SO_ALPHABETICAL_ASCENDING;
6509 break;
6510 }
6511
6512 vik_treeview_sort_children ( VIK_LAYER(vtl)->vt, iter, VL_SO_ALPHABETICAL_ASCENDING );
6513}
6514
6515static void trw_layer_sort_order_z2a ( gpointer pass_along[6] )
6516{
6517 VikTrwLayer *vtl = VIK_TRW_LAYER(pass_along[0]);
6518 GtkTreeIter *iter;
6519
6520 switch (GPOINTER_TO_INT (pass_along[2])) {
6521 case VIK_TRW_LAYER_SUBLAYER_TRACKS:
6522 iter = &(vtl->tracks_iter);
6523 vtl->track_sort_order = VL_SO_ALPHABETICAL_DESCENDING;
6524 break;
6525 case VIK_TRW_LAYER_SUBLAYER_ROUTES:
6526 iter = &(vtl->routes_iter);
6527 vtl->track_sort_order = VL_SO_ALPHABETICAL_DESCENDING;
6528 break;
6529 default: // VIK_TRW_LAYER_SUBLAYER_WAYPOINTS:
6530 iter = &(vtl->waypoints_iter);
6531 vtl->wp_sort_order = VL_SO_ALPHABETICAL_DESCENDING;
6532 break;
6533 }
6534
6535 vik_treeview_sort_children ( VIK_LAYER(vtl)->vt, iter, VL_SO_ALPHABETICAL_DESCENDING );
6536}
6537
6538/**
6539 *
6540 */
6541static void trw_layer_delete_tracks_from_selection ( gpointer lav[2] )
6542{
6543 VikTrwLayer *vtl = VIK_TRW_LAYER(lav[0]);
6544 GList *all = NULL;
6545
6546 // Ensure list of track names offered is unique
6547 if ( trw_layer_has_same_track_names ( vtl->tracks ) ) {
6548 if ( a_dialog_yes_or_no ( VIK_GTK_WINDOW_FROM_LAYER(vtl),
6549 _("Multiple entries with the same name exist. This method only works with unique names. Force unique names now?"), NULL ) ) {
6550 vik_trw_layer_uniquify_tracks ( vtl, VIK_LAYERS_PANEL(lav[1]), vtl->tracks, TRUE );
6551 }
6552 else
6553 return;
6554 }
6555
6556 // Sort list alphabetically for better presentation
6557 g_hash_table_foreach(vtl->tracks, (GHFunc) trw_layer_sorted_track_id_by_name_list, &all);
6558
6559 if ( ! all ) {
6560 a_dialog_error_msg (VIK_GTK_WINDOW_FROM_LAYER(vtl), _("No tracks found"));
6561 return;
6562 }
6563
6564 // Get list of items to delete from the user
6565 GList *delete_list = a_dialog_select_from_list(VIK_GTK_WINDOW_FROM_LAYER(vtl),
6566 all,
6567 TRUE,
6568 _("Delete Selection"),
6569 _("Select tracks to delete"));
6570 g_list_free(all);
6571
6572 // Delete requested tracks
6573 // since specificly requested, IMHO no need for extra confirmation
6574 if ( delete_list ) {
6575 GList *l;
6576 for (l = delete_list; l != NULL; l = g_list_next(l)) {
6577 // This deletes first trk it finds of that name (but uniqueness is enforced above)
6578 trw_layer_delete_track_by_name (vtl, l->data, vtl->tracks);
6579 }
6580 g_list_free(delete_list);
6581 vik_layer_emit_update( VIK_LAYER(vtl) );
6582 }
6583}
6584
6585/**
6586 *
6587 */
6588static void trw_layer_delete_routes_from_selection ( gpointer lav[2] )
6589{
6590 VikTrwLayer *vtl = VIK_TRW_LAYER(lav[0]);
6591 GList *all = NULL;
6592
6593 // Ensure list of track names offered is unique
6594 if ( trw_layer_has_same_track_names ( vtl->routes ) ) {
6595 if ( a_dialog_yes_or_no ( VIK_GTK_WINDOW_FROM_LAYER(vtl),
6596 _("Multiple entries with the same name exist. This method only works with unique names. Force unique names now?"), NULL ) ) {
6597 vik_trw_layer_uniquify_tracks ( vtl, VIK_LAYERS_PANEL(lav[1]), vtl->routes, FALSE );
6598 }
6599 else
6600 return;
6601 }
6602
6603 // Sort list alphabetically for better presentation
6604 g_hash_table_foreach(vtl->routes, (GHFunc) trw_layer_sorted_track_id_by_name_list, &all);
6605
6606 if ( ! all ) {
6607 a_dialog_error_msg (VIK_GTK_WINDOW_FROM_LAYER(vtl), _("No routes found"));
6608 return;
6609 }
6610
6611 // Get list of items to delete from the user
6612 GList *delete_list = a_dialog_select_from_list ( VIK_GTK_WINDOW_FROM_LAYER(vtl),
6613 all,
6614 TRUE,
6615 _("Delete Selection"),
6616 _("Select routes to delete") );
6617 g_list_free(all);
6618
6619 // Delete requested routes
6620 // since specificly requested, IMHO no need for extra confirmation
6621 if ( delete_list ) {
6622 GList *l;
6623 for (l = delete_list; l != NULL; l = g_list_next(l)) {
6624 // This deletes first route it finds of that name (but uniqueness is enforced above)
6625 trw_layer_delete_track_by_name (vtl, l->data, vtl->routes);
6626 }
6627 g_list_free(delete_list);
6628 vik_layer_emit_update( VIK_LAYER(vtl) );
6629 }
6630}
6631
6632typedef struct {
6633 gboolean has_same_waypoint_name;
6634 const gchar *same_waypoint_name;
6635} same_waypoint_name_udata;
6636
6637static gint check_waypoints_for_same_name ( gconstpointer aa, gconstpointer bb, gpointer udata )
6638{
6639 const gchar* namea = (const gchar*) aa;
6640 const gchar* nameb = (const gchar*) bb;
6641
6642 // the test
6643 gint result = strcmp ( namea, nameb );
6644
6645 if ( result == 0 ) {
6646 // Found two names the same
6647 same_waypoint_name_udata *user_data = udata;
6648 user_data->has_same_waypoint_name = TRUE;
6649 user_data->same_waypoint_name = namea;
6650 }
6651
6652 // Leave ordering the same
6653 return 0;
6654}
6655
6656/**
6657 * Find out if any waypoints have the same name in this layer
6658 */
6659gboolean trw_layer_has_same_waypoint_names ( VikTrwLayer *vtl )
6660{
6661 // Sort items by name, then compare if any next to each other are the same
6662
6663 GList *waypoint_names = NULL;
6664 g_hash_table_foreach ( vtl->waypoints, (GHFunc) trw_layer_sorted_wp_id_by_name_list, &waypoint_names );
6665
6666 // No waypoints
6667 if ( ! waypoint_names )
6668 return FALSE;
6669
6670 same_waypoint_name_udata udata;
6671 udata.has_same_waypoint_name = FALSE;
6672
6673 // Use sort routine to traverse list comparing items
6674 // Don't care how this list ends up ordered ( doesn't actually change ) - care about the returned status
6675 GList *dummy_list = g_list_sort_with_data ( waypoint_names, check_waypoints_for_same_name, &udata );
6676 // Still no waypoints...
6677 if ( ! dummy_list )
6678 return FALSE;
6679
6680 return udata.has_same_waypoint_name;
6681}
6682
6683/**
6684 * Force unqiue waypoint names for this layer
6685 * Note the panel is a required parameter to enable the update of the names displayed
6686 */
6687static void vik_trw_layer_uniquify_waypoints ( VikTrwLayer *vtl, VikLayersPanel *vlp )
6688{
6689 // . Search list for an instance of repeated name
6690 // . get waypoint of this name
6691 // . create new name
6692 // . rename waypoint & update equiv. treeview iter
6693 // . repeat until all different
6694
6695 same_waypoint_name_udata udata;
6696
6697 GList *waypoint_names = NULL;
6698 udata.has_same_waypoint_name = FALSE;
6699 udata.same_waypoint_name = NULL;
6700
6701 g_hash_table_foreach ( vtl->waypoints, (GHFunc) trw_layer_sorted_wp_id_by_name_list, &waypoint_names );
6702
6703 // No waypoints
6704 if ( ! waypoint_names )
6705 return;
6706
6707 GList *dummy_list1 = g_list_sort_with_data ( waypoint_names, check_waypoints_for_same_name, &udata );
6708
6709 // Still no waypoints...
6710 if ( ! dummy_list1 )
6711 return;
6712
6713 while ( udata.has_same_waypoint_name ) {
6714
6715 // Find a waypoint with the same name
6716 VikWaypoint *waypoint = vik_trw_layer_get_waypoint ( vtl, (gpointer) udata.same_waypoint_name );
6717
6718 if ( ! waypoint ) {
6719 // Broken :(
6720 g_critical("Houston, we've had a problem.");
6721 vik_statusbar_set_message ( vik_window_get_statusbar (VIK_WINDOW(VIK_GTK_WINDOW_FROM_LAYER(vtl))), VIK_STATUSBAR_INFO,
6722 _("Internal Error in vik_trw_layer_uniquify_waypoints") );
6723 return;
6724 }
6725
6726 // Rename it
6727 gchar *newname = trw_layer_new_unique_sublayer_name ( vtl, VIK_TRW_LAYER_SUBLAYER_WAYPOINT, udata.same_waypoint_name );
6728
6729 trw_layer_waypoint_rename ( vtl, waypoint, newname );
6730
6731 // Start trying to find same names again...
6732 waypoint_names = NULL;
6733 g_hash_table_foreach ( vtl->waypoints, (GHFunc) trw_layer_sorted_wp_id_by_name_list, &waypoint_names );
6734 udata.has_same_waypoint_name = FALSE;
6735 GList *dummy_list2 = g_list_sort_with_data ( waypoint_names, check_waypoints_for_same_name, &udata );
6736
6737 // No waypoints any more - give up searching
6738 if ( ! dummy_list2 )
6739 udata.has_same_waypoint_name = FALSE;
6740 }
6741
6742 // Update
6743 vik_layers_panel_emit_update ( vlp );
6744}
6745
6746/**
6747 *
6748 */
6749static void trw_layer_delete_waypoints_from_selection ( gpointer lav[2] )
6750{
6751 VikTrwLayer *vtl = VIK_TRW_LAYER(lav[0]);
6752 GList *all = NULL;
6753
6754 // Ensure list of waypoint names offered is unique
6755 if ( trw_layer_has_same_waypoint_names ( vtl ) ) {
6756 if ( a_dialog_yes_or_no ( VIK_GTK_WINDOW_FROM_LAYER(vtl),
6757 _("Multiple entries with the same name exist. This method only works with unique names. Force unique names now?"), NULL ) ) {
6758 vik_trw_layer_uniquify_waypoints ( vtl, VIK_LAYERS_PANEL(lav[1]) );
6759 }
6760 else
6761 return;
6762 }
6763
6764 // Sort list alphabetically for better presentation
6765 g_hash_table_foreach ( vtl->waypoints, (GHFunc) trw_layer_sorted_wp_id_by_name_list, &all);
6766 if ( ! all ) {
6767 a_dialog_error_msg (VIK_GTK_WINDOW_FROM_LAYER(vtl), _("No waypoints found"));
6768 return;
6769 }
6770
6771 all = g_list_sort_with_data(all, sort_alphabetically, NULL);
6772
6773 // Get list of items to delete from the user
6774 GList *delete_list = a_dialog_select_from_list(VIK_GTK_WINDOW_FROM_LAYER(vtl),
6775 all,
6776 TRUE,
6777 _("Delete Selection"),
6778 _("Select waypoints to delete"));
6779 g_list_free(all);
6780
6781 // Delete requested waypoints
6782 // since specificly requested, IMHO no need for extra confirmation
6783 if ( delete_list ) {
6784 GList *l;
6785 for (l = delete_list; l != NULL; l = g_list_next(l)) {
6786 // This deletes first waypoint it finds of that name (but uniqueness is enforced above)
6787 trw_layer_delete_waypoint_by_name (vtl, l->data);
6788 }
6789 g_list_free(delete_list);
6790
6791 trw_layer_calculate_bounds_waypoints ( vtl );
6792 vik_layer_emit_update( VIK_LAYER(vtl) );
6793 }
6794
6795}
6796
6797/**
6798 *
6799 */
6800static void trw_layer_iter_visibility_toggle ( gpointer id, GtkTreeIter *it, VikTreeview *vt )
6801{
6802 vik_treeview_item_toggle_visible ( vt, it );
6803}
6804
6805/**
6806 *
6807 */
6808static void trw_layer_iter_visibility ( gpointer id, GtkTreeIter *it, gpointer vis_data[2] )
6809{
6810 vik_treeview_item_set_visible ( (VikTreeview*)vis_data[0], it, GPOINTER_TO_INT (vis_data[1]) );
6811}
6812
6813/**
6814 *
6815 */
6816static void trw_layer_waypoints_visibility ( gpointer id, VikWaypoint *wp, gpointer on_off )
6817{
6818 wp->visible = GPOINTER_TO_INT (on_off);
6819}
6820
6821/**
6822 *
6823 */
6824static void trw_layer_waypoints_toggle_visibility ( gpointer id, VikWaypoint *wp )
6825{
6826 wp->visible = !wp->visible;
6827}
6828
6829/**
6830 *
6831 */
6832static void trw_layer_waypoints_visibility_off ( gpointer lav[2] )
6833{
6834 VikTrwLayer *vtl = VIK_TRW_LAYER(lav[0]);
6835 gpointer vis_data[2] = { VIK_LAYER(vtl)->vt, GINT_TO_POINTER(FALSE) };
6836 g_hash_table_foreach ( vtl->waypoints_iters, (GHFunc) trw_layer_iter_visibility, vis_data );
6837 g_hash_table_foreach ( vtl->waypoints, (GHFunc) trw_layer_waypoints_visibility, vis_data[1] );
6838 // Redraw
6839 vik_layer_emit_update ( VIK_LAYER(vtl) );
6840}
6841
6842/**
6843 *
6844 */
6845static void trw_layer_waypoints_visibility_on ( gpointer lav[2] )
6846{
6847 VikTrwLayer *vtl = VIK_TRW_LAYER(lav[0]);
6848 gpointer vis_data[2] = { VIK_LAYER(vtl)->vt, GINT_TO_POINTER(TRUE) };
6849 g_hash_table_foreach ( vtl->waypoints_iters, (GHFunc) trw_layer_iter_visibility, vis_data );
6850 g_hash_table_foreach ( vtl->waypoints, (GHFunc) trw_layer_waypoints_visibility, vis_data[1] );
6851 // Redraw
6852 vik_layer_emit_update ( VIK_LAYER(vtl) );
6853}
6854
6855/**
6856 *
6857 */
6858static void trw_layer_waypoints_visibility_toggle ( gpointer lav[2] )
6859{
6860 VikTrwLayer *vtl = VIK_TRW_LAYER(lav[0]);
6861 g_hash_table_foreach ( vtl->waypoints_iters, (GHFunc) trw_layer_iter_visibility_toggle, VIK_LAYER(vtl)->vt );
6862 g_hash_table_foreach ( vtl->waypoints, (GHFunc) trw_layer_waypoints_toggle_visibility, NULL );
6863 // Redraw
6864 vik_layer_emit_update ( VIK_LAYER(vtl) );
6865}
6866
6867/**
6868 *
6869 */
6870static void trw_layer_tracks_visibility ( gpointer id, VikTrack *trk, gpointer on_off )
6871{
6872 trk->visible = GPOINTER_TO_INT (on_off);
6873}
6874
6875/**
6876 *
6877 */
6878static void trw_layer_tracks_toggle_visibility ( gpointer id, VikTrack *trk )
6879{
6880 trk->visible = !trk->visible;
6881}
6882
6883/**
6884 *
6885 */
6886static void trw_layer_tracks_visibility_off ( gpointer lav[2] )
6887{
6888 VikTrwLayer *vtl = VIK_TRW_LAYER(lav[0]);
6889 gpointer vis_data[2] = { VIK_LAYER(vtl)->vt, GINT_TO_POINTER(FALSE) };
6890 g_hash_table_foreach ( vtl->tracks_iters, (GHFunc) trw_layer_iter_visibility, vis_data );
6891 g_hash_table_foreach ( vtl->tracks, (GHFunc) trw_layer_tracks_visibility, vis_data[1] );
6892 // Redraw
6893 vik_layer_emit_update ( VIK_LAYER(vtl) );
6894}
6895
6896/**
6897 *
6898 */
6899static void trw_layer_tracks_visibility_on ( gpointer lav[2] )
6900{
6901 VikTrwLayer *vtl = VIK_TRW_LAYER(lav[0]);
6902 gpointer vis_data[2] = { VIK_LAYER(vtl)->vt, GINT_TO_POINTER(TRUE) };
6903 g_hash_table_foreach ( vtl->tracks_iters, (GHFunc) trw_layer_iter_visibility, vis_data );
6904 g_hash_table_foreach ( vtl->tracks, (GHFunc) trw_layer_tracks_visibility, vis_data[1] );
6905 // Redraw
6906 vik_layer_emit_update ( VIK_LAYER(vtl) );
6907}
6908
6909/**
6910 *
6911 */
6912static void trw_layer_tracks_visibility_toggle ( gpointer lav[2] )
6913{
6914 VikTrwLayer *vtl = VIK_TRW_LAYER(lav[0]);
6915 g_hash_table_foreach ( vtl->tracks_iters, (GHFunc) trw_layer_iter_visibility_toggle, VIK_LAYER(vtl)->vt );
6916 g_hash_table_foreach ( vtl->tracks, (GHFunc) trw_layer_tracks_toggle_visibility, NULL );
6917 // Redraw
6918 vik_layer_emit_update ( VIK_LAYER(vtl) );
6919}
6920
6921/**
6922 *
6923 */
6924static void trw_layer_routes_visibility_off ( gpointer lav[2] )
6925{
6926 VikTrwLayer *vtl = VIK_TRW_LAYER(lav[0]);
6927 gpointer vis_data[2] = { VIK_LAYER(vtl)->vt, GINT_TO_POINTER(FALSE) };
6928 g_hash_table_foreach ( vtl->routes_iters, (GHFunc) trw_layer_iter_visibility, vis_data );
6929 g_hash_table_foreach ( vtl->routes, (GHFunc) trw_layer_tracks_visibility, vis_data[1] );
6930 // Redraw
6931 vik_layer_emit_update ( VIK_LAYER(vtl) );
6932}
6933
6934/**
6935 *
6936 */
6937static void trw_layer_routes_visibility_on ( gpointer lav[2] )
6938{
6939 VikTrwLayer *vtl = VIK_TRW_LAYER(lav[0]);
6940 gpointer vis_data[2] = { VIK_LAYER(vtl)->vt, GINT_TO_POINTER(TRUE) };
6941 g_hash_table_foreach ( vtl->routes_iters, (GHFunc) trw_layer_iter_visibility, vis_data );
6942 g_hash_table_foreach ( vtl->routes, (GHFunc) trw_layer_tracks_visibility, vis_data[1] );
6943 // Redraw
6944 vik_layer_emit_update ( VIK_LAYER(vtl) );
6945}
6946
6947/**
6948 *
6949 */
6950static void trw_layer_routes_visibility_toggle ( gpointer lav[2] )
6951{
6952 VikTrwLayer *vtl = VIK_TRW_LAYER(lav[0]);
6953 g_hash_table_foreach ( vtl->routes_iters, (GHFunc) trw_layer_iter_visibility_toggle, VIK_LAYER(vtl)->vt );
6954 g_hash_table_foreach ( vtl->routes, (GHFunc) trw_layer_tracks_toggle_visibility, NULL );
6955 // Redraw
6956 vik_layer_emit_update ( VIK_LAYER(vtl) );
6957}
6958
6959/**
6960 * vik_trw_layer_build_waypoint_list_t:
6961 *
6962 * Helper function to construct a list of #vik_trw_waypoint_list_t
6963 */
6964GList *vik_trw_layer_build_waypoint_list_t ( VikTrwLayer *vtl, GList *waypoints )
6965{
6966 GList *waypoints_and_layers = NULL;
6967 // build waypoints_and_layers list
6968 while ( waypoints ) {
6969 vik_trw_waypoint_list_t *vtdl = g_malloc (sizeof(vik_trw_waypoint_list_t));
6970 vtdl->wpt = VIK_WAYPOINT(waypoints->data);
6971 vtdl->vtl = vtl;
6972 waypoints_and_layers = g_list_prepend ( waypoints_and_layers, vtdl );
6973 waypoints = g_list_next ( waypoints );
6974 }
6975 return waypoints_and_layers;
6976}
6977
6978/**
6979 * trw_layer_create_waypoint_list:
6980 *
6981 * Create the latest list of waypoints with the associated layer(s)
6982 * Although this will always be from a single layer here
6983 */
6984static GList* trw_layer_create_waypoint_list ( VikLayer *vl, gpointer user_data )
6985{
6986 VikTrwLayer *vtl = VIK_TRW_LAYER(vl);
6987 GList *waypoints = g_hash_table_get_values ( vik_trw_layer_get_waypoints(vtl) );
6988
6989 return vik_trw_layer_build_waypoint_list_t ( vtl, waypoints );
6990}
6991
6992/**
6993 * trw_layer_analyse_close:
6994 *
6995 * Stuff to do on dialog closure
6996 */
6997static void trw_layer_analyse_close ( GtkWidget *dialog, gint resp, VikLayer* vl )
6998{
6999 VikTrwLayer *vtl = VIK_TRW_LAYER(vl);
7000 gtk_widget_destroy ( dialog );
7001 vtl->tracks_analysis_dialog = NULL;
7002}
7003
7004/**
7005 * vik_trw_layer_build_track_list_t:
7006 *
7007 * Helper function to construct a list of #vik_trw_track_list_t
7008 */
7009GList *vik_trw_layer_build_track_list_t ( VikTrwLayer *vtl, GList *tracks )
7010{
7011 GList *tracks_and_layers = NULL;
7012 // build tracks_and_layers list
7013 while ( tracks ) {
7014 vik_trw_track_list_t *vtdl = g_malloc (sizeof(vik_trw_track_list_t));
7015 vtdl->trk = VIK_TRACK(tracks->data);
7016 vtdl->vtl = vtl;
7017 tracks_and_layers = g_list_prepend ( tracks_and_layers, vtdl );
7018 tracks = g_list_next ( tracks );
7019 }
7020 return tracks_and_layers;
7021}
7022
7023/**
7024 * trw_layer_create_track_list:
7025 *
7026 * Create the latest list of tracks with the associated layer(s)
7027 * Although this will always be from a single layer here
7028 */
7029static GList* trw_layer_create_track_list ( VikLayer *vl, gpointer user_data )
7030{
7031 VikTrwLayer *vtl = VIK_TRW_LAYER(vl);
7032 GList *tracks = NULL;
7033 if ( GPOINTER_TO_INT(user_data) == VIK_TRW_LAYER_SUBLAYER_TRACKS )
7034 tracks = g_hash_table_get_values ( vik_trw_layer_get_tracks(vtl) );
7035 else
7036 tracks = g_hash_table_get_values ( vik_trw_layer_get_routes(vtl) );
7037
7038 return vik_trw_layer_build_track_list_t ( vtl, tracks );
7039}
7040
7041static void trw_layer_tracks_stats ( gpointer lav[2] )
7042{
7043 VikTrwLayer *vtl = VIK_TRW_LAYER(lav[0]);
7044 // There can only be one!
7045 if ( vtl->tracks_analysis_dialog )
7046 return;
7047
7048 vtl->tracks_analysis_dialog = vik_trw_layer_analyse_this ( VIK_GTK_WINDOW_FROM_LAYER(vtl),
7049 VIK_LAYER(vtl)->name,
7050 VIK_LAYER(vtl),
7051 GINT_TO_POINTER(VIK_TRW_LAYER_SUBLAYER_TRACKS),
7052 trw_layer_create_track_list,
7053 trw_layer_analyse_close );
7054}
7055
7056/**
7057 *
7058 */
7059static void trw_layer_routes_stats ( gpointer lav[2] )
7060{
7061 VikTrwLayer *vtl = VIK_TRW_LAYER(lav[0]);
7062 // There can only be one!
7063 if ( vtl->tracks_analysis_dialog )
7064 return;
7065
7066 vtl->tracks_analysis_dialog = vik_trw_layer_analyse_this ( VIK_GTK_WINDOW_FROM_LAYER(vtl),
7067 VIK_LAYER(vtl)->name,
7068 VIK_LAYER(vtl),
7069 GINT_TO_POINTER(VIK_TRW_LAYER_SUBLAYER_ROUTES),
7070 trw_layer_create_track_list,
7071 trw_layer_analyse_close );
7072}
7073
7074static void trw_layer_goto_waypoint ( gpointer pass_along[6] )
7075{
7076 VikWaypoint *wp = g_hash_table_lookup ( VIK_TRW_LAYER(pass_along[0])->waypoints, pass_along[3] );
7077 if ( wp )
7078 goto_coord ( pass_along[1], pass_along[0], pass_along[5], &(wp->coord) );
7079}
7080
7081static void trw_layer_waypoint_gc_webpage ( gpointer pass_along[6] )
7082{
7083 VikWaypoint *wp = g_hash_table_lookup ( VIK_TRW_LAYER(pass_along[0])->waypoints, pass_along[3] );
7084 if ( !wp )
7085 return;
7086 gchar *webpage = g_strdup_printf("http://www.geocaching.com/seek/cache_details.aspx?wp=%s", wp->name );
7087 open_url(VIK_GTK_WINDOW_FROM_LAYER(VIK_LAYER(pass_along[0])), webpage);
7088 g_free ( webpage );
7089}
7090
7091static void trw_layer_waypoint_webpage ( gpointer pass_along[6] )
7092{
7093 VikWaypoint *wp = g_hash_table_lookup ( VIK_TRW_LAYER(pass_along[0])->waypoints, pass_along[3] );
7094 if ( !wp )
7095 return;
7096 if ( !strncmp(wp->comment, "http", 4) ) {
7097 open_url(VIK_GTK_WINDOW_FROM_LAYER(VIK_LAYER(pass_along[0])), wp->comment);
7098 } else if ( !strncmp(wp->description, "http", 4) ) {
7099 open_url(VIK_GTK_WINDOW_FROM_LAYER(VIK_LAYER(pass_along[0])), wp->description);
7100 }
7101}
7102
7103static const gchar* trw_layer_sublayer_rename_request ( VikTrwLayer *l, const gchar *newname, gpointer vlp, gint subtype, gpointer sublayer, GtkTreeIter *iter )
7104{
7105 if ( subtype == VIK_TRW_LAYER_SUBLAYER_WAYPOINT )
7106 {
7107 VikWaypoint *wp = g_hash_table_lookup ( l->waypoints, sublayer );
7108
7109 // No actual change to the name supplied
7110 if ( wp->name )
7111 if (strcmp(newname, wp->name) == 0 )
7112 return NULL;
7113
7114 VikWaypoint *wpf = vik_trw_layer_get_waypoint ( l, newname );
7115
7116 if ( wpf ) {
7117 // An existing waypoint has been found with the requested name
7118 if ( ! a_dialog_yes_or_no ( VIK_GTK_WINDOW_FROM_LAYER(l),
7119 _("A waypoint with the name \"%s\" already exists. Really rename to the same name?"),
7120 newname ) )
7121 return NULL;
7122 }
7123
7124 // Update WP name and refresh the treeview
7125 vik_waypoint_set_name (wp, newname);
7126
7127 vik_treeview_item_set_name ( VIK_LAYER(l)->vt, iter, newname );
7128 vik_treeview_sort_children ( VIK_LAYER(l)->vt, &(l->waypoints_iter), l->wp_sort_order );
7129
7130 vik_layers_panel_emit_update ( VIK_LAYERS_PANEL(vlp) );
7131
7132 return newname;
7133 }
7134
7135 if ( subtype == VIK_TRW_LAYER_SUBLAYER_TRACK )
7136 {
7137 VikTrack *trk = g_hash_table_lookup ( l->tracks, sublayer );
7138
7139 // No actual change to the name supplied
7140 if ( trk->name )
7141 if (strcmp(newname, trk->name) == 0)
7142 return NULL;
7143
7144 VikTrack *trkf = vik_trw_layer_get_track ( l, (gpointer) newname );
7145
7146 if ( trkf ) {
7147 // An existing track has been found with the requested name
7148 if ( ! a_dialog_yes_or_no ( VIK_GTK_WINDOW_FROM_LAYER(l),
7149 _("A track with the name \"%s\" already exists. Really rename to the same name?"),
7150 newname ) )
7151 return NULL;
7152 }
7153 // Update track name and refresh GUI parts
7154 vik_track_set_name (trk, newname);
7155
7156 // Update any subwindows that could be displaying this track which has changed name
7157 // Only one Track Edit Window
7158 if ( l->current_tp_track == trk && l->tpwin ) {
7159 vik_trw_layer_tpwin_set_track_name ( l->tpwin, newname );
7160 }
7161 // Property Dialog of the track
7162 vik_trw_layer_propwin_update ( trk );
7163
7164 vik_treeview_item_set_name ( VIK_LAYER(l)->vt, iter, newname );
7165 vik_treeview_sort_children ( VIK_LAYER(l)->vt, &(l->tracks_iter), l->track_sort_order );
7166
7167 vik_layers_panel_emit_update ( VIK_LAYERS_PANEL(vlp) );
7168
7169 return newname;
7170 }
7171
7172 if ( subtype == VIK_TRW_LAYER_SUBLAYER_ROUTE )
7173 {
7174 VikTrack *trk = g_hash_table_lookup ( l->routes, sublayer );
7175
7176 // No actual change to the name supplied
7177 if ( trk->name )
7178 if (strcmp(newname, trk->name) == 0)
7179 return NULL;
7180
7181 VikTrack *trkf = vik_trw_layer_get_route ( l, (gpointer) newname );
7182
7183 if ( trkf ) {
7184 // An existing track has been found with the requested name
7185 if ( ! a_dialog_yes_or_no ( VIK_GTK_WINDOW_FROM_LAYER(l),
7186 _("A route with the name \"%s\" already exists. Really rename to the same name?"),
7187 newname ) )
7188 return NULL;
7189 }
7190 // Update track name and refresh GUI parts
7191 vik_track_set_name (trk, newname);
7192
7193 // Update any subwindows that could be displaying this track which has changed name
7194 // Only one Track Edit Window
7195 if ( l->current_tp_track == trk && l->tpwin ) {
7196 vik_trw_layer_tpwin_set_track_name ( l->tpwin, newname );
7197 }
7198 // Property Dialog of the track
7199 vik_trw_layer_propwin_update ( trk );
7200
7201 vik_treeview_item_set_name ( VIK_LAYER(l)->vt, iter, newname );
7202 vik_treeview_sort_children ( VIK_LAYER(l)->vt, &(l->tracks_iter), l->track_sort_order );
7203
7204 vik_layers_panel_emit_update ( VIK_LAYERS_PANEL(vlp) );
7205
7206 return newname;
7207 }
7208 return NULL;
7209}
7210
7211static gboolean is_valid_geocache_name ( gchar *str )
7212{
7213 gint len = strlen ( str );
7214 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]));
7215}
7216
7217static void trw_layer_track_use_with_filter ( gpointer pass_along[6] )
7218{
7219 VikTrack *trk = g_hash_table_lookup ( VIK_TRW_LAYER(pass_along[0])->tracks, pass_along[3] );
7220 a_acquire_set_filter_track ( trk );
7221}
7222
7223#ifdef VIK_CONFIG_GOOGLE
7224static gboolean is_valid_google_route ( VikTrwLayer *vtl, const gpointer track_id )
7225{
7226 VikTrack *tr = g_hash_table_lookup ( vtl->routes, track_id );
7227 return ( tr && tr->comment && strlen(tr->comment) > 7 && !strncmp(tr->comment, "from:", 5) );
7228}
7229
7230static void trw_layer_google_route_webpage ( gpointer pass_along[6] )
7231{
7232 VikTrack *tr = g_hash_table_lookup ( VIK_TRW_LAYER(pass_along[0])->routes, pass_along[3] );
7233 if ( tr ) {
7234 gchar *escaped = uri_escape ( tr->comment );
7235 gchar *webpage = g_strdup_printf("http://maps.google.com/maps?f=q&hl=en&q=%s", escaped );
7236 open_url(VIK_GTK_WINDOW_FROM_LAYER(VIK_LAYER(pass_along[0])), webpage);
7237 g_free ( escaped );
7238 g_free ( webpage );
7239 }
7240}
7241#endif
7242
7243/* vlp can be NULL if necessary - i.e. right-click from a tool */
7244/* viewpoint is now available instead */
7245static gboolean trw_layer_sublayer_add_menu_items ( VikTrwLayer *l, GtkMenu *menu, gpointer vlp, gint subtype, gpointer sublayer, GtkTreeIter *iter, VikViewport *vvp )
7246{
7247 static gpointer pass_along[8];
7248 GtkWidget *item;
7249 gboolean rv = FALSE;
7250
7251 pass_along[0] = l;
7252 pass_along[1] = vlp;
7253 pass_along[2] = GINT_TO_POINTER (subtype);
7254 pass_along[3] = sublayer;
7255 pass_along[4] = GINT_TO_POINTER (1); // Confirm delete request
7256 pass_along[5] = vvp;
7257 pass_along[6] = iter;
7258 pass_along[7] = NULL; // For misc purposes - maybe track or waypoint
7259
7260 if ( subtype == VIK_TRW_LAYER_SUBLAYER_WAYPOINT || subtype == VIK_TRW_LAYER_SUBLAYER_TRACK || subtype == VIK_TRW_LAYER_SUBLAYER_ROUTE )
7261 {
7262 rv = TRUE;
7263
7264 item = gtk_image_menu_item_new_from_stock ( GTK_STOCK_PROPERTIES, NULL );
7265 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_properties_item), pass_along );
7266 gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
7267 gtk_widget_show ( item );
7268
7269 if (subtype == VIK_TRW_LAYER_SUBLAYER_TRACK) {
7270 VikTrack *tr = g_hash_table_lookup ( l->tracks, sublayer );
7271 if (tr && tr->property_dialog)
7272 gtk_widget_set_sensitive(GTK_WIDGET(item), FALSE );
7273 }
7274 if (subtype == VIK_TRW_LAYER_SUBLAYER_ROUTE) {
7275 VikTrack *tr = g_hash_table_lookup ( l->routes, sublayer );
7276 if (tr && tr->property_dialog)
7277 gtk_widget_set_sensitive(GTK_WIDGET(item), FALSE );
7278 }
7279
7280 item = gtk_image_menu_item_new_from_stock ( GTK_STOCK_CUT, NULL );
7281 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_cut_item_cb), pass_along );
7282 gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
7283 gtk_widget_show ( item );
7284
7285 item = gtk_image_menu_item_new_from_stock ( GTK_STOCK_COPY, NULL );
7286 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_copy_item_cb), pass_along );
7287 gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
7288 gtk_widget_show ( item );
7289
7290 item = gtk_image_menu_item_new_from_stock ( GTK_STOCK_DELETE, NULL );
7291 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_delete_item), pass_along );
7292 gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
7293 gtk_widget_show ( item );
7294
7295 if ( subtype == VIK_TRW_LAYER_SUBLAYER_WAYPOINT )
7296 {
7297 // Always create separator as now there is always at least the transform menu option
7298 item = gtk_menu_item_new ();
7299 gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
7300 gtk_widget_show ( item );
7301
7302 /* could be a right-click using the tool */
7303 if ( vlp != NULL ) {
7304 item = gtk_image_menu_item_new_with_mnemonic ( _("_Goto") );
7305 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_JUMP_TO, GTK_ICON_SIZE_MENU) );
7306 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_goto_waypoint), pass_along );
7307 gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
7308 gtk_widget_show ( item );
7309 }
7310
7311 VikWaypoint *wp = g_hash_table_lookup ( VIK_TRW_LAYER(l)->waypoints, sublayer );
7312
7313 if ( wp && wp->name ) {
7314 if ( is_valid_geocache_name ( wp->name ) ) {
7315 item = gtk_menu_item_new_with_mnemonic ( _("_Visit Geocache Webpage") );
7316 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_waypoint_gc_webpage), pass_along );
7317 gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
7318 gtk_widget_show ( item );
7319 }
7320#ifdef VIK_CONFIG_GEOTAG
7321 item = gtk_menu_item_new_with_mnemonic ( _("Geotag _Images...") );
7322 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_geotagging_waypoint), pass_along );
7323 gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
7324 gtk_widget_set_tooltip_text (item, _("Geotag multiple images against this waypoint"));
7325 gtk_widget_show ( item );
7326#endif
7327 }
7328
7329 if ( wp && wp->image )
7330 {
7331 // Set up image paramater
7332 pass_along[5] = wp->image;
7333
7334 item = gtk_image_menu_item_new_with_mnemonic ( _("_Show Picture...") );
7335 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock ("vik-icon-Show Picture", GTK_ICON_SIZE_MENU) ); // Own icon - see stock_icons in vikwindow.c
7336 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_show_picture), pass_along );
7337 gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
7338 gtk_widget_show ( item );
7339
7340#ifdef VIK_CONFIG_GEOTAG
7341 GtkWidget *geotag_submenu = gtk_menu_new ();
7342 item = gtk_image_menu_item_new_with_mnemonic ( _("Update Geotag on _Image") );
7343 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_REFRESH, GTK_ICON_SIZE_MENU) );
7344 gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
7345 gtk_widget_show ( item );
7346 gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), geotag_submenu );
7347
7348 item = gtk_menu_item_new_with_mnemonic ( _("_Update") );
7349 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_geotagging_waypoint_mtime_update), pass_along );
7350 gtk_menu_shell_append (GTK_MENU_SHELL (geotag_submenu), item);
7351 gtk_widget_show ( item );
7352
7353 item = gtk_menu_item_new_with_mnemonic ( _("Update and _Keep File Timestamp") );
7354 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_geotagging_waypoint_mtime_keep), pass_along );
7355 gtk_menu_shell_append (GTK_MENU_SHELL (geotag_submenu), item);
7356 gtk_widget_show ( item );
7357#endif
7358 }
7359
7360 if ( wp )
7361 {
7362 if ( ( wp->comment && !strncmp(wp->comment, "http", 4) ) ||
7363 ( wp->description && !strncmp(wp->description, "http", 4) )) {
7364 item = gtk_image_menu_item_new_with_mnemonic ( _("Visit _Webpage") );
7365 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_NETWORK, GTK_ICON_SIZE_MENU) );
7366 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_waypoint_webpage), pass_along );
7367 gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
7368 gtk_widget_show ( item );
7369 }
7370 }
7371 }
7372 }
7373
7374 if ( subtype == VIK_TRW_LAYER_SUBLAYER_WAYPOINTS || subtype == VIK_TRW_LAYER_SUBLAYER_TRACKS || subtype == VIK_TRW_LAYER_SUBLAYER_ROUTES ) {
7375 item = gtk_image_menu_item_new_from_stock ( GTK_STOCK_PASTE, NULL );
7376 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_paste_item_cb), pass_along );
7377 gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
7378 gtk_widget_show ( item );
7379 // TODO: only enable if suitable item is in clipboard - want to determine *which* sublayer type
7380 if ( a_clipboard_type ( ) == VIK_CLIPBOARD_DATA_SUBLAYER )
7381 gtk_widget_set_sensitive ( item, TRUE );
7382 else
7383 gtk_widget_set_sensitive ( item, FALSE );
7384
7385 // Add separator
7386 item = gtk_menu_item_new ();
7387 gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
7388 gtk_widget_show ( item );
7389 }
7390
7391 if ( vlp && (subtype == VIK_TRW_LAYER_SUBLAYER_WAYPOINTS || subtype == VIK_TRW_LAYER_SUBLAYER_WAYPOINT) )
7392 {
7393 rv = TRUE;
7394 item = gtk_image_menu_item_new_with_mnemonic ( _("_New Waypoint...") );
7395 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_NEW, GTK_ICON_SIZE_MENU) );
7396 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_new_wp), pass_along );
7397 gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
7398 gtk_widget_show ( item );
7399 }
7400
7401 if ( subtype == VIK_TRW_LAYER_SUBLAYER_WAYPOINTS )
7402 {
7403 item = gtk_image_menu_item_new_with_mnemonic ( _("_View All Waypoints") );
7404 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_ZOOM_FIT, GTK_ICON_SIZE_MENU) );
7405 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_auto_waypoints_view), pass_along );
7406 gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
7407 gtk_widget_show ( item );
7408
7409 item = gtk_image_menu_item_new_with_mnemonic ( _("Goto _Waypoint...") );
7410 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_JUMP_TO, GTK_ICON_SIZE_MENU) );
7411 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_goto_wp), pass_along );
7412 gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
7413 gtk_widget_show ( item );
7414
7415 item = gtk_image_menu_item_new_with_mnemonic ( _("Delete _All Waypoints") );
7416 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_REMOVE, GTK_ICON_SIZE_MENU) );
7417 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_delete_all_waypoints), pass_along );
7418 gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
7419 gtk_widget_show ( item );
7420
7421 item = gtk_image_menu_item_new_with_mnemonic ( _("_Delete Waypoints From Selection...") );
7422 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_INDEX, GTK_ICON_SIZE_MENU) );
7423 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_delete_waypoints_from_selection), pass_along );
7424 gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
7425 gtk_widget_show ( item );
7426
7427 GtkWidget *vis_submenu = gtk_menu_new ();
7428 item = gtk_menu_item_new_with_mnemonic ( _("_Visibility") );
7429 gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
7430 gtk_widget_show ( item );
7431 gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), vis_submenu );
7432
7433 item = gtk_image_menu_item_new_with_mnemonic ( _("_Show All Waypoints") );
7434 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_APPLY, GTK_ICON_SIZE_MENU) );
7435 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_waypoints_visibility_on), pass_along );
7436 gtk_menu_shell_append ( GTK_MENU_SHELL(vis_submenu), item );
7437 gtk_widget_show ( item );
7438
7439 item = gtk_image_menu_item_new_with_mnemonic ( _("_Hide All Waypoints") );
7440 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_CLEAR, GTK_ICON_SIZE_MENU) );
7441 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_waypoints_visibility_off), pass_along );
7442 gtk_menu_shell_append ( GTK_MENU_SHELL(vis_submenu), item );
7443 gtk_widget_show ( item );
7444
7445 item = gtk_image_menu_item_new_with_mnemonic ( _("_Toggle") );
7446 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_REFRESH, GTK_ICON_SIZE_MENU) );
7447 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_waypoints_visibility_toggle), pass_along );
7448 gtk_menu_shell_append ( GTK_MENU_SHELL(vis_submenu), item );
7449 gtk_widget_show ( item );
7450
7451 item = gtk_image_menu_item_new_with_mnemonic ( _("_List Waypoints...") );
7452 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_INDEX, GTK_ICON_SIZE_MENU) );
7453 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_waypoint_list_dialog), pass_along );
7454 gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
7455 }
7456
7457 if ( subtype == VIK_TRW_LAYER_SUBLAYER_TRACKS )
7458 {
7459 rv = TRUE;
7460
7461 if ( l->current_track && !l->current_track->is_route ) {
7462 item = gtk_menu_item_new_with_mnemonic ( _("_Finish Track") );
7463 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_finish_track), pass_along );
7464 gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
7465 gtk_widget_show ( item );
7466 // Add separator
7467 item = gtk_menu_item_new ();
7468 gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
7469 gtk_widget_show ( item );
7470 }
7471
7472 item = gtk_image_menu_item_new_with_mnemonic ( _("_View All Tracks") );
7473 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_ZOOM_FIT, GTK_ICON_SIZE_MENU) );
7474 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_auto_tracks_view), pass_along );
7475 gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
7476 gtk_widget_show ( item );
7477
7478 item = gtk_image_menu_item_new_with_mnemonic ( _("_New Track") );
7479 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_NEW, GTK_ICON_SIZE_MENU) );
7480 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_new_track), pass_along );
7481 gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
7482 gtk_widget_show ( item );
7483 // Make it available only when a new track *not* already in progress
7484 gtk_widget_set_sensitive ( item, ! (gboolean)GPOINTER_TO_INT(l->current_track) );
7485
7486 item = gtk_image_menu_item_new_with_mnemonic ( _("Delete _All Tracks") );
7487 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_REMOVE, GTK_ICON_SIZE_MENU) );
7488 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_delete_all_tracks), pass_along );
7489 gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
7490 gtk_widget_show ( item );
7491
7492 item = gtk_image_menu_item_new_with_mnemonic ( _("_Delete Tracks From Selection...") );
7493 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_INDEX, GTK_ICON_SIZE_MENU) );
7494 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_delete_tracks_from_selection), pass_along );
7495 gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
7496 gtk_widget_show ( item );
7497
7498 GtkWidget *vis_submenu = gtk_menu_new ();
7499 item = gtk_menu_item_new_with_mnemonic ( _("_Visibility") );
7500 gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
7501 gtk_widget_show ( item );
7502 gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), vis_submenu );
7503
7504 item = gtk_image_menu_item_new_with_mnemonic ( _("_Show All Tracks") );
7505 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_APPLY, GTK_ICON_SIZE_MENU) );
7506 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_tracks_visibility_on), pass_along );
7507 gtk_menu_shell_append ( GTK_MENU_SHELL(vis_submenu), item );
7508 gtk_widget_show ( item );
7509
7510 item = gtk_image_menu_item_new_with_mnemonic ( _("_Hide All Tracks") );
7511 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_CLEAR, GTK_ICON_SIZE_MENU) );
7512 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_tracks_visibility_off), pass_along );
7513 gtk_menu_shell_append ( GTK_MENU_SHELL(vis_submenu), item );
7514 gtk_widget_show ( item );
7515
7516 item = gtk_image_menu_item_new_with_mnemonic ( _("_Toggle") );
7517 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_REFRESH, GTK_ICON_SIZE_MENU) );
7518 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_tracks_visibility_toggle), pass_along );
7519 gtk_menu_shell_append ( GTK_MENU_SHELL(vis_submenu), item );
7520
7521 item = gtk_image_menu_item_new_with_mnemonic ( _("_List Tracks...") );
7522 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_INDEX, GTK_ICON_SIZE_MENU) );
7523 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_track_list_dialog_single), pass_along );
7524 gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
7525 gtk_widget_show ( item );
7526
7527 item = gtk_menu_item_new_with_mnemonic ( _("_Statistics") );
7528 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_tracks_stats), pass_along );
7529 gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
7530 gtk_widget_show ( item );
7531 }
7532
7533 if ( subtype == VIK_TRW_LAYER_SUBLAYER_ROUTES )
7534 {
7535 rv = TRUE;
7536
7537 if ( l->current_track && l->current_track->is_route ) {
7538 item = gtk_menu_item_new_with_mnemonic ( _("_Finish Route") );
7539 // Reuse finish track method
7540 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_finish_track), pass_along );
7541 gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
7542 gtk_widget_show ( item );
7543 // Add separator
7544 item = gtk_menu_item_new ();
7545 gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
7546 gtk_widget_show ( item );
7547 }
7548
7549 item = gtk_image_menu_item_new_with_mnemonic ( _("_View All Routes") );
7550 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_ZOOM_FIT, GTK_ICON_SIZE_MENU) );
7551 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_auto_routes_view), pass_along );
7552 gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
7553 gtk_widget_show ( item );
7554
7555 item = gtk_image_menu_item_new_with_mnemonic ( _("_New Route") );
7556 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_NEW, GTK_ICON_SIZE_MENU) );
7557 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_new_route), pass_along );
7558 gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
7559 gtk_widget_show ( item );
7560 // Make it available only when a new track *not* already in progress
7561 gtk_widget_set_sensitive ( item, ! (gboolean)GPOINTER_TO_INT(l->current_track) );
7562
7563 item = gtk_image_menu_item_new_with_mnemonic ( _("Delete _All Routes") );
7564 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_REMOVE, GTK_ICON_SIZE_MENU) );
7565 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_delete_all_routes), pass_along );
7566 gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
7567 gtk_widget_show ( item );
7568
7569 item = gtk_image_menu_item_new_with_mnemonic ( _("_Delete Routes From Selection...") );
7570 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_INDEX, GTK_ICON_SIZE_MENU) );
7571 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_delete_routes_from_selection), pass_along );
7572 gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
7573 gtk_widget_show ( item );
7574
7575 GtkWidget *vis_submenu = gtk_menu_new ();
7576 item = gtk_menu_item_new_with_mnemonic ( _("_Visibility") );
7577 gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
7578 gtk_widget_show ( item );
7579 gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), vis_submenu );
7580
7581 item = gtk_image_menu_item_new_with_mnemonic ( _("_Show All Routes") );
7582 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_APPLY, GTK_ICON_SIZE_MENU) );
7583 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_routes_visibility_on), pass_along );
7584 gtk_menu_shell_append ( GTK_MENU_SHELL(vis_submenu), item );
7585 gtk_widget_show ( item );
7586
7587 item = gtk_image_menu_item_new_with_mnemonic ( _("_Hide All Routes") );
7588 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_CLEAR, GTK_ICON_SIZE_MENU) );
7589 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_routes_visibility_off), pass_along );
7590 gtk_menu_shell_append ( GTK_MENU_SHELL(vis_submenu), item );
7591 gtk_widget_show ( item );
7592
7593 item = gtk_image_menu_item_new_with_mnemonic ( _("_Toggle") );
7594 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_REFRESH, GTK_ICON_SIZE_MENU) );
7595 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_routes_visibility_toggle), pass_along );
7596 gtk_menu_shell_append ( GTK_MENU_SHELL(vis_submenu), item );
7597
7598 item = gtk_image_menu_item_new_with_mnemonic ( _("_List Routes...") );
7599 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_INDEX, GTK_ICON_SIZE_MENU) );
7600 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_track_list_dialog_single), pass_along );
7601 gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
7602
7603 gtk_widget_show ( item );
7604
7605 item = gtk_menu_item_new_with_mnemonic ( _("_Statistics") );
7606 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_routes_stats), pass_along );
7607 gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
7608 gtk_widget_show ( item );
7609 }
7610
7611
7612 if ( subtype == VIK_TRW_LAYER_SUBLAYER_WAYPOINTS || subtype == VIK_TRW_LAYER_SUBLAYER_TRACKS || subtype == VIK_TRW_LAYER_SUBLAYER_ROUTES ) {
7613 GtkWidget *submenu_sort = gtk_menu_new ();
7614 item = gtk_image_menu_item_new_with_mnemonic ( _("_Sort") );
7615 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_REFRESH, GTK_ICON_SIZE_MENU) );
7616 gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
7617 gtk_widget_show ( item );
7618 gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), submenu_sort );
7619
7620 item = gtk_image_menu_item_new_with_mnemonic ( _("Name _Ascending") );
7621 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_SORT_ASCENDING, GTK_ICON_SIZE_MENU) );
7622 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_sort_order_a2z), pass_along );
7623 gtk_menu_shell_append ( GTK_MENU_SHELL(submenu_sort), item );
7624 gtk_widget_show ( item );
7625
7626 item = gtk_image_menu_item_new_with_mnemonic ( _("Name _Descending") );
7627 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_SORT_DESCENDING, GTK_ICON_SIZE_MENU) );
7628 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_sort_order_z2a), pass_along );
7629 gtk_menu_shell_append ( GTK_MENU_SHELL(submenu_sort), item );
7630 gtk_widget_show ( item );
7631 }
7632
7633 GtkWidget *upload_submenu = gtk_menu_new ();
7634
7635 if ( subtype == VIK_TRW_LAYER_SUBLAYER_TRACK || subtype == VIK_TRW_LAYER_SUBLAYER_ROUTE )
7636 {
7637 item = gtk_menu_item_new ();
7638 gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
7639 gtk_widget_show ( item );
7640
7641 if ( l->current_track && subtype == VIK_TRW_LAYER_SUBLAYER_TRACK && !l->current_track->is_route )
7642 item = gtk_menu_item_new_with_mnemonic ( _("_Finish Track") );
7643 if ( l->current_track && subtype == VIK_TRW_LAYER_SUBLAYER_ROUTE && l->current_track->is_route )
7644 item = gtk_menu_item_new_with_mnemonic ( _("_Finish Route") );
7645 if ( l->current_track ) {
7646 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_finish_track), pass_along );
7647 gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
7648 gtk_widget_show ( item );
7649
7650 // Add separator
7651 item = gtk_menu_item_new ();
7652 gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
7653 gtk_widget_show ( item );
7654 }
7655
7656 if ( subtype == VIK_TRW_LAYER_SUBLAYER_TRACK )
7657 item = gtk_image_menu_item_new_with_mnemonic ( _("_View Track") );
7658 else
7659 item = gtk_image_menu_item_new_with_mnemonic ( _("_View Route") );
7660 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_ZOOM_FIT, GTK_ICON_SIZE_MENU) );
7661 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_auto_track_view), pass_along );
7662 gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
7663 gtk_widget_show ( item );
7664
7665 item = gtk_menu_item_new_with_mnemonic ( _("_Statistics") );
7666 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_track_statistics), pass_along );
7667 gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
7668 gtk_widget_show ( item );
7669
7670 GtkWidget *goto_submenu;
7671 goto_submenu = gtk_menu_new ();
7672 item = gtk_image_menu_item_new_with_mnemonic ( _("_Goto") );
7673 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_JUMP_TO, GTK_ICON_SIZE_MENU) );
7674 gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
7675 gtk_widget_show ( item );
7676 gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), goto_submenu );
7677
7678 item = gtk_image_menu_item_new_with_mnemonic ( _("_Startpoint") );
7679 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_GOTO_FIRST, GTK_ICON_SIZE_MENU) );
7680 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_goto_track_startpoint), pass_along );
7681 gtk_menu_shell_append ( GTK_MENU_SHELL(goto_submenu), item );
7682 gtk_widget_show ( item );
7683
7684 item = gtk_image_menu_item_new_with_mnemonic ( _("\"_Center\"") );
7685 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_JUMP_TO, GTK_ICON_SIZE_MENU) );
7686 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_goto_track_center), pass_along );
7687 gtk_menu_shell_append ( GTK_MENU_SHELL(goto_submenu), item );
7688 gtk_widget_show ( item );
7689
7690 item = gtk_image_menu_item_new_with_mnemonic ( _("_Endpoint") );
7691 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_GOTO_LAST, GTK_ICON_SIZE_MENU) );
7692 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_goto_track_endpoint), pass_along );
7693 gtk_menu_shell_append ( GTK_MENU_SHELL(goto_submenu), item );
7694 gtk_widget_show ( item );
7695
7696 item = gtk_image_menu_item_new_with_mnemonic ( _("_Highest Altitude") );
7697 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_GOTO_TOP, GTK_ICON_SIZE_MENU) );
7698 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_goto_track_max_alt), pass_along );
7699 gtk_menu_shell_append ( GTK_MENU_SHELL(goto_submenu), item );
7700 gtk_widget_show ( item );
7701
7702 item = gtk_image_menu_item_new_with_mnemonic ( _("_Lowest Altitude") );
7703 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_GOTO_BOTTOM, GTK_ICON_SIZE_MENU) );
7704 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_goto_track_min_alt), pass_along );
7705 gtk_menu_shell_append ( GTK_MENU_SHELL(goto_submenu), item );
7706 gtk_widget_show ( item );
7707
7708 // Routes don't have speeds
7709 if ( subtype == VIK_TRW_LAYER_SUBLAYER_TRACK ) {
7710 item = gtk_image_menu_item_new_with_mnemonic ( _("_Maximum Speed") );
7711 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_MEDIA_FORWARD, GTK_ICON_SIZE_MENU) );
7712 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_goto_track_max_speed), pass_along );
7713 gtk_menu_shell_append ( GTK_MENU_SHELL(goto_submenu), item );
7714 gtk_widget_show ( item );
7715 }
7716
7717 GtkWidget *combine_submenu;
7718 combine_submenu = gtk_menu_new ();
7719 item = gtk_image_menu_item_new_with_mnemonic ( _("Co_mbine") );
7720 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_CONNECT, GTK_ICON_SIZE_MENU) );
7721 gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
7722 gtk_widget_show ( item );
7723 gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), combine_submenu );
7724
7725 // Routes don't have times or segments...
7726 if ( subtype == VIK_TRW_LAYER_SUBLAYER_TRACK ) {
7727 item = gtk_menu_item_new_with_mnemonic ( _("_Merge By Time...") );
7728 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_merge_by_timestamp), pass_along );
7729 gtk_menu_shell_append ( GTK_MENU_SHELL(combine_submenu), item );
7730 gtk_widget_show ( item );
7731
7732 item = gtk_menu_item_new_with_mnemonic ( _("Merge _Segments") );
7733 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_merge_by_segment), pass_along );
7734 gtk_menu_shell_append ( GTK_MENU_SHELL(combine_submenu), item );
7735 gtk_widget_show ( item );
7736 }
7737
7738 item = gtk_menu_item_new_with_mnemonic ( _("Merge _With Other Tracks...") );
7739 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_merge_with_other), pass_along );
7740 gtk_menu_shell_append ( GTK_MENU_SHELL(combine_submenu), item );
7741 gtk_widget_show ( item );
7742
7743 if ( subtype == VIK_TRW_LAYER_SUBLAYER_TRACK )
7744 item = gtk_menu_item_new_with_mnemonic ( _("_Append Track...") );
7745 else
7746 item = gtk_menu_item_new_with_mnemonic ( _("_Append Route...") );
7747 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_append_track), pass_along );
7748 gtk_menu_shell_append ( GTK_MENU_SHELL(combine_submenu), item );
7749 gtk_widget_show ( item );
7750
7751 if ( subtype == VIK_TRW_LAYER_SUBLAYER_TRACK )
7752 item = gtk_menu_item_new_with_mnemonic ( _("Append _Route...") );
7753 else
7754 item = gtk_menu_item_new_with_mnemonic ( _("Append _Track...") );
7755 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_append_other), pass_along );
7756 gtk_menu_shell_append ( GTK_MENU_SHELL(combine_submenu), item );
7757 gtk_widget_show ( item );
7758
7759 GtkWidget *split_submenu;
7760 split_submenu = gtk_menu_new ();
7761 item = gtk_image_menu_item_new_with_mnemonic ( _("_Split") );
7762 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_DISCONNECT, GTK_ICON_SIZE_MENU) );
7763 gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
7764 gtk_widget_show ( item );
7765 gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), split_submenu );
7766
7767 // Routes don't have times or segments...
7768 if ( subtype == VIK_TRW_LAYER_SUBLAYER_TRACK ) {
7769 item = gtk_menu_item_new_with_mnemonic ( _("_Split By Time...") );
7770 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_split_by_timestamp), pass_along );
7771 gtk_menu_shell_append ( GTK_MENU_SHELL(split_submenu), item );
7772 gtk_widget_show ( item );
7773
7774 // ATM always enable this entry - don't want to have to analyse the track before displaying the menu - to keep the menu speedy
7775 item = gtk_menu_item_new_with_mnemonic ( _("Split Se_gments") );
7776 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_split_segments), pass_along );
7777 gtk_menu_shell_append ( GTK_MENU_SHELL(split_submenu), item );
7778 gtk_widget_show ( item );
7779 }
7780
7781 item = gtk_menu_item_new_with_mnemonic ( _("Split By _Number of Points...") );
7782 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_split_by_n_points), pass_along );
7783 gtk_menu_shell_append ( GTK_MENU_SHELL(split_submenu), item );
7784 gtk_widget_show ( item );
7785
7786 item = gtk_menu_item_new_with_mnemonic ( _("Split at _Trackpoint") );
7787 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_split_at_trackpoint), pass_along );
7788 gtk_menu_shell_append ( GTK_MENU_SHELL(split_submenu), item );
7789 gtk_widget_show ( item );
7790 // Make it available only when a trackpoint is selected.
7791 gtk_widget_set_sensitive ( item, (gboolean)GPOINTER_TO_INT(l->current_tpl) );
7792
7793 GtkWidget *insert_submenu = gtk_menu_new ();
7794 item = gtk_image_menu_item_new_with_mnemonic ( _("_Insert Points") );
7795 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_ADD, GTK_ICON_SIZE_MENU) );
7796 gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
7797 gtk_widget_show ( item );
7798 gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), insert_submenu );
7799
7800 item = gtk_menu_item_new_with_mnemonic ( _("Insert Point _Before Selected Point") );
7801 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_insert_point_before), pass_along );
7802 gtk_menu_shell_append ( GTK_MENU_SHELL(insert_submenu), item );
7803 gtk_widget_show ( item );
7804 // Make it available only when a point is selected
7805 gtk_widget_set_sensitive ( item, (gboolean)GPOINTER_TO_INT(l->current_tpl) );
7806
7807 item = gtk_menu_item_new_with_mnemonic ( _("Insert Point _After Selected Point") );
7808 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_insert_point_after), pass_along );
7809 gtk_menu_shell_append ( GTK_MENU_SHELL(insert_submenu), item );
7810 gtk_widget_show ( item );
7811 // Make it available only when a point is selected
7812 gtk_widget_set_sensitive ( item, (gboolean)GPOINTER_TO_INT(l->current_tpl) );
7813
7814 GtkWidget *delete_submenu;
7815 delete_submenu = gtk_menu_new ();
7816 item = gtk_image_menu_item_new_with_mnemonic ( _("Delete Poi_nts") );
7817 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_DELETE, GTK_ICON_SIZE_MENU) );
7818 gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
7819 gtk_widget_show ( item );
7820 gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), delete_submenu );
7821
7822 item = gtk_image_menu_item_new_with_mnemonic ( _("Delete _Selected Point") );
7823 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_DELETE, GTK_ICON_SIZE_MENU) );
7824 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_delete_point_selected), pass_along );
7825 gtk_menu_shell_append ( GTK_MENU_SHELL(delete_submenu), item );
7826 gtk_widget_show ( item );
7827 // Make it available only when a point is selected
7828 gtk_widget_set_sensitive ( item, (gboolean)GPOINTER_TO_INT(l->current_tpl) );
7829
7830 item = gtk_menu_item_new_with_mnemonic ( _("Delete Points With The Same _Position") );
7831 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_delete_points_same_position), pass_along );
7832 gtk_menu_shell_append ( GTK_MENU_SHELL(delete_submenu), item );
7833 gtk_widget_show ( item );
7834
7835 item = gtk_menu_item_new_with_mnemonic ( _("Delete Points With The Same _Time") );
7836 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_delete_points_same_time), pass_along );
7837 gtk_menu_shell_append ( GTK_MENU_SHELL(delete_submenu), item );
7838 gtk_widget_show ( item );
7839
7840 GtkWidget *transform_submenu;
7841 transform_submenu = gtk_menu_new ();
7842 item = gtk_image_menu_item_new_with_mnemonic ( _("_Transform") );
7843 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_CONVERT, GTK_ICON_SIZE_MENU) );
7844 gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
7845 gtk_widget_show ( item );
7846 gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), transform_submenu );
7847
7848 GtkWidget *dem_submenu;
7849 dem_submenu = gtk_menu_new ();
7850 item = gtk_image_menu_item_new_with_mnemonic ( _("_Apply DEM Data") );
7851 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock ("vik-icon-DEM Download", GTK_ICON_SIZE_MENU) ); // Own icon - see stock_icons in vikwindow.c
7852 gtk_menu_shell_append ( GTK_MENU_SHELL(transform_submenu), item );
7853 gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), dem_submenu );
7854
7855 item = gtk_image_menu_item_new_with_mnemonic ( _("_Overwrite") );
7856 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_apply_dem_data_all), pass_along );
7857 gtk_menu_shell_append ( GTK_MENU_SHELL(dem_submenu), item );
7858 gtk_widget_set_tooltip_text (item, _("Overwrite any existing elevation values with DEM values"));
7859 gtk_widget_show ( item );
7860
7861 item = gtk_image_menu_item_new_with_mnemonic ( _("_Keep Existing") );
7862 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_apply_dem_data_only_missing), pass_along );
7863 gtk_menu_shell_append ( GTK_MENU_SHELL(dem_submenu), item );
7864 gtk_widget_set_tooltip_text (item, _("Keep existing elevation values, only attempt for missing values"));
7865 gtk_widget_show ( item );
7866
7867 GtkWidget *smooth_submenu;
7868 smooth_submenu = gtk_menu_new ();
7869 item = gtk_menu_item_new_with_mnemonic ( _("_Smooth Missing Elevation Data") );
7870 gtk_menu_shell_append ( GTK_MENU_SHELL(transform_submenu), item );
7871 gtk_widget_show ( item );
7872 gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), smooth_submenu );
7873
7874 item = gtk_image_menu_item_new_with_mnemonic ( _("_Interpolated") );
7875 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_missing_elevation_data_interp), pass_along );
7876 gtk_menu_shell_append ( GTK_MENU_SHELL(smooth_submenu), item );
7877 gtk_widget_set_tooltip_text (item, _("Interpolate between known elevation values to derive values for the missing elevations"));
7878 gtk_widget_show ( item );
7879
7880 item = gtk_image_menu_item_new_with_mnemonic ( _("_Flat") );
7881 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_missing_elevation_data_flat), pass_along );
7882 gtk_menu_shell_append ( GTK_MENU_SHELL(smooth_submenu), item );
7883 gtk_widget_set_tooltip_text (item, _("Set unknown elevation values to the last known value"));
7884 gtk_widget_show ( item );
7885
7886 if ( subtype == VIK_TRW_LAYER_SUBLAYER_TRACK )
7887 item = gtk_image_menu_item_new_with_mnemonic ( _("C_onvert to a Route") );
7888 else
7889 item = gtk_image_menu_item_new_with_mnemonic ( _("C_onvert to a Track") );
7890 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_CONVERT, GTK_ICON_SIZE_MENU) );
7891 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_convert_track_route), pass_along );
7892 gtk_menu_shell_append ( GTK_MENU_SHELL(transform_submenu), item );
7893 gtk_widget_show ( item );
7894
7895 // Routes don't have timestamps - so this is only available for tracks
7896 if ( subtype == VIK_TRW_LAYER_SUBLAYER_TRACK ) {
7897 item = gtk_image_menu_item_new_with_mnemonic ( _("_Anonymize Times") );
7898 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_anonymize_times), pass_along );
7899 gtk_menu_shell_append ( GTK_MENU_SHELL(transform_submenu), item );
7900 gtk_widget_set_tooltip_text (item, _("Shift timestamps to a relative offset from 1901-01-01"));
7901 gtk_widget_show ( item );
7902 }
7903
7904 if ( subtype == VIK_TRW_LAYER_SUBLAYER_TRACK )
7905 item = gtk_image_menu_item_new_with_mnemonic ( _("_Reverse Track") );
7906 else
7907 item = gtk_image_menu_item_new_with_mnemonic ( _("_Reverse Route") );
7908 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_GO_BACK, GTK_ICON_SIZE_MENU) );
7909 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_reverse), pass_along );
7910 gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
7911 gtk_widget_show ( item );
7912
7913 if ( subtype == VIK_TRW_LAYER_SUBLAYER_ROUTE ) {
7914 item = gtk_image_menu_item_new_with_mnemonic ( _("Refine Route...") );
7915 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_FIND, GTK_ICON_SIZE_MENU) );
7916 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_route_refine), pass_along );
7917 gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
7918 gtk_widget_show ( item );
7919 }
7920
7921 /* ATM This function is only available via the layers panel, due to the method in finding out the maps in use */
7922 if ( vlp ) {
7923 if ( subtype == VIK_TRW_LAYER_SUBLAYER_TRACK )
7924 item = gtk_image_menu_item_new_with_mnemonic ( _("Down_load Maps Along Track...") );
7925 else
7926 item = gtk_image_menu_item_new_with_mnemonic ( _("Down_load Maps Along Route...") );
7927 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock ("vik-icon-Maps Download", GTK_ICON_SIZE_MENU) ); // Own icon - see stock_icons in vikwindow.c
7928 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_download_map_along_track_cb), pass_along );
7929 gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
7930 gtk_widget_show ( item );
7931 }
7932
7933 if ( subtype == VIK_TRW_LAYER_SUBLAYER_TRACK )
7934 item = gtk_image_menu_item_new_with_mnemonic ( _("_Export Track as GPX...") );
7935 else
7936 item = gtk_image_menu_item_new_with_mnemonic ( _("_Export Route as GPX...") );
7937 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_HARDDISK, GTK_ICON_SIZE_MENU) );
7938 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_export_gpx_track), pass_along );
7939 gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
7940 gtk_widget_show ( item );
7941
7942 if ( subtype == VIK_TRW_LAYER_SUBLAYER_TRACK )
7943 item = gtk_image_menu_item_new_with_mnemonic ( _("E_xtend Track End") );
7944 else
7945 item = gtk_image_menu_item_new_with_mnemonic ( _("E_xtend Route End") );
7946 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_ADD, GTK_ICON_SIZE_MENU) );
7947 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_extend_track_end), pass_along );
7948 gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
7949 gtk_widget_show ( item );
7950
7951 if ( subtype == VIK_TRW_LAYER_SUBLAYER_ROUTE ) {
7952 item = gtk_image_menu_item_new_with_mnemonic ( _("Extend _Using Route Finder") );
7953 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock ("vik-icon-Route Finder", GTK_ICON_SIZE_MENU) ); // Own icon - see stock_icons in vikwindow.c
7954 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_extend_track_end_route_finder), pass_along );
7955 gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
7956 gtk_widget_show ( item );
7957 }
7958
7959 // ATM can't upload a single waypoint but can do waypoints to a GPS
7960 if ( subtype != VIK_TRW_LAYER_SUBLAYER_WAYPOINT ) {
7961 item = gtk_image_menu_item_new_with_mnemonic ( _("_Upload") );
7962 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_GO_UP, GTK_ICON_SIZE_MENU) );
7963 gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
7964 gtk_widget_show ( item );
7965 gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), upload_submenu );
7966
7967 item = gtk_image_menu_item_new_with_mnemonic ( _("_Upload to GPS...") );
7968 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_GO_FORWARD, GTK_ICON_SIZE_MENU) );
7969 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_gps_upload_any), pass_along );
7970 gtk_menu_shell_append ( GTK_MENU_SHELL(upload_submenu), item );
7971 gtk_widget_show ( item );
7972 }
7973 }
7974
7975#ifdef VIK_CONFIG_GOOGLE
7976 if ( subtype == VIK_TRW_LAYER_SUBLAYER_ROUTE && is_valid_google_route ( l, sublayer ) )
7977 {
7978 item = gtk_image_menu_item_new_with_mnemonic ( _("_View Google Directions") );
7979 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_NETWORK, GTK_ICON_SIZE_MENU) );
7980 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_google_route_webpage), pass_along );
7981 gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
7982 gtk_widget_show ( item );
7983 }
7984#endif
7985
7986 // Some things aren't usable with routes
7987 if ( subtype == VIK_TRW_LAYER_SUBLAYER_TRACK ) {
7988#ifdef VIK_CONFIG_OPENSTREETMAP
7989 item = gtk_image_menu_item_new_with_mnemonic ( _("Upload to _OSM...") );
7990 // Convert internal pointer into actual track for usage outside this file
7991 pass_along[7] = g_hash_table_lookup ( l->tracks, sublayer);
7992 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_GO_UP, GTK_ICON_SIZE_MENU) );
7993 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(osm_traces_upload_track_cb), pass_along );
7994 gtk_menu_shell_append ( GTK_MENU_SHELL(upload_submenu), item );
7995 gtk_widget_show ( item );
7996#endif
7997
7998 item = gtk_image_menu_item_new_with_mnemonic ( _("Use with _Filter") );
7999 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_INDEX, GTK_ICON_SIZE_MENU) );
8000 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_track_use_with_filter), pass_along );
8001 gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
8002 gtk_widget_show ( item );
8003
8004 /* ATM This function is only available via the layers panel, due to needing a vlp */
8005 if ( vlp ) {
8006 item = a_acquire_track_menu ( VIK_WINDOW(VIK_GTK_WINDOW_FROM_LAYER(l)), vlp,
8007 vik_layers_panel_get_viewport(VIK_LAYERS_PANEL(vlp)),
8008 g_hash_table_lookup ( l->tracks, (gchar *) sublayer ) );
8009 if ( item ) {
8010 gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
8011 gtk_widget_show ( item );
8012 }
8013 }
8014
8015#ifdef VIK_CONFIG_GEOTAG
8016 item = gtk_menu_item_new_with_mnemonic ( _("Geotag _Images...") );
8017 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_geotagging_track), pass_along );
8018 gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
8019 gtk_widget_show ( item );
8020#endif
8021 }
8022
8023 if ( subtype == VIK_TRW_LAYER_SUBLAYER_TRACK || subtype == VIK_TRW_LAYER_SUBLAYER_ROUTE ) {
8024 // Only show on viewport popmenu when a trackpoint is selected
8025 if ( ! vlp && l->current_tpl ) {
8026 // Add separator
8027 item = gtk_menu_item_new ();
8028 gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
8029 gtk_widget_show ( item );
8030
8031 item = gtk_image_menu_item_new_with_mnemonic ( _("_Edit Trackpoint") );
8032 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_PROPERTIES, GTK_ICON_SIZE_MENU) );
8033 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_edit_trackpoint), pass_along );
8034 gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
8035 gtk_widget_show ( item );
8036 }
8037 }
8038
8039 if ( subtype == VIK_TRW_LAYER_SUBLAYER_WAYPOINTS || subtype == VIK_TRW_LAYER_SUBLAYER_WAYPOINT ) {
8040 GtkWidget *transform_submenu;
8041 transform_submenu = gtk_menu_new ();
8042 item = gtk_image_menu_item_new_with_mnemonic ( _("_Transform") );
8043 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_CONVERT, GTK_ICON_SIZE_MENU) );
8044 gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
8045 gtk_widget_show ( item );
8046 gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), transform_submenu );
8047
8048 GtkWidget *dem_submenu;
8049 dem_submenu = gtk_menu_new ();
8050 item = gtk_image_menu_item_new_with_mnemonic ( _("_Apply DEM Data") );
8051 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock ("vik-icon-DEM Download", GTK_ICON_SIZE_MENU) ); // Own icon - see stock_icons in vikwindow.c
8052 gtk_menu_shell_append ( GTK_MENU_SHELL(transform_submenu), item );
8053 gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), dem_submenu );
8054
8055 item = gtk_image_menu_item_new_with_mnemonic ( _("_Overwrite") );
8056 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_apply_dem_data_wpt_all), pass_along );
8057 gtk_menu_shell_append ( GTK_MENU_SHELL(dem_submenu), item );
8058 gtk_widget_set_tooltip_text (item, _("Overwrite any existing elevation values with DEM values"));
8059 gtk_widget_show ( item );
8060
8061 item = gtk_image_menu_item_new_with_mnemonic ( _("_Keep Existing") );
8062 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_apply_dem_data_wpt_only_missing), pass_along );
8063 gtk_menu_shell_append ( GTK_MENU_SHELL(dem_submenu), item );
8064 gtk_widget_set_tooltip_text (item, _("Keep existing elevation values, only attempt for missing values"));
8065 gtk_widget_show ( item );
8066 }
8067
8068 gtk_widget_show_all ( GTK_WIDGET(menu) );
8069
8070 return rv;
8071}
8072
8073// TODO: Probably better to rework this track manipulation in viktrack.c
8074static void trw_layer_insert_tp_beside_current_tp ( VikTrwLayer *vtl, gboolean before )
8075{
8076 // sanity check
8077 if (!vtl->current_tpl)
8078 return;
8079
8080 VikTrackpoint *tp_current = VIK_TRACKPOINT(vtl->current_tpl->data);
8081 VikTrackpoint *tp_other = NULL;
8082
8083 if ( before ) {
8084 if (!vtl->current_tpl->prev)
8085 return;
8086 tp_other = VIK_TRACKPOINT(vtl->current_tpl->prev->data);
8087 } else {
8088 if (!vtl->current_tpl->next)
8089 return;
8090 tp_other = VIK_TRACKPOINT(vtl->current_tpl->next->data);
8091 }
8092
8093 // Use current and other trackpoints to form a new track point which is inserted into the tracklist
8094 if ( tp_other ) {
8095
8096 VikTrackpoint *tp_new = vik_trackpoint_new();
8097 struct LatLon ll_current, ll_other;
8098 vik_coord_to_latlon ( &tp_current->coord, &ll_current );
8099 vik_coord_to_latlon ( &tp_other->coord, &ll_other );
8100
8101 /* main positional interpolation */
8102 struct LatLon ll_new = { (ll_current.lat+ll_other.lat)/2, (ll_current.lon+ll_other.lon)/2 };
8103 vik_coord_load_from_latlon ( &(tp_new->coord), vtl->coord_mode, &ll_new );
8104
8105 /* Now other properties that can be interpolated */
8106 tp_new->altitude = (tp_current->altitude + tp_other->altitude) / 2;
8107
8108 if (tp_current->has_timestamp && tp_other->has_timestamp) {
8109 /* Note here the division is applied to each part, then added
8110 This is to avoid potential overflow issues with a 32 time_t for dates after midpoint of this Unix time on 2004/01/04 */
8111 tp_new->timestamp = (tp_current->timestamp/2) + (tp_other->timestamp/2);
8112 tp_new->has_timestamp = TRUE;
8113 }
8114
8115 if (tp_current->speed != NAN && tp_other->speed != NAN)
8116 tp_new->speed = (tp_current->speed + tp_other->speed)/2;
8117
8118 /* TODO - improve interpolation of course, as it may not be correct.
8119 if courses in degrees are 350 + 020, the mid course more likely to be 005 (not 185)
8120 [similar applies if value is in radians] */
8121 if (tp_current->course != NAN && tp_other->course != NAN)
8122 tp_new->course = (tp_current->course + tp_other->course)/2;
8123
8124 /* DOP / sat values remain at defaults as not they do not seem applicable to a dreamt up point */
8125
8126 // Insert new point into the appropriate trackpoint list, either before or after the current trackpoint as directed
8127 VikTrack *trk = g_hash_table_lookup ( vtl->tracks, vtl->current_tp_id );
8128 if ( !trk )
8129 // Otherwise try routes
8130 trk = g_hash_table_lookup ( vtl->routes, vtl->current_tp_id );
8131 if ( !trk )
8132 return;
8133
8134 gint index = g_list_index ( trk->trackpoints, tp_current );
8135 if ( index > -1 ) {
8136 if ( !before )
8137 index = index + 1;
8138 // NB no recalculation of bounds since it is inserted between points
8139 trk->trackpoints = g_list_insert ( trk->trackpoints, tp_new, index );
8140 }
8141 }
8142}
8143
8144static void trw_layer_cancel_current_tp ( VikTrwLayer *vtl, gboolean destroy )
8145{
8146 if ( vtl->tpwin )
8147 {
8148 if ( destroy)
8149 {
8150 gtk_widget_destroy ( GTK_WIDGET(vtl->tpwin) );
8151 vtl->tpwin = NULL;
8152 }
8153 else
8154 vik_trw_layer_tpwin_set_empty ( vtl->tpwin );
8155 }
8156 if ( vtl->current_tpl )
8157 {
8158 vtl->current_tpl = NULL;
8159 vtl->current_tp_track = NULL;
8160 vtl->current_tp_id = NULL;
8161 vik_layer_emit_update(VIK_LAYER(vtl));
8162 }
8163}
8164
8165static void trw_layer_tpwin_response ( VikTrwLayer *vtl, gint response )
8166{
8167 g_assert ( vtl->tpwin != NULL );
8168 if ( response == VIK_TRW_LAYER_TPWIN_CLOSE )
8169 trw_layer_cancel_current_tp ( vtl, TRUE );
8170
8171 if ( vtl->current_tpl == NULL )
8172 return;
8173
8174 if ( response == VIK_TRW_LAYER_TPWIN_SPLIT && vtl->current_tpl->next && vtl->current_tpl->prev )
8175 {
8176 trw_layer_split_at_selected_trackpoint ( vtl, vtl->current_tp_track->is_route ? VIK_TRW_LAYER_SUBLAYER_ROUTE : VIK_TRW_LAYER_SUBLAYER_TRACK );
8177 vik_trw_layer_tpwin_set_tp ( vtl->tpwin, vtl->current_tpl, vtl->current_tp_track->name );
8178 }
8179 else if ( response == VIK_TRW_LAYER_TPWIN_DELETE )
8180 {
8181 VikTrack *tr = g_hash_table_lookup ( vtl->tracks, vtl->current_tp_id );
8182 if ( tr == NULL )
8183 tr = g_hash_table_lookup ( vtl->routes, vtl->current_tp_id );
8184 if ( tr == NULL )
8185 return;
8186
8187 trw_layer_trackpoint_selected_delete ( vtl, tr );
8188
8189 if ( vtl->current_tpl )
8190 // Reset dialog with the available adjacent trackpoint
8191 vik_trw_layer_tpwin_set_tp ( vtl->tpwin, vtl->current_tpl, vtl->current_tp_track->name );
8192
8193 vik_layer_emit_update(VIK_LAYER(vtl));
8194 }
8195 else if ( response == VIK_TRW_LAYER_TPWIN_FORWARD && vtl->current_tpl->next )
8196 {
8197 if ( vtl->current_tp_track )
8198 vik_trw_layer_tpwin_set_tp ( vtl->tpwin, vtl->current_tpl = vtl->current_tpl->next, vtl->current_tp_track->name );
8199 vik_layer_emit_update(VIK_LAYER(vtl)); /* TODO longone: either move or only update if tp is inside drawing window */
8200 }
8201 else if ( response == VIK_TRW_LAYER_TPWIN_BACK && vtl->current_tpl->prev )
8202 {
8203 if ( vtl->current_tp_track )
8204 vik_trw_layer_tpwin_set_tp ( vtl->tpwin, vtl->current_tpl = vtl->current_tpl->prev, vtl->current_tp_track->name );
8205 vik_layer_emit_update(VIK_LAYER(vtl));
8206 }
8207 else if ( response == VIK_TRW_LAYER_TPWIN_INSERT && vtl->current_tpl->next )
8208 {
8209 trw_layer_insert_tp_beside_current_tp ( vtl, FALSE );
8210 vik_layer_emit_update(VIK_LAYER(vtl));
8211 }
8212 else if ( response == VIK_TRW_LAYER_TPWIN_DATA_CHANGED )
8213 vik_layer_emit_update(VIK_LAYER(vtl));
8214}
8215
8216/**
8217 * trw_layer_dialog_shift:
8218 * @vertical: The reposition strategy. If Vertical moves dialog vertically, otherwise moves it horizontally
8219 *
8220 * Try to reposition a dialog if it's over the specified coord
8221 * so to not obscure the item of interest
8222 */
8223void trw_layer_dialog_shift ( VikTrwLayer *vtl, GtkWindow *dialog, VikCoord *coord, gboolean vertical )
8224{
8225 GtkWindow *parent = VIK_GTK_WINDOW_FROM_LAYER(vtl); //i.e. the main window
8226
8227 // Attempt force dialog to be shown so we can find out where it is more reliably...
8228 while ( gtk_events_pending() )
8229 gtk_main_iteration ();
8230
8231 // get parent window position & size
8232 gint win_pos_x, win_pos_y;
8233 gtk_window_get_position ( parent, &win_pos_x, &win_pos_y );
8234
8235 gint win_size_x, win_size_y;
8236 gtk_window_get_size ( parent, &win_size_x, &win_size_y );
8237
8238 // get own dialog size
8239 gint dia_size_x, dia_size_y;
8240 gtk_window_get_size ( dialog, &dia_size_x, &dia_size_y );
8241
8242 // get own dialog position
8243 gint dia_pos_x, dia_pos_y;
8244 gtk_window_get_position ( dialog, &dia_pos_x, &dia_pos_y );
8245
8246 // Dialog not 'realized'/positioned - so can't really do any repositioning logic
8247 if ( dia_pos_x > 2 && dia_pos_y > 2 ) {
8248
8249 VikViewport *vvp = vik_window_viewport ( VIK_WINDOW(VIK_GTK_WINDOW_FROM_LAYER(vtl)) );
8250
8251 gint vp_xx, vp_yy; // In viewport pixels
8252 vik_viewport_coord_to_screen ( vvp, coord, &vp_xx, &vp_yy );
8253
8254 // Work out the 'bounding box' in pixel terms of the dialog and only move it when over the position
8255
8256 gint dest_x = 0;
8257 gint dest_y = 0;
8258 if ( gtk_widget_translate_coordinates ( GTK_WIDGET(vvp), GTK_WIDGET(parent), 0, 0, &dest_x, &dest_y ) ) {
8259
8260 // Transform Viewport pixels into absolute pixels
8261 gint tmp_xx = vp_xx + dest_x + win_pos_x - 10;
8262 gint tmp_yy = vp_yy + dest_y + win_pos_y - 10;
8263
8264 // Is dialog over the point (to within an ^^ edge value)
8265 if ( (tmp_xx > dia_pos_x) && (tmp_xx < (dia_pos_x + dia_size_x)) &&
8266 (tmp_yy > dia_pos_y) && (tmp_yy < (dia_pos_y + dia_size_y)) ) {
8267
8268 if ( vertical ) {
8269 // Shift up<->down
8270 gint hh = vik_viewport_get_height ( vvp );
8271
8272 // Consider the difference in viewport to the full window
8273 gint offset_y = dest_y;
8274 // Add difference between dialog and window sizes
8275 offset_y += win_pos_y + (hh/2 - dia_size_y)/2;
8276
8277 if ( vp_yy > hh/2 ) {
8278 // Point in bottom half, move window to top half
8279 gtk_window_move ( dialog, dia_pos_x, offset_y );
8280 }
8281 else {
8282 // Point in top half, move dialog down
8283 gtk_window_move ( dialog, dia_pos_x, hh/2 + offset_y );
8284 }
8285 }
8286 else {
8287 // Shift left<->right
8288 gint ww = vik_viewport_get_width ( vvp );
8289
8290 // Consider the difference in viewport to the full window
8291 gint offset_x = dest_x;
8292 // Add difference between dialog and window sizes
8293 offset_x += win_pos_x + (ww/2 - dia_size_x)/2;
8294
8295 if ( vp_xx > ww/2 ) {
8296 // Point on right, move window to left
8297 gtk_window_move ( dialog, offset_x, dia_pos_y );
8298 }
8299 else {
8300 // Point on left, move right
8301 gtk_window_move ( dialog, ww/2 + offset_x, dia_pos_y );
8302 }
8303 }
8304 }
8305 }
8306 }
8307}
8308
8309static void trw_layer_tpwin_init ( VikTrwLayer *vtl )
8310{
8311 if ( ! vtl->tpwin )
8312 {
8313 vtl->tpwin = vik_trw_layer_tpwin_new ( VIK_GTK_WINDOW_FROM_LAYER(vtl) );
8314 g_signal_connect_swapped ( GTK_DIALOG(vtl->tpwin), "response", G_CALLBACK(trw_layer_tpwin_response), vtl );
8315 /* connect signals -- DELETE SIGNAL VERY IMPORTANT TO SET TO NULL */
8316 g_signal_connect_swapped ( vtl->tpwin, "delete-event", G_CALLBACK(trw_layer_cancel_current_tp), vtl );
8317
8318 gtk_widget_show_all ( GTK_WIDGET(vtl->tpwin) );
8319
8320 if ( vtl->current_tpl ) {
8321 // get tp pixel position
8322 VikTrackpoint *tp = VIK_TRACKPOINT(vtl->current_tpl->data);
8323
8324 // Shift up<->down to try not to obscure the trackpoint.
8325 trw_layer_dialog_shift ( vtl, GTK_WINDOW(vtl->tpwin), &(tp->coord), TRUE );
8326 }
8327 }
8328
8329 if ( vtl->current_tpl )
8330 if ( vtl->current_tp_track )
8331 vik_trw_layer_tpwin_set_tp ( vtl->tpwin, vtl->current_tpl, vtl->current_tp_track->name );
8332 /* set layer name and TP data */
8333}
8334
8335/***************************************************************************
8336 ** Tool code
8337 ***************************************************************************/
8338
8339/*** Utility data structures and functions ****/
8340
8341typedef struct {
8342 gint x, y;
8343 gint closest_x, closest_y;
8344 gboolean draw_images;
8345 gpointer *closest_wp_id;
8346 VikWaypoint *closest_wp;
8347 VikViewport *vvp;
8348} WPSearchParams;
8349
8350typedef struct {
8351 gint x, y;
8352 gint closest_x, closest_y;
8353 gpointer closest_track_id;
8354 VikTrackpoint *closest_tp;
8355 VikViewport *vvp;
8356 GList *closest_tpl;
8357 LatLonBBox bbox;
8358} TPSearchParams;
8359
8360static void waypoint_search_closest_tp ( gpointer id, VikWaypoint *wp, WPSearchParams *params )
8361{
8362 gint x, y;
8363 if ( !wp->visible )
8364 return;
8365
8366 vik_viewport_coord_to_screen ( params->vvp, &(wp->coord), &x, &y );
8367
8368 // If waypoint has an image then use the image size to select
8369 if ( params->draw_images && wp->image ) {
8370 gint slackx, slacky;
8371 slackx = wp->image_width / 2;
8372 slacky = wp->image_height / 2;
8373
8374 if ( x <= params->x + slackx && x >= params->x - slackx
8375 && y <= params->y + slacky && y >= params->y - slacky ) {
8376 params->closest_wp_id = id;
8377 params->closest_wp = wp;
8378 params->closest_x = x;
8379 params->closest_y = y;
8380 }
8381 }
8382 else if ( abs (x - params->x) <= WAYPOINT_SIZE_APPROX && abs (y - params->y) <= WAYPOINT_SIZE_APPROX &&
8383 ((!params->closest_wp) || /* was the old waypoint we already found closer than this one? */
8384 abs(x - params->x)+abs(y - params->y) < abs(x - params->closest_x)+abs(y - params->closest_y)))
8385 {
8386 params->closest_wp_id = id;
8387 params->closest_wp = wp;
8388 params->closest_x = x;
8389 params->closest_y = y;
8390 }
8391}
8392
8393static void track_search_closest_tp ( gpointer id, VikTrack *t, TPSearchParams *params )
8394{
8395 GList *tpl = t->trackpoints;
8396 VikTrackpoint *tp;
8397
8398 if ( !t->visible )
8399 return;
8400
8401 if ( ! BBOX_INTERSECT ( t->bbox, params->bbox ) )
8402 return;
8403
8404 while (tpl)
8405 {
8406 gint x, y;
8407 tp = VIK_TRACKPOINT(tpl->data);
8408
8409 vik_viewport_coord_to_screen ( params->vvp, &(tp->coord), &x, &y );
8410
8411 if ( abs (x - params->x) <= TRACKPOINT_SIZE_APPROX && abs (y - params->y) <= TRACKPOINT_SIZE_APPROX &&
8412 ((!params->closest_tp) || /* was the old trackpoint we already found closer than this one? */
8413 abs(x - params->x)+abs(y - params->y) < abs(x - params->closest_x)+abs(y - params->closest_y)))
8414 {
8415 params->closest_track_id = id;
8416 params->closest_tp = tp;
8417 params->closest_tpl = tpl;
8418 params->closest_x = x;
8419 params->closest_y = y;
8420 }
8421 tpl = tpl->next;
8422 }
8423}
8424
8425// ATM: Leave this as 'Track' only.
8426// Not overly bothered about having a snap to route trackpoint capability
8427static VikTrackpoint *closest_tp_in_five_pixel_interval ( VikTrwLayer *vtl, VikViewport *vvp, gint x, gint y )
8428{
8429 TPSearchParams params;
8430 params.x = x;
8431 params.y = y;
8432 params.vvp = vvp;
8433 params.closest_track_id = NULL;
8434 params.closest_tp = NULL;
8435 vik_viewport_get_min_max_lat_lon ( params.vvp, &(params.bbox.south), &(params.bbox.north), &(params.bbox.west), &(params.bbox.east) );
8436 g_hash_table_foreach ( vtl->tracks, (GHFunc) track_search_closest_tp, &params);
8437 return params.closest_tp;
8438}
8439
8440static VikWaypoint *closest_wp_in_five_pixel_interval ( VikTrwLayer *vtl, VikViewport *vvp, gint x, gint y )
8441{
8442 WPSearchParams params;
8443 params.x = x;
8444 params.y = y;
8445 params.vvp = vvp;
8446 params.draw_images = vtl->drawimages;
8447 params.closest_wp = NULL;
8448 params.closest_wp_id = NULL;
8449 g_hash_table_foreach ( vtl->waypoints, (GHFunc) waypoint_search_closest_tp, &params);
8450 return params.closest_wp;
8451}
8452
8453
8454// Some forward declarations
8455static void marker_begin_move ( tool_ed_t *t, gint x, gint y );
8456static void marker_moveto ( tool_ed_t *t, gint x, gint y );
8457static void marker_end_move ( tool_ed_t *t );
8458//
8459
8460static gboolean trw_layer_select_move ( VikTrwLayer *vtl, GdkEventButton *event, VikViewport *vvp, tool_ed_t* t )
8461{
8462 if ( t->holding ) {
8463 VikCoord new_coord;
8464 vik_viewport_screen_to_coord ( vvp, event->x, event->y, &new_coord );
8465
8466 // Here always allow snapping back to the original location
8467 // this is useful when one decides not to move the thing afterall
8468 // If one wants to move the item only a little bit then don't hold down the 'snap' key!
8469
8470 // snap to TP
8471 if ( event->state & GDK_CONTROL_MASK )
8472 {
8473 VikTrackpoint *tp = closest_tp_in_five_pixel_interval ( vtl, vvp, event->x, event->y );
8474 if ( tp )
8475 new_coord = tp->coord;
8476 }
8477
8478 // snap to WP
8479 if ( event->state & GDK_SHIFT_MASK )
8480 {
8481 VikWaypoint *wp = closest_wp_in_five_pixel_interval ( vtl, vvp, event->x, event->y );
8482 if ( wp )
8483 new_coord = wp->coord;
8484 }
8485
8486 gint x, y;
8487 vik_viewport_coord_to_screen ( vvp, &new_coord, &x, &y );
8488
8489 marker_moveto ( t, x, y );
8490
8491 return TRUE;
8492 }
8493 return FALSE;
8494}
8495
8496static gboolean trw_layer_select_release ( VikTrwLayer *vtl, GdkEventButton *event, VikViewport *vvp, tool_ed_t* t )
8497{
8498 if ( t->holding && event->button == 1 )
8499 {
8500 VikCoord new_coord;
8501 vik_viewport_screen_to_coord ( vvp, event->x, event->y, &new_coord );
8502
8503 // snap to TP
8504 if ( event->state & GDK_CONTROL_MASK )
8505 {
8506 VikTrackpoint *tp = closest_tp_in_five_pixel_interval ( vtl, vvp, event->x, event->y );
8507 if ( tp )
8508 new_coord = tp->coord;
8509 }
8510
8511 // snap to WP
8512 if ( event->state & GDK_SHIFT_MASK )
8513 {
8514 VikWaypoint *wp = closest_wp_in_five_pixel_interval ( vtl, vvp, event->x, event->y );
8515 if ( wp )
8516 new_coord = wp->coord;
8517 }
8518
8519 marker_end_move ( t );
8520
8521 // Determine if working on a waypoint or a trackpoint
8522 if ( t->is_waypoint ) {
8523 // Update waypoint position
8524 vtl->current_wp->coord = new_coord;
8525 trw_layer_calculate_bounds_waypoints ( vtl );
8526 // Reset waypoint pointer
8527 vtl->current_wp = NULL;
8528 vtl->current_wp_id = NULL;
8529 }
8530 else {
8531 if ( vtl->current_tpl ) {
8532 VIK_TRACKPOINT(vtl->current_tpl->data)->coord = new_coord;
8533
8534 if ( vtl->current_tp_track )
8535 vik_track_calculate_bounds ( vtl->current_tp_track );
8536
8537 if ( vtl->tpwin )
8538 if ( vtl->current_tp_track )
8539 vik_trw_layer_tpwin_set_tp ( vtl->tpwin, vtl->current_tpl, vtl->current_tp_track->name );
8540 // NB don't reset the selected trackpoint, thus ensuring it's still in the tpwin
8541 }
8542 }
8543
8544 vik_layer_emit_update ( VIK_LAYER(vtl) );
8545 return TRUE;
8546 }
8547 return FALSE;
8548}
8549
8550/*
8551 Returns true if a waypoint or track is found near the requested event position for this particular layer
8552 The item found is automatically selected
8553 This is a tool like feature but routed via the layer interface, since it's instigated by a 'global' layer tool in vikwindow.c
8554 */
8555static gboolean trw_layer_select_click ( VikTrwLayer *vtl, GdkEventButton *event, VikViewport *vvp, tool_ed_t* tet )
8556{
8557 if ( event->button != 1 )
8558 return FALSE;
8559
8560 if (!vtl || vtl->vl.type != VIK_LAYER_TRW)
8561 return FALSE;
8562
8563 if ( !vtl->tracks_visible && !vtl->waypoints_visible && !vtl->routes_visible )
8564 return FALSE;
8565
8566 LatLonBBox bbox;
8567 vik_viewport_get_min_max_lat_lon ( vvp, &(bbox.south), &(bbox.north), &(bbox.west), &(bbox.east) );
8568
8569 // Go for waypoints first as these often will be near a track, but it's likely the wp is wanted rather then the track
8570
8571 if ( vtl->waypoints_visible && BBOX_INTERSECT (vtl->waypoints_bbox, bbox ) ) {
8572 WPSearchParams wp_params;
8573 wp_params.vvp = vvp;
8574 wp_params.x = event->x;
8575 wp_params.y = event->y;
8576 wp_params.draw_images = vtl->drawimages;
8577 wp_params.closest_wp_id = NULL;
8578 wp_params.closest_wp = NULL;
8579
8580 g_hash_table_foreach ( vtl->waypoints, (GHFunc) waypoint_search_closest_tp, &wp_params);
8581
8582 if ( wp_params.closest_wp ) {
8583
8584 // Select
8585 vik_treeview_select_iter ( VIK_LAYER(vtl)->vt, g_hash_table_lookup ( vtl->waypoints_iters, wp_params.closest_wp_id ), TRUE );
8586
8587 // Too easy to move it so must be holding shift to start immediately moving it
8588 // or otherwise be previously selected but not have an image (otherwise clicking within image bounds (again) moves it)
8589 if ( event->state & GDK_SHIFT_MASK ||
8590 ( vtl->current_wp == wp_params.closest_wp && !vtl->current_wp->image ) ) {
8591 // Put into 'move buffer'
8592 // NB vvp & vw already set in tet
8593 tet->vtl = (gpointer)vtl;
8594 tet->is_waypoint = TRUE;
8595
8596 marker_begin_move (tet, event->x, event->y);
8597 }
8598
8599 vtl->current_wp = wp_params.closest_wp;
8600 vtl->current_wp_id = wp_params.closest_wp_id;
8601
8602 vik_layer_emit_update ( VIK_LAYER(vtl) );
8603
8604 return TRUE;
8605 }
8606 }
8607
8608 // Used for both track and route lists
8609 TPSearchParams tp_params;
8610 tp_params.vvp = vvp;
8611 tp_params.x = event->x;
8612 tp_params.y = event->y;
8613 tp_params.closest_track_id = NULL;
8614 tp_params.closest_tp = NULL;
8615 tp_params.closest_tpl = NULL;
8616 tp_params.bbox = bbox;
8617
8618 if (vtl->tracks_visible) {
8619 g_hash_table_foreach ( vtl->tracks, (GHFunc) track_search_closest_tp, &tp_params);
8620
8621 if ( tp_params.closest_tp ) {
8622
8623 // Always select + highlight the track
8624 vik_treeview_select_iter ( VIK_LAYER(vtl)->vt, g_hash_table_lookup ( vtl->tracks_iters, tp_params.closest_track_id ), TRUE );
8625
8626 tet->is_waypoint = FALSE;
8627
8628 // Select the Trackpoint
8629 // Can move it immediately when control held or it's the previously selected tp
8630 if ( event->state & GDK_CONTROL_MASK ||
8631 vtl->current_tpl == tp_params.closest_tpl ) {
8632 // Put into 'move buffer'
8633 // NB vvp & vw already set in tet
8634 tet->vtl = (gpointer)vtl;
8635 marker_begin_move (tet, event->x, event->y);
8636 }
8637
8638 vtl->current_tpl = tp_params.closest_tpl;
8639 vtl->current_tp_id = tp_params.closest_track_id;
8640 vtl->current_tp_track = g_hash_table_lookup ( vtl->tracks, tp_params.closest_track_id );
8641
8642 set_statusbar_msg_info_trkpt ( vtl, tp_params.closest_tp );
8643
8644 if ( vtl->tpwin )
8645 vik_trw_layer_tpwin_set_tp ( vtl->tpwin, vtl->current_tpl, vtl->current_tp_track->name );
8646
8647 vik_layer_emit_update ( VIK_LAYER(vtl) );
8648 return TRUE;
8649 }
8650 }
8651
8652 // Try again for routes
8653 if (vtl->routes_visible) {
8654 g_hash_table_foreach ( vtl->routes, (GHFunc) track_search_closest_tp, &tp_params);
8655
8656 if ( tp_params.closest_tp ) {
8657
8658 // Always select + highlight the track
8659 vik_treeview_select_iter ( VIK_LAYER(vtl)->vt, g_hash_table_lookup ( vtl->routes_iters, tp_params.closest_track_id ), TRUE );
8660
8661 tet->is_waypoint = FALSE;
8662
8663 // Select the Trackpoint
8664 // Can move it immediately when control held or it's the previously selected tp
8665 if ( event->state & GDK_CONTROL_MASK ||
8666 vtl->current_tpl == tp_params.closest_tpl ) {
8667 // Put into 'move buffer'
8668 // NB vvp & vw already set in tet
8669 tet->vtl = (gpointer)vtl;
8670 marker_begin_move (tet, event->x, event->y);
8671 }
8672
8673 vtl->current_tpl = tp_params.closest_tpl;
8674 vtl->current_tp_id = tp_params.closest_track_id;
8675 vtl->current_tp_track = g_hash_table_lookup ( vtl->routes, tp_params.closest_track_id );
8676
8677 set_statusbar_msg_info_trkpt ( vtl, tp_params.closest_tp );
8678
8679 if ( vtl->tpwin )
8680 vik_trw_layer_tpwin_set_tp ( vtl->tpwin, vtl->current_tpl, vtl->current_tp_track->name );
8681
8682 vik_layer_emit_update ( VIK_LAYER(vtl) );
8683 return TRUE;
8684 }
8685 }
8686
8687 /* these aren't the droids you're looking for */
8688 vtl->current_wp = NULL;
8689 vtl->current_wp_id = NULL;
8690 trw_layer_cancel_current_tp ( vtl, FALSE );
8691
8692 // Blank info
8693 vik_statusbar_set_message ( vik_window_get_statusbar (VIK_WINDOW(VIK_GTK_WINDOW_FROM_LAYER(vtl))), VIK_STATUSBAR_INFO, "" );
8694
8695 return FALSE;
8696}
8697
8698static gboolean trw_layer_show_selected_viewport_menu ( VikTrwLayer *vtl, GdkEventButton *event, VikViewport *vvp )
8699{
8700 if ( event->button != 3 )
8701 return FALSE;
8702
8703 if (!vtl || vtl->vl.type != VIK_LAYER_TRW)
8704 return FALSE;
8705
8706 if ( !vtl->tracks_visible && !vtl->waypoints_visible && !vtl->routes_visible )
8707 return FALSE;
8708
8709 /* Post menu for the currently selected item */
8710
8711 /* See if a track is selected */
8712 VikTrack *track = (VikTrack*)vik_window_get_selected_track ( (VikWindow *)VIK_GTK_WINDOW_FROM_LAYER(vtl) );
8713 if ( track && track->visible ) {
8714
8715 if ( track->name ) {
8716
8717 if ( vtl->track_right_click_menu )
8718 g_object_ref_sink ( G_OBJECT(vtl->track_right_click_menu) );
8719
8720 vtl->track_right_click_menu = GTK_MENU ( gtk_menu_new () );
8721
8722 trku_udata udataU;
8723 udataU.trk = track;
8724 udataU.uuid = NULL;
8725
8726 gpointer *trkf;
8727 if ( track->is_route )
8728 trkf = g_hash_table_find ( vtl->routes, (GHRFunc) trw_layer_track_find_uuid, &udataU );
8729 else
8730 trkf = g_hash_table_find ( vtl->tracks, (GHRFunc) trw_layer_track_find_uuid, &udataU );
8731
8732 if ( trkf && udataU.uuid ) {
8733
8734 GtkTreeIter *iter;
8735 if ( track->is_route )
8736 iter = g_hash_table_lookup ( vtl->routes_iters, udataU.uuid );
8737 else
8738 iter = g_hash_table_lookup ( vtl->tracks_iters, udataU.uuid );
8739
8740 trw_layer_sublayer_add_menu_items ( vtl,
8741 vtl->track_right_click_menu,
8742 NULL,
8743 track->is_route ? VIK_TRW_LAYER_SUBLAYER_ROUTE : VIK_TRW_LAYER_SUBLAYER_TRACK,
8744 udataU.uuid,
8745 iter,
8746 vvp );
8747 }
8748
8749 gtk_menu_popup ( vtl->track_right_click_menu, NULL, NULL, NULL, NULL, event->button, gtk_get_current_event_time() );
8750
8751 return TRUE;
8752 }
8753 }
8754
8755 /* See if a waypoint is selected */
8756 VikWaypoint *waypoint = (VikWaypoint*)vik_window_get_selected_waypoint ( (VikWindow *)VIK_GTK_WINDOW_FROM_LAYER(vtl) );
8757 if ( waypoint && waypoint->visible ) {
8758 if ( waypoint->name ) {
8759
8760 if ( vtl->wp_right_click_menu )
8761 g_object_ref_sink ( G_OBJECT(vtl->wp_right_click_menu) );
8762
8763 vtl->wp_right_click_menu = GTK_MENU ( gtk_menu_new () );
8764
8765 wpu_udata udata;
8766 udata.wp = waypoint;
8767 udata.uuid = NULL;
8768
8769 gpointer *wpf = g_hash_table_find ( vtl->waypoints, (GHRFunc) trw_layer_waypoint_find_uuid, (gpointer) &udata );
8770
8771 if ( wpf && udata.uuid ) {
8772 GtkTreeIter *iter = g_hash_table_lookup ( vtl->waypoints_iters, udata.uuid );
8773
8774 trw_layer_sublayer_add_menu_items ( vtl,
8775 vtl->wp_right_click_menu,
8776 NULL,
8777 VIK_TRW_LAYER_SUBLAYER_WAYPOINT,
8778 udata.uuid,
8779 iter,
8780 vvp );
8781 }
8782 gtk_menu_popup ( vtl->wp_right_click_menu, NULL, NULL, NULL, NULL, event->button, gtk_get_current_event_time() );
8783
8784 return TRUE;
8785 }
8786 }
8787
8788 return FALSE;
8789}
8790
8791/* background drawing hook, to be passed the viewport */
8792static gboolean tool_sync_done = TRUE;
8793
8794static gboolean tool_sync(gpointer data)
8795{
8796 VikViewport *vvp = data;
8797 gdk_threads_enter();
8798 vik_viewport_sync(vvp);
8799 tool_sync_done = TRUE;
8800 gdk_threads_leave();
8801 return FALSE;
8802}
8803
8804static void marker_begin_move ( tool_ed_t *t, gint x, gint y )
8805{
8806 t->holding = TRUE;
8807 t->gc = vik_viewport_new_gc (t->vvp, "black", 2);
8808 gdk_gc_set_function ( t->gc, GDK_INVERT );
8809 vik_viewport_draw_rectangle ( t->vvp, t->gc, FALSE, x-3, y-3, 6, 6 );
8810 vik_viewport_sync(t->vvp);
8811 t->oldx = x;
8812 t->oldy = y;
8813}
8814
8815static void marker_moveto ( tool_ed_t *t, gint x, gint y )
8816{
8817 VikViewport *vvp = t->vvp;
8818 vik_viewport_draw_rectangle ( vvp, t->gc, FALSE, t->oldx-3, t->oldy-3, 6, 6 );
8819 vik_viewport_draw_rectangle ( vvp, t->gc, FALSE, x-3, y-3, 6, 6 );
8820 t->oldx = x;
8821 t->oldy = y;
8822
8823 if (tool_sync_done) {
8824 g_idle_add_full (G_PRIORITY_HIGH_IDLE + 10, tool_sync, vvp, NULL);
8825 tool_sync_done = FALSE;
8826 }
8827}
8828
8829static void marker_end_move ( tool_ed_t *t )
8830{
8831 vik_viewport_draw_rectangle ( t->vvp, t->gc, FALSE, t->oldx-3, t->oldy-3, 6, 6 );
8832 g_object_unref ( t->gc );
8833 t->holding = FALSE;
8834}
8835
8836/*** Edit waypoint ****/
8837
8838static gpointer tool_edit_waypoint_create ( VikWindow *vw, VikViewport *vvp)
8839{
8840 tool_ed_t *t = g_new(tool_ed_t, 1);
8841 t->vvp = vvp;
8842 t->holding = FALSE;
8843 return t;
8844}
8845
8846static void tool_edit_waypoint_destroy ( tool_ed_t *t )
8847{
8848 g_free ( t );
8849}
8850
8851static gboolean tool_edit_waypoint_click ( VikTrwLayer *vtl, GdkEventButton *event, gpointer data )
8852{
8853 WPSearchParams params;
8854 tool_ed_t *t = data;
8855 VikViewport *vvp = t->vvp;
8856
8857 if (!vtl || vtl->vl.type != VIK_LAYER_TRW)
8858 return FALSE;
8859
8860 if ( t->holding ) {
8861 return TRUE;
8862 }
8863
8864 if ( !vtl->vl.visible || !vtl->waypoints_visible )
8865 return FALSE;
8866
8867 if ( vtl->current_wp && vtl->current_wp->visible )
8868 {
8869 /* first check if current WP is within area (other may be 'closer', but we want to move the current) */
8870 gint x, y;
8871 vik_viewport_coord_to_screen ( vvp, &(vtl->current_wp->coord), &x, &y );
8872
8873 if ( abs(x - event->x) <= WAYPOINT_SIZE_APPROX &&
8874 abs(y - event->y) <= WAYPOINT_SIZE_APPROX )
8875 {
8876 if ( event->button == 3 )
8877 vtl->waypoint_rightclick = TRUE; /* remember that we're clicking; other layers will ignore release signal */
8878 else {
8879 marker_begin_move(t, event->x, event->y);
8880 }
8881 return TRUE;
8882 }
8883 }
8884
8885 params.vvp = vvp;
8886 params.x = event->x;
8887 params.y = event->y;
8888 params.draw_images = vtl->drawimages;
8889 params.closest_wp_id = NULL;
8890 /* TODO: should get track listitem so we can break it up, make a new track, mess it up, all that. */
8891 params.closest_wp = NULL;
8892 g_hash_table_foreach ( vtl->waypoints, (GHFunc) waypoint_search_closest_tp, &params);
8893 if ( vtl->current_wp == params.closest_wp && vtl->current_wp != NULL )
8894 {
8895 // how do we get here?
8896 marker_begin_move(t, event->x, event->y);
8897 g_critical("shouldn't be here");
8898 return FALSE;
8899 }
8900 else if ( params.closest_wp )
8901 {
8902 if ( event->button == 3 )
8903 vtl->waypoint_rightclick = TRUE; /* remember that we're clicking; other layers will ignore release signal */
8904 else
8905 vtl->waypoint_rightclick = FALSE;
8906
8907 vik_treeview_select_iter ( VIK_LAYER(vtl)->vt, g_hash_table_lookup ( vtl->waypoints_iters, params.closest_wp_id ), TRUE );
8908
8909 vtl->current_wp = params.closest_wp;
8910 vtl->current_wp_id = params.closest_wp_id;
8911
8912 /* could make it so don't update if old WP is off screen and new is null but oh well */
8913 vik_layer_emit_update ( VIK_LAYER(vtl) );
8914 return TRUE;
8915 }
8916
8917 vtl->current_wp = NULL;
8918 vtl->current_wp_id = NULL;
8919 vtl->waypoint_rightclick = FALSE;
8920 vik_layer_emit_update ( VIK_LAYER(vtl) );
8921 return FALSE;
8922}
8923
8924static gboolean tool_edit_waypoint_move ( VikTrwLayer *vtl, GdkEventMotion *event, gpointer data )
8925{
8926 tool_ed_t *t = data;
8927 VikViewport *vvp = t->vvp;
8928
8929 if (!vtl || vtl->vl.type != VIK_LAYER_TRW)
8930 return FALSE;
8931
8932 if ( t->holding ) {
8933 VikCoord new_coord;
8934 vik_viewport_screen_to_coord ( vvp, event->x, event->y, &new_coord );
8935
8936 /* snap to TP */
8937 if ( event->state & GDK_CONTROL_MASK )
8938 {
8939 VikTrackpoint *tp = closest_tp_in_five_pixel_interval ( vtl, vvp, event->x, event->y );
8940 if ( tp )
8941 new_coord = tp->coord;
8942 }
8943
8944 /* snap to WP */
8945 if ( event->state & GDK_SHIFT_MASK )
8946 {
8947 VikWaypoint *wp = closest_wp_in_five_pixel_interval ( vtl, vvp, event->x, event->y );
8948 if ( wp && wp != vtl->current_wp )
8949 new_coord = wp->coord;
8950 }
8951
8952 {
8953 gint x, y;
8954 vik_viewport_coord_to_screen ( vvp, &new_coord, &x, &y );
8955
8956 marker_moveto ( t, x, y );
8957 }
8958 return TRUE;
8959 }
8960 return FALSE;
8961}
8962
8963static gboolean tool_edit_waypoint_release ( VikTrwLayer *vtl, GdkEventButton *event, gpointer data )
8964{
8965 tool_ed_t *t = data;
8966 VikViewport *vvp = t->vvp;
8967
8968 if (!vtl || vtl->vl.type != VIK_LAYER_TRW)
8969 return FALSE;
8970
8971 if ( t->holding && event->button == 1 )
8972 {
8973 VikCoord new_coord;
8974 vik_viewport_screen_to_coord ( vvp, event->x, event->y, &new_coord );
8975
8976 /* snap to TP */
8977 if ( event->state & GDK_CONTROL_MASK )
8978 {
8979 VikTrackpoint *tp = closest_tp_in_five_pixel_interval ( vtl, vvp, event->x, event->y );
8980 if ( tp )
8981 new_coord = tp->coord;
8982 }
8983
8984 /* snap to WP */
8985 if ( event->state & GDK_SHIFT_MASK )
8986 {
8987 VikWaypoint *wp = closest_wp_in_five_pixel_interval ( vtl, vvp, event->x, event->y );
8988 if ( wp && wp != vtl->current_wp )
8989 new_coord = wp->coord;
8990 }
8991
8992 marker_end_move ( t );
8993
8994 vtl->current_wp->coord = new_coord;
8995
8996 trw_layer_calculate_bounds_waypoints ( vtl );
8997 vik_layer_emit_update ( VIK_LAYER(vtl) );
8998 return TRUE;
8999 }
9000 /* PUT IN RIGHT PLACE!!! */
9001 if ( event->button == 3 && vtl->waypoint_rightclick )
9002 {
9003 if ( vtl->wp_right_click_menu )
9004 g_object_ref_sink ( G_OBJECT(vtl->wp_right_click_menu) );
9005 if ( vtl->current_wp ) {
9006 vtl->wp_right_click_menu = GTK_MENU ( gtk_menu_new () );
9007 trw_layer_sublayer_add_menu_items ( vtl, vtl->wp_right_click_menu, NULL, VIK_TRW_LAYER_SUBLAYER_WAYPOINT, vtl->current_wp_id, g_hash_table_lookup ( vtl->waypoints_iters, vtl->current_wp_id ), vvp );
9008 gtk_menu_popup ( vtl->wp_right_click_menu, NULL, NULL, NULL, NULL, event->button, gtk_get_current_event_time() );
9009 }
9010 vtl->waypoint_rightclick = FALSE;
9011 }
9012 return FALSE;
9013}
9014
9015/*** New track ****/
9016
9017static gpointer tool_new_track_create ( VikWindow *vw, VikViewport *vvp)
9018{
9019 return vvp;
9020}
9021
9022typedef struct {
9023 VikTrwLayer *vtl;
9024 GdkDrawable *drawable;
9025 GdkGC *gc;
9026 GdkPixmap *pixmap;
9027} draw_sync_t;
9028
9029/*
9030 * Draw specified pixmap
9031 */
9032static gboolean draw_sync ( gpointer data )
9033{
9034 draw_sync_t *ds = (draw_sync_t*) data;
9035 // Sometimes don't want to draw
9036 // normally because another update has taken precedent such as panning the display
9037 // which means this pixmap is no longer valid
9038 if ( ds->vtl->draw_sync_do ) {
9039 gdk_threads_enter();
9040 gdk_draw_drawable (ds->drawable,
9041 ds->gc,
9042 ds->pixmap,
9043 0, 0, 0, 0, -1, -1);
9044 ds->vtl->draw_sync_done = TRUE;
9045 gdk_threads_leave();
9046 }
9047 g_free ( ds );
9048 return FALSE;
9049}
9050
9051static gchar* distance_string (gdouble distance)
9052{
9053 gchar str[128];
9054
9055 /* draw label with distance */
9056 vik_units_distance_t dist_units = a_vik_get_units_distance ();
9057 switch (dist_units) {
9058 case VIK_UNITS_DISTANCE_MILES:
9059 if (distance >= VIK_MILES_TO_METERS(1) && distance < VIK_MILES_TO_METERS(100)) {
9060 g_sprintf(str, "%3.2f miles", VIK_METERS_TO_MILES(distance));
9061 } else if (distance < 1609.4) {
9062 g_sprintf(str, "%d yards", (int)(distance*1.0936133));
9063 } else {
9064 g_sprintf(str, "%d miles", (int)VIK_METERS_TO_MILES(distance));
9065 }
9066 break;
9067 default:
9068 // VIK_UNITS_DISTANCE_KILOMETRES
9069 if (distance >= 1000 && distance < 100000) {
9070 g_sprintf(str, "%3.2f km", distance/1000.0);
9071 } else if (distance < 1000) {
9072 g_sprintf(str, "%d m", (int)distance);
9073 } else {
9074 g_sprintf(str, "%d km", (int)distance/1000);
9075 }
9076 break;
9077 }
9078 return g_strdup (str);
9079}
9080
9081/*
9082 * Actually set the message in statusbar
9083 */
9084static void statusbar_write (gdouble distance, gdouble elev_gain, gdouble elev_loss, gdouble last_step, gdouble angle, VikTrwLayer *vtl )
9085{
9086 // Only show elevation data when track has some elevation properties
9087 gchar str_gain_loss[64];
9088 str_gain_loss[0] = '\0';
9089 gchar str_last_step[64];
9090 str_last_step[0] = '\0';
9091 gchar *str_total = distance_string (distance);
9092
9093 if ( (elev_gain > 0.1) || (elev_loss > 0.1) ) {
9094 if ( a_vik_get_units_height () == VIK_UNITS_HEIGHT_METRES )
9095 g_sprintf(str_gain_loss, _(" - Gain %dm:Loss %dm"), (int)elev_gain, (int)elev_loss);
9096 else
9097 g_sprintf(str_gain_loss, _(" - Gain %dft:Loss %dft"), (int)VIK_METERS_TO_FEET(elev_gain), (int)VIK_METERS_TO_FEET(elev_loss));
9098 }
9099
9100 if ( last_step > 0 ) {
9101 gchar *tmp = distance_string (last_step);
9102 g_sprintf(str_last_step, _(" - Bearing %3.1f° - Step %s"), RAD2DEG(angle), tmp);
9103 g_free ( tmp );
9104 }
9105
9106 VikWindow *vw = VIK_WINDOW(VIK_GTK_WINDOW_FROM_LAYER(vtl));
9107
9108 // Write with full gain/loss information
9109 gchar *msg = g_strdup_printf ( "Total %s%s%s", str_total, str_last_step, str_gain_loss);
9110 vik_statusbar_set_message ( vik_window_get_statusbar (vw), VIK_STATUSBAR_INFO, msg );
9111 g_free ( msg );
9112 g_free ( str_total );
9113}
9114
9115/*
9116 * Figure out what information should be set in the statusbar and then write it
9117 */
9118static void update_statusbar ( VikTrwLayer *vtl )
9119{
9120 // Get elevation data
9121 gdouble elev_gain, elev_loss;
9122 vik_track_get_total_elevation_gain ( vtl->current_track, &elev_gain, &elev_loss);
9123
9124 /* Find out actual distance of current track */
9125 gdouble distance = vik_track_get_length (vtl->current_track);
9126
9127 statusbar_write (distance, elev_gain, elev_loss, 0, 0, vtl);
9128}
9129
9130
9131static VikLayerToolFuncStatus tool_new_track_move ( VikTrwLayer *vtl, GdkEventMotion *event, VikViewport *vvp )
9132{
9133 /* if we haven't sync'ed yet, we don't have time to do more. */
9134 if ( vtl->draw_sync_done && vtl->current_track && vtl->current_track->trackpoints ) {
9135 GList *iter = g_list_last ( vtl->current_track->trackpoints );
9136 VikTrackpoint *last_tpt = VIK_TRACKPOINT(iter->data);
9137
9138 static GdkPixmap *pixmap = NULL;
9139 int w1, h1, w2, h2;
9140 // Need to check in case window has been resized
9141 w1 = vik_viewport_get_width(vvp);
9142 h1 = vik_viewport_get_height(vvp);
9143 if (!pixmap) {
9144 pixmap = gdk_pixmap_new ( gtk_widget_get_window(GTK_WIDGET(vvp)), w1, h1, -1 );
9145 }
9146 gdk_drawable_get_size (pixmap, &w2, &h2);
9147 if (w1 != w2 || h1 != h2) {
9148 g_object_unref ( G_OBJECT ( pixmap ) );
9149 pixmap = gdk_pixmap_new ( gtk_widget_get_window(GTK_WIDGET(vvp)), w1, h1, -1 );
9150 }
9151
9152 // Reset to background
9153 gdk_draw_drawable (pixmap,
9154 vtl->current_track_newpoint_gc,
9155 vik_viewport_get_pixmap(vvp),
9156 0, 0, 0, 0, -1, -1);
9157
9158 draw_sync_t *passalong;
9159 gint x1, y1;
9160
9161 vik_viewport_coord_to_screen ( vvp, &(last_tpt->coord), &x1, &y1 );
9162
9163 // FOR SCREEN OVERLAYS WE MUST DRAW INTO THIS PIXMAP (when using the reset method)
9164 // otherwise using vik_viewport_draw_* functions puts the data into the base pixmap,
9165 // thus when we come to reset to the background it would include what we have already drawn!!
9166 gdk_draw_line ( pixmap,
9167 vtl->current_track_newpoint_gc,
9168 x1, y1, event->x, event->y );
9169 // Using this reset method is more reliable than trying to undraw previous efforts via the GDK_INVERT method
9170
9171 /* Find out actual distance of current track */
9172 gdouble distance = vik_track_get_length (vtl->current_track);
9173
9174 // Now add distance to where the pointer is //
9175 VikCoord coord;
9176 struct LatLon ll;
9177 vik_viewport_screen_to_coord ( vvp, (gint) event->x, (gint) event->y, &coord );
9178 vik_coord_to_latlon ( &coord, &ll );
9179 gdouble last_step = vik_coord_diff( &coord, &(last_tpt->coord));
9180 distance = distance + last_step;
9181
9182 // Get elevation data
9183 gdouble elev_gain, elev_loss;
9184 vik_track_get_total_elevation_gain ( vtl->current_track, &elev_gain, &elev_loss);
9185
9186 // Adjust elevation data (if available) for the current pointer position
9187 gdouble elev_new;
9188 elev_new = (gdouble) a_dems_get_elev_by_coord ( &coord, VIK_DEM_INTERPOL_BEST );
9189 if ( elev_new != VIK_DEM_INVALID_ELEVATION ) {
9190 if ( last_tpt->altitude != VIK_DEFAULT_ALTITUDE ) {
9191 // Adjust elevation of last track point
9192 if ( elev_new > last_tpt->altitude )
9193 // Going up
9194 elev_gain += elev_new - last_tpt->altitude;
9195 else
9196 // Going down
9197 elev_loss += last_tpt->altitude - elev_new;
9198 }
9199 }
9200
9201 //
9202 // Display of the distance 'tooltip' during track creation is controlled by a preference
9203 //
9204 if ( a_vik_get_create_track_tooltip() ) {
9205
9206 gchar *str = distance_string (distance);
9207
9208 PangoLayout *pl = gtk_widget_create_pango_layout (GTK_WIDGET(vvp), NULL);
9209 pango_layout_set_font_description (pl, gtk_widget_get_style(GTK_WIDGET(vvp))->font_desc);
9210 pango_layout_set_text (pl, str, -1);
9211 gint wd, hd;
9212 pango_layout_get_pixel_size ( pl, &wd, &hd );
9213
9214 gint xd,yd;
9215 // offset from cursor a bit depending on font size
9216 xd = event->x + 10;
9217 yd = event->y - hd;
9218
9219 // Create a background block to make the text easier to read over the background map
9220 GdkGC *background_block_gc = vik_viewport_new_gc ( vvp, "#cccccc", 1);
9221 gdk_draw_rectangle (pixmap, background_block_gc, TRUE, xd-2, yd-2, wd+4, hd+2);
9222 gdk_draw_layout (pixmap, vtl->current_track_newpoint_gc, xd, yd, pl);
9223
9224 g_object_unref ( G_OBJECT ( pl ) );
9225 g_object_unref ( G_OBJECT ( background_block_gc ) );
9226 g_free (str);
9227 }
9228
9229 passalong = g_new(draw_sync_t,1); // freed by draw_sync()
9230 passalong->vtl = vtl;
9231 passalong->pixmap = pixmap;
9232 passalong->drawable = gtk_widget_get_window(GTK_WIDGET(vvp));
9233 passalong->gc = vtl->current_track_newpoint_gc;
9234
9235 gdouble angle;
9236 gdouble baseangle;
9237 vik_viewport_compute_bearing ( vvp, x1, y1, event->x, event->y, &angle, &baseangle );
9238
9239 // Update statusbar with full gain/loss information
9240 statusbar_write (distance, elev_gain, elev_loss, last_step, angle, vtl);
9241
9242 // draw pixmap when we have time to
9243 g_idle_add_full (G_PRIORITY_HIGH_IDLE + 10, draw_sync, passalong, NULL);
9244 vtl->draw_sync_done = FALSE;
9245 return VIK_LAYER_TOOL_ACK_GRAB_FOCUS;
9246 }
9247 return VIK_LAYER_TOOL_ACK;
9248}
9249
9250static gboolean tool_new_track_key_press ( VikTrwLayer *vtl, GdkEventKey *event, VikViewport *vvp )
9251{
9252 if ( vtl->current_track && event->keyval == GDK_Escape ) {
9253 vtl->current_track = NULL;
9254 vik_layer_emit_update ( VIK_LAYER(vtl) );
9255 return TRUE;
9256 } else if ( vtl->current_track && event->keyval == GDK_BackSpace ) {
9257 /* undo */
9258 if ( vtl->current_track->trackpoints )
9259 {
9260 GList *last = g_list_last(vtl->current_track->trackpoints);
9261 g_free ( last->data );
9262 vtl->current_track->trackpoints = g_list_remove_link ( vtl->current_track->trackpoints, last );
9263 }
9264
9265 update_statusbar ( vtl );
9266
9267 vik_layer_emit_update ( VIK_LAYER(vtl) );
9268 return TRUE;
9269 }
9270 return FALSE;
9271}
9272
9273/*
9274 * Common function to handle trackpoint button requests on either a route or a track
9275 * . enables adding a point via normal click
9276 * . enables removal of last point via right click
9277 * . finishing of the track or route via double clicking
9278 */
9279static gboolean tool_new_track_or_route_click ( VikTrwLayer *vtl, GdkEventButton *event, VikViewport *vvp )
9280{
9281 VikTrackpoint *tp;
9282
9283 if (!vtl || vtl->vl.type != VIK_LAYER_TRW)
9284 return FALSE;
9285
9286 if ( event->button == 2 ) {
9287 // As the display is panning, the new track pixmap is now invalid so don't draw it
9288 // otherwise this drawing done results in flickering back to an old image
9289 vtl->draw_sync_do = FALSE;
9290 return FALSE;
9291 }
9292
9293 if ( event->button == 3 )
9294 {
9295 if ( !vtl->current_track )
9296 return FALSE;
9297 /* undo */
9298 if ( vtl->current_track->trackpoints )
9299 {
9300 GList *last = g_list_last(vtl->current_track->trackpoints);
9301 g_free ( last->data );
9302 vtl->current_track->trackpoints = g_list_remove_link ( vtl->current_track->trackpoints, last );
9303 }
9304 vik_track_calculate_bounds ( vtl->current_track );
9305 update_statusbar ( vtl );
9306
9307 vik_layer_emit_update ( VIK_LAYER(vtl) );
9308 return TRUE;
9309 }
9310
9311 if ( event->type == GDK_2BUTTON_PRESS )
9312 {
9313 /* subtract last (duplicate from double click) tp then end */
9314 if ( vtl->current_track && vtl->current_track->trackpoints && vtl->ct_x1 == vtl->ct_x2 && vtl->ct_y1 == vtl->ct_y2 )
9315 {
9316 GList *last = g_list_last(vtl->current_track->trackpoints);
9317 g_free ( last->data );
9318 vtl->current_track->trackpoints = g_list_remove_link ( vtl->current_track->trackpoints, last );
9319 /* undo last, then end */
9320 vtl->current_track = NULL;
9321 }
9322 vik_layer_emit_update ( VIK_LAYER(vtl) );
9323 return TRUE;
9324 }
9325
9326 tp = vik_trackpoint_new();
9327 vik_viewport_screen_to_coord ( vvp, event->x, event->y, &(tp->coord) );
9328
9329 /* snap to other TP */
9330 if ( event->state & GDK_CONTROL_MASK )
9331 {
9332 VikTrackpoint *other_tp = closest_tp_in_five_pixel_interval ( vtl, vvp, event->x, event->y );
9333 if ( other_tp )
9334 tp->coord = other_tp->coord;
9335 }
9336
9337 tp->newsegment = FALSE;
9338 tp->has_timestamp = FALSE;
9339 tp->timestamp = 0;
9340
9341 if ( vtl->current_track ) {
9342 vik_track_add_trackpoint ( vtl->current_track, tp, TRUE ); // Ensure bounds is updated
9343 /* Auto attempt to get elevation from DEM data (if it's available) */
9344 vik_track_apply_dem_data_last_trackpoint ( vtl->current_track );
9345 }
9346
9347 vtl->ct_x1 = vtl->ct_x2;
9348 vtl->ct_y1 = vtl->ct_y2;
9349 vtl->ct_x2 = event->x;
9350 vtl->ct_y2 = event->y;
9351
9352 vik_layer_emit_update ( VIK_LAYER(vtl) );
9353 return TRUE;
9354}
9355
9356static gboolean tool_new_track_click ( VikTrwLayer *vtl, GdkEventButton *event, VikViewport *vvp )
9357{
9358 // ----------------------------------------------------- if current is a route - switch to new track
9359 if ( event->button == 1 && ( ! vtl->current_track || (vtl->current_track && vtl->current_track->is_route ) ))
9360 {
9361 gchar *name = trw_layer_new_unique_sublayer_name(vtl, VIK_TRW_LAYER_SUBLAYER_TRACK, _("Track"));
9362 if ( ( name = a_dialog_new_track ( VIK_GTK_WINDOW_FROM_LAYER(vtl), name, FALSE ) ) )
9363 {
9364 new_track_create_common ( vtl, name );
9365 g_free ( name );
9366 }
9367 else
9368 return TRUE;
9369 }
9370 return tool_new_track_or_route_click ( vtl, event, vvp );
9371}
9372
9373static void tool_new_track_release ( VikTrwLayer *vtl, GdkEventButton *event, VikViewport *vvp )
9374{
9375 if ( event->button == 2 ) {
9376 // Pan moving ended - enable potential point drawing again
9377 vtl->draw_sync_do = TRUE;
9378 vtl->draw_sync_done = TRUE;
9379 }
9380}
9381
9382/*** New route ****/
9383
9384static gpointer tool_new_route_create ( VikWindow *vw, VikViewport *vvp)
9385{
9386 return vvp;
9387}
9388
9389static gboolean tool_new_route_click ( VikTrwLayer *vtl, GdkEventButton *event, VikViewport *vvp )
9390{
9391 // -------------------------- if current is a track - switch to new route
9392 if ( event->button == 1 && ( ! vtl->current_track || (vtl->current_track && !vtl->current_track->is_route ) ) )
9393 {
9394 gchar *name = trw_layer_new_unique_sublayer_name(vtl, VIK_TRW_LAYER_SUBLAYER_ROUTE, _("Route"));
9395 if ( ( name = a_dialog_new_track ( VIK_GTK_WINDOW_FROM_LAYER(vtl), name, TRUE ) ) ) {
9396 new_route_create_common ( vtl, name );
9397 g_free ( name );
9398 }
9399 else
9400 return TRUE;
9401 }
9402 return tool_new_track_or_route_click ( vtl, event, vvp );
9403}
9404
9405/*** New waypoint ****/
9406
9407static gpointer tool_new_waypoint_create ( VikWindow *vw, VikViewport *vvp)
9408{
9409 return vvp;
9410}
9411
9412static gboolean tool_new_waypoint_click ( VikTrwLayer *vtl, GdkEventButton *event, VikViewport *vvp )
9413{
9414 VikCoord coord;
9415 if (!vtl || vtl->vl.type != VIK_LAYER_TRW)
9416 return FALSE;
9417 vik_viewport_screen_to_coord ( vvp, event->x, event->y, &coord );
9418 if (vik_trw_layer_new_waypoint ( vtl, VIK_GTK_WINDOW_FROM_LAYER(vtl), &coord ) && VIK_LAYER(vtl)->visible) {
9419 trw_layer_calculate_bounds_waypoints ( vtl );
9420 vik_layer_emit_update ( VIK_LAYER(vtl) );
9421 }
9422 return TRUE;
9423}
9424
9425
9426/*** Edit trackpoint ****/
9427
9428static gpointer tool_edit_trackpoint_create ( VikWindow *vw, VikViewport *vvp)
9429{
9430 tool_ed_t *t = g_new(tool_ed_t, 1);
9431 t->vvp = vvp;
9432 t->holding = FALSE;
9433 return t;
9434}
9435
9436static void tool_edit_trackpoint_destroy ( tool_ed_t *t )
9437{
9438 g_free ( t );
9439}
9440
9441static gboolean tool_edit_trackpoint_click ( VikTrwLayer *vtl, GdkEventButton *event, gpointer data )
9442{
9443 tool_ed_t *t = data;
9444 VikViewport *vvp = t->vvp;
9445 TPSearchParams params;
9446 /* OUTDATED DOCUMENTATION:
9447 find 5 pixel range on each side. then put these UTM, and a pointer
9448 to the winning track name (and maybe the winning track itself), and a
9449 pointer to the winning trackpoint, inside an array or struct. pass
9450 this along, do a foreach on the tracks which will do a foreach on the
9451 trackpoints. */
9452 params.vvp = vvp;
9453 params.x = event->x;
9454 params.y = event->y;
9455 params.closest_track_id = NULL;
9456 /* TODO: should get track listitem so we can break it up, make a new track, mess it up, all that. */
9457 params.closest_tp = NULL;
9458 params.closest_tpl = NULL;
9459 vik_viewport_get_min_max_lat_lon ( vvp, &(params.bbox.south), &(params.bbox.north), &(params.bbox.west), &(params.bbox.east) );
9460
9461 if ( event->button != 1 )
9462 return FALSE;
9463
9464 if (!vtl || vtl->vl.type != VIK_LAYER_TRW)
9465 return FALSE;
9466
9467 if ( !vtl->vl.visible || !vtl->tracks_visible || !vtl->routes_visible )
9468 return FALSE;
9469
9470 if ( vtl->current_tpl )
9471 {
9472 /* 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.) */
9473 VikTrackpoint *tp = VIK_TRACKPOINT(vtl->current_tpl->data);
9474 VikTrack *current_tr = VIK_TRACK(g_hash_table_lookup(vtl->tracks, vtl->current_tp_id));
9475 if ( !current_tr )
9476 return FALSE;
9477
9478 gint x, y;
9479 vik_viewport_coord_to_screen ( vvp, &(tp->coord), &x, &y );
9480
9481 if ( current_tr->visible &&
9482 abs(x - event->x) < TRACKPOINT_SIZE_APPROX &&
9483 abs(y - event->y) < TRACKPOINT_SIZE_APPROX ) {
9484 marker_begin_move ( t, event->x, event->y );
9485 return TRUE;
9486 }
9487
9488 }
9489
9490 if ( vtl->tracks_visible )
9491 g_hash_table_foreach ( vtl->tracks, (GHFunc) track_search_closest_tp, &params);
9492
9493 if ( params.closest_tp )
9494 {
9495 vik_treeview_select_iter ( VIK_LAYER(vtl)->vt, g_hash_table_lookup ( vtl->tracks_iters, params.closest_track_id ), TRUE );
9496 vtl->current_tpl = params.closest_tpl;
9497 vtl->current_tp_id = params.closest_track_id;
9498 vtl->current_tp_track = g_hash_table_lookup ( vtl->tracks, params.closest_track_id );
9499 trw_layer_tpwin_init ( vtl );
9500 set_statusbar_msg_info_trkpt ( vtl, params.closest_tp );
9501 vik_layer_emit_update ( VIK_LAYER(vtl) );
9502 return TRUE;
9503 }
9504
9505 if ( vtl->routes_visible )
9506 g_hash_table_foreach ( vtl->routes, (GHFunc) track_search_closest_tp, &params);
9507
9508 if ( params.closest_tp )
9509 {
9510 vik_treeview_select_iter ( VIK_LAYER(vtl)->vt, g_hash_table_lookup ( vtl->routes_iters, params.closest_track_id ), TRUE );
9511 vtl->current_tpl = params.closest_tpl;
9512 vtl->current_tp_id = params.closest_track_id;
9513 vtl->current_tp_track = g_hash_table_lookup ( vtl->routes, params.closest_track_id );
9514 trw_layer_tpwin_init ( vtl );
9515 set_statusbar_msg_info_trkpt ( vtl, params.closest_tp );
9516 vik_layer_emit_update ( VIK_LAYER(vtl) );
9517 return TRUE;
9518 }
9519
9520 /* these aren't the droids you're looking for */
9521 return FALSE;
9522}
9523
9524static gboolean tool_edit_trackpoint_move ( VikTrwLayer *vtl, GdkEventMotion *event, gpointer data )
9525{
9526 tool_ed_t *t = data;
9527 VikViewport *vvp = t->vvp;
9528
9529 if (!vtl || vtl->vl.type != VIK_LAYER_TRW)
9530 return FALSE;
9531
9532 if ( t->holding )
9533 {
9534 VikCoord new_coord;
9535 vik_viewport_screen_to_coord ( vvp, event->x, event->y, &new_coord );
9536
9537 /* snap to TP */
9538 if ( event->state & GDK_CONTROL_MASK )
9539 {
9540 VikTrackpoint *tp = closest_tp_in_five_pixel_interval ( vtl, vvp, event->x, event->y );
9541 if ( tp && tp != vtl->current_tpl->data )
9542 new_coord = tp->coord;
9543 }
9544 // VIK_TRACKPOINT(vtl->current_tpl->data)->coord = new_coord;
9545 {
9546 gint x, y;
9547 vik_viewport_coord_to_screen ( vvp, &new_coord, &x, &y );
9548 marker_moveto ( t, x, y );
9549 }
9550
9551 return TRUE;
9552 }
9553 return FALSE;
9554}
9555
9556static gboolean tool_edit_trackpoint_release ( VikTrwLayer *vtl, GdkEventButton *event, gpointer data )
9557{
9558 tool_ed_t *t = data;
9559 VikViewport *vvp = t->vvp;
9560
9561 if (!vtl || vtl->vl.type != VIK_LAYER_TRW)
9562 return FALSE;
9563 if ( event->button != 1)
9564 return FALSE;
9565
9566 if ( t->holding ) {
9567 VikCoord new_coord;
9568 vik_viewport_screen_to_coord ( vvp, event->x, event->y, &new_coord );
9569
9570 /* snap to TP */
9571 if ( event->state & GDK_CONTROL_MASK )
9572 {
9573 VikTrackpoint *tp = closest_tp_in_five_pixel_interval ( vtl, vvp, event->x, event->y );
9574 if ( tp && tp != vtl->current_tpl->data )
9575 new_coord = tp->coord;
9576 }
9577
9578 VIK_TRACKPOINT(vtl->current_tpl->data)->coord = new_coord;
9579 if ( vtl->current_tp_track )
9580 vik_track_calculate_bounds ( vtl->current_tp_track );
9581
9582 marker_end_move ( t );
9583
9584 /* diff dist is diff from orig */
9585 if ( vtl->tpwin )
9586 vik_trw_layer_tpwin_set_tp ( vtl->tpwin, vtl->current_tpl, vtl->current_tp_track->name );
9587
9588 vik_layer_emit_update ( VIK_LAYER(vtl) );
9589 return TRUE;
9590 }
9591 return FALSE;
9592}
9593
9594
9595/*** Route Finder ***/
9596static gpointer tool_route_finder_create ( VikWindow *vw, VikViewport *vvp)
9597{
9598 return vvp;
9599}
9600
9601static gboolean tool_route_finder_click ( VikTrwLayer *vtl, GdkEventButton *event, VikViewport *vvp )
9602{
9603 VikCoord tmp;
9604 if ( !vtl ) return FALSE;
9605 vik_viewport_screen_to_coord ( vvp, event->x, event->y, &tmp );
9606 if ( event->button == 3 && vtl->route_finder_current_track ) {
9607 VikCoord *new_end;
9608 new_end = vik_track_cut_back_to_double_point ( vtl->route_finder_current_track );
9609 if ( new_end ) {
9610 vtl->route_finder_coord = *new_end;
9611 g_free ( new_end );
9612 vik_layer_emit_update ( VIK_LAYER(vtl) );
9613 /* remove last ' to:...' */
9614 if ( vtl->route_finder_current_track->comment ) {
9615 gchar *last_to = strrchr ( vtl->route_finder_current_track->comment, 't' );
9616 if ( last_to && (last_to - vtl->route_finder_current_track->comment > 1) ) {
9617 gchar *new_comment = g_strndup ( vtl->route_finder_current_track->comment,
9618 last_to - vtl->route_finder_current_track->comment - 1);
9619 vik_track_set_comment_no_copy ( vtl->route_finder_current_track, new_comment );
9620 }
9621 }
9622 }
9623 }
9624 else if ( vtl->route_finder_started || (event->state & GDK_CONTROL_MASK && vtl->route_finder_current_track) ) {
9625 struct LatLon start, end;
9626
9627 vik_coord_to_latlon ( &(vtl->route_finder_coord), &start );
9628 vik_coord_to_latlon ( &(tmp), &end );
9629 vtl->route_finder_coord = tmp; /* for continuations */
9630
9631 /* these are checked when adding a track from a file (vik_trw_layer_filein_add_track) */
9632 if ( event->state & GDK_CONTROL_MASK && vtl->route_finder_current_track ) {
9633 vtl->route_finder_append = TRUE; // merge tracks. keep started true.
9634 } else {
9635 vtl->route_finder_check_added_track = TRUE;
9636 vtl->route_finder_started = FALSE;
9637 }
9638
9639 vik_routing_default_find ( vtl, start, end);
9640
9641 /* see if anything was done -- a track was added or appended to */
9642 if ( vtl->route_finder_check_added_track && vtl->route_finder_added_track ) {
9643 vik_track_set_comment_no_copy ( vtl->route_finder_added_track, g_strdup_printf("from: %f,%f to: %f,%f", start.lat, start.lon, end.lat, end.lon ) );
9644 } else if ( vtl->route_finder_append == FALSE && vtl->route_finder_current_track ) {
9645 /* route_finder_append was originally TRUE but set to FALSE by filein_add_track */
9646 gchar *new_comment = g_strdup_printf("%s to: %f,%f", vtl->route_finder_current_track->comment, end.lat, end.lon );
9647 vik_track_set_comment_no_copy ( vtl->route_finder_current_track, new_comment );
9648 }
9649
9650 if ( vtl->route_finder_added_track )
9651 vik_track_calculate_bounds ( vtl->route_finder_added_track );
9652
9653 vtl->route_finder_added_track = NULL;
9654 vtl->route_finder_check_added_track = FALSE;
9655 vtl->route_finder_append = FALSE;
9656
9657 vik_layer_emit_update ( VIK_LAYER(vtl) );
9658 } else {
9659 vtl->route_finder_started = TRUE;
9660 vtl->route_finder_coord = tmp;
9661 vtl->route_finder_current_track = NULL;
9662 }
9663 return TRUE;
9664}
9665
9666/*** Show picture ****/
9667
9668static gpointer tool_show_picture_create ( VikWindow *vw, VikViewport *vvp)
9669{
9670 return vvp;
9671}
9672
9673/* Params are: vvp, event, last match found or NULL */
9674static void tool_show_picture_wp ( const gpointer id, VikWaypoint *wp, gpointer params[3] )
9675{
9676 if ( wp->image && wp->visible )
9677 {
9678 gint x, y, slackx, slacky;
9679 GdkEventButton *event = (GdkEventButton *) params[1];
9680
9681 vik_viewport_coord_to_screen ( VIK_VIEWPORT(params[0]), &(wp->coord), &x, &y );
9682 slackx = wp->image_width / 2;
9683 slacky = wp->image_height / 2;
9684 if ( x <= event->x + slackx && x >= event->x - slackx
9685 && y <= event->y + slacky && y >= event->y - slacky )
9686 {
9687 params[2] = wp->image; /* we've found a match. however continue searching
9688 * since we want to find the last match -- that
9689 * is, the match that was drawn last. */
9690 }
9691 }
9692}
9693
9694static void trw_layer_show_picture ( gpointer pass_along[6] )
9695{
9696 /* thanks to the Gaim people for showing me ShellExecute and g_spawn_command_line_async */
9697#ifdef WINDOWS
9698 ShellExecute(NULL, "open", (char *) pass_along[5], NULL, NULL, SW_SHOWNORMAL);
9699#else /* WINDOWS */
9700 GError *err = NULL;
9701 gchar *quoted_file = g_shell_quote ( (gchar *) pass_along[5] );
9702 gchar *cmd = g_strdup_printf ( "%s %s", a_vik_get_image_viewer(), quoted_file );
9703 g_free ( quoted_file );
9704 if ( ! g_spawn_command_line_async ( cmd, &err ) )
9705 {
9706 a_dialog_error_msg_extra ( VIK_GTK_WINDOW_FROM_LAYER( pass_along[0]), _("Could not launch %s to open file."), a_vik_get_image_viewer() );
9707 g_error_free ( err );
9708 }
9709 g_free ( cmd );
9710#endif /* WINDOWS */
9711}
9712
9713static gboolean tool_show_picture_click ( VikTrwLayer *vtl, GdkEventButton *event, VikViewport *vvp )
9714{
9715 gpointer params[3] = { vvp, event, NULL };
9716 if (!vtl || vtl->vl.type != VIK_LAYER_TRW)
9717 return FALSE;
9718 g_hash_table_foreach ( vtl->waypoints, (GHFunc) tool_show_picture_wp, params );
9719 if ( params[2] )
9720 {
9721 static gpointer pass_along[6];
9722 pass_along[0] = vtl;
9723 pass_along[5] = params[2];
9724 trw_layer_show_picture ( pass_along );
9725 return TRUE; /* found a match */
9726 }
9727 else
9728 return FALSE; /* go through other layers, searching for a match */
9729}
9730
9731/***************************************************************************
9732 ** End tool code
9733 ***************************************************************************/
9734
9735
9736static void image_wp_make_list ( const gpointer id, VikWaypoint *wp, GSList **pics )
9737{
9738 if ( wp->image && ( ! a_thumbnails_exists ( wp->image ) ) )
9739 *pics = g_slist_append ( *pics, (gpointer) g_strdup ( wp->image ) );
9740}
9741
9742/* Structure for thumbnail creating data used in the background thread */
9743typedef struct {
9744 VikTrwLayer *vtl; // Layer needed for redrawing
9745 GSList *pics; // Image list
9746} thumbnail_create_thread_data;
9747
9748static int create_thumbnails_thread ( thumbnail_create_thread_data *tctd, gpointer threaddata )
9749{
9750 guint total = g_slist_length(tctd->pics), done = 0;
9751 while ( tctd->pics )
9752 {
9753 a_thumbnails_create ( (gchar *) tctd->pics->data );
9754 int result = a_background_thread_progress ( threaddata, ((gdouble) ++done) / total );
9755 if ( result != 0 )
9756 return -1; /* Abort thread */
9757
9758 tctd->pics = tctd->pics->next;
9759 }
9760
9761 // Redraw to show the thumbnails as they are now created
9762 if ( IS_VIK_LAYER(tctd->vtl) )
9763 vik_layer_emit_update ( VIK_LAYER(tctd->vtl) ); // NB update from background thread
9764
9765 return 0;
9766}
9767
9768static void thumbnail_create_thread_free ( thumbnail_create_thread_data *tctd )
9769{
9770 while ( tctd->pics )
9771 {
9772 g_free ( tctd->pics->data );
9773 tctd->pics = g_slist_delete_link ( tctd->pics, tctd->pics );
9774 }
9775 g_free ( tctd );
9776}
9777
9778void trw_layer_verify_thumbnails ( VikTrwLayer *vtl, GtkWidget *vp )
9779{
9780 if ( ! vtl->has_verified_thumbnails )
9781 {
9782 GSList *pics = NULL;
9783 g_hash_table_foreach ( vtl->waypoints, (GHFunc) image_wp_make_list, &pics );
9784 if ( pics )
9785 {
9786 gint len = g_slist_length ( pics );
9787 gchar *tmp = g_strdup_printf ( _("Creating %d Image Thumbnails..."), len );
9788 thumbnail_create_thread_data *tctd = g_malloc ( sizeof(thumbnail_create_thread_data) );
9789 tctd->vtl = vtl;
9790 tctd->pics = pics;
9791 a_background_thread ( VIK_GTK_WINDOW_FROM_LAYER(vtl),
9792 tmp,
9793 (vik_thr_func) create_thumbnails_thread,
9794 tctd,
9795 (vik_thr_free_func) thumbnail_create_thread_free,
9796 NULL,
9797 len );
9798 g_free ( tmp );
9799 }
9800 }
9801}
9802
9803static const gchar* my_track_colors ( gint ii )
9804{
9805 static const gchar* colors[VIK_TRW_LAYER_TRACK_GCS] = {
9806 "#2d870a",
9807 "#135D34",
9808 "#0a8783",
9809 "#0e4d87",
9810 "#05469f",
9811 "#695CBB",
9812 "#2d059f",
9813 "#4a059f",
9814 "#5A171A",
9815 "#96059f"
9816 };
9817 // Fast and reliable way of returning a colour
9818 return colors[(ii % VIK_TRW_LAYER_TRACK_GCS)];
9819}
9820
9821static void trw_layer_track_alloc_colors ( VikTrwLayer *vtl )
9822{
9823 GHashTableIter iter;
9824 gpointer key, value;
9825
9826 gint ii = 0;
9827 // Tracks
9828 g_hash_table_iter_init ( &iter, vtl->tracks );
9829
9830 while ( g_hash_table_iter_next (&iter, &key, &value) ) {
9831
9832 // Tracks get a random spread of colours if not already assigned
9833 if ( ! VIK_TRACK(value)->has_color ) {
9834 if ( vtl->drawmode == DRAWMODE_ALL_SAME_COLOR )
9835 VIK_TRACK(value)->color = vtl->track_color;
9836 else {
9837 gdk_color_parse ( my_track_colors (ii), &(VIK_TRACK(value)->color) );
9838 }
9839 VIK_TRACK(value)->has_color = TRUE;
9840 }
9841
9842 trw_layer_update_treeview ( vtl, VIK_TRACK(value) );
9843
9844 ii++;
9845 if (ii > VIK_TRW_LAYER_TRACK_GCS)
9846 ii = 0;
9847 }
9848
9849 // Routes
9850 ii = 0;
9851 g_hash_table_iter_init ( &iter, vtl->routes );
9852
9853 while ( g_hash_table_iter_next (&iter, &key, &value) ) {
9854
9855 // Routes get an intermix of reds
9856 if ( ! VIK_TRACK(value)->has_color ) {
9857 if ( ii )
9858 gdk_color_parse ( "#FF0000" , &(VIK_TRACK(value)->color) ); // Red
9859 else
9860 gdk_color_parse ( "#B40916" , &(VIK_TRACK(value)->color) ); // Dark Red
9861 VIK_TRACK(value)->has_color = TRUE;
9862 }
9863
9864 trw_layer_update_treeview ( vtl, VIK_TRACK(value) );
9865
9866 ii = !ii;
9867 }
9868}
9869
9870/*
9871 * (Re)Calculate the bounds of the waypoints in this layer,
9872 * This should be called whenever waypoints are changed
9873 */
9874void trw_layer_calculate_bounds_waypoints ( VikTrwLayer *vtl )
9875{
9876 struct LatLon topleft = { 0.0, 0.0 };
9877 struct LatLon bottomright = { 0.0, 0.0 };
9878 struct LatLon ll;
9879
9880 GHashTableIter iter;
9881 gpointer key, value;
9882
9883 g_hash_table_iter_init ( &iter, vtl->waypoints );
9884
9885 // Set bounds to first point
9886 if ( g_hash_table_iter_next (&iter, &key, &value) ) {
9887 vik_coord_to_latlon ( &(VIK_WAYPOINT(value)->coord), &topleft );
9888 vik_coord_to_latlon ( &(VIK_WAYPOINT(value)->coord), &bottomright );
9889 }
9890
9891 // Ensure there is another point...
9892 if ( g_hash_table_size ( vtl->waypoints ) > 1 ) {
9893
9894 while ( g_hash_table_iter_next (&iter, &key, &value) ) {
9895
9896 // See if this point increases the bounds.
9897 vik_coord_to_latlon ( &(VIK_WAYPOINT(value)->coord), &ll );
9898
9899 if ( ll.lat > topleft.lat) topleft.lat = ll.lat;
9900 if ( ll.lon < topleft.lon) topleft.lon = ll.lon;
9901 if ( ll.lat < bottomright.lat) bottomright.lat = ll.lat;
9902 if ( ll.lon > bottomright.lon) bottomright.lon = ll.lon;
9903 }
9904 }
9905
9906 vtl->waypoints_bbox.north = topleft.lat;
9907 vtl->waypoints_bbox.east = bottomright.lon;
9908 vtl->waypoints_bbox.south = bottomright.lat;
9909 vtl->waypoints_bbox.west = topleft.lon;
9910}
9911
9912static void trw_layer_calculate_bounds_track ( gpointer id, VikTrack *trk )
9913{
9914 vik_track_calculate_bounds ( trk );
9915}
9916
9917static void trw_layer_calculate_bounds_tracks ( VikTrwLayer *vtl )
9918{
9919 g_hash_table_foreach ( vtl->tracks, (GHFunc) trw_layer_calculate_bounds_track, NULL );
9920 g_hash_table_foreach ( vtl->routes, (GHFunc) trw_layer_calculate_bounds_track, NULL );
9921}
9922
9923static void trw_layer_sort_all ( VikTrwLayer *vtl )
9924{
9925 if ( ! VIK_LAYER(vtl)->vt )
9926 return;
9927
9928 // Obviously need 2 to tango - sorting with only 1 (or less) is a lonely activity!
9929 if ( g_hash_table_size (vtl->tracks) > 1 )
9930 vik_treeview_sort_children ( VIK_LAYER(vtl)->vt, &(vtl->tracks_iter), vtl->track_sort_order );
9931
9932 if ( g_hash_table_size (vtl->routes) > 1 )
9933 vik_treeview_sort_children ( VIK_LAYER(vtl)->vt, &(vtl->routes_iter), vtl->track_sort_order );
9934
9935 if ( g_hash_table_size (vtl->waypoints) > 1 )
9936 vik_treeview_sort_children ( VIK_LAYER(vtl)->vt, &(vtl->waypoints_iter), vtl->wp_sort_order );
9937}
9938
9939static void trw_layer_post_read ( VikTrwLayer *vtl, GtkWidget *vvp, gboolean from_file )
9940{
9941 if ( VIK_LAYER(vtl)->realized )
9942 trw_layer_verify_thumbnails ( vtl, vvp );
9943 trw_layer_track_alloc_colors ( vtl );
9944
9945 trw_layer_calculate_bounds_waypoints ( vtl );
9946 trw_layer_calculate_bounds_tracks ( vtl );
9947
9948 // Apply treeview sort after loading all the tracks for this layer
9949 // (rather than sorted insert on each individual track additional)
9950 // and after subsequent changes to the properties as the specified order may have changed.
9951 // since the sorting of a treeview section is now very quick
9952 // NB sorting is also performed after every name change as well to maintain the list order
9953 trw_layer_sort_all ( vtl );
9954}
9955
9956VikCoordMode vik_trw_layer_get_coord_mode ( VikTrwLayer *vtl )
9957{
9958 return vtl->coord_mode;
9959}
9960
9961/**
9962 * Uniquify the whole layer
9963 * Also requires the layers panel as the names shown there need updating too
9964 * Returns whether the operation was successful or not
9965 */
9966gboolean vik_trw_layer_uniquify ( VikTrwLayer *vtl, VikLayersPanel *vlp )
9967{
9968 if ( vtl && vlp ) {
9969 vik_trw_layer_uniquify_tracks ( vtl, vlp, vtl->tracks, TRUE );
9970 vik_trw_layer_uniquify_tracks ( vtl, vlp, vtl->routes, FALSE );
9971 vik_trw_layer_uniquify_waypoints ( vtl, vlp );
9972 return TRUE;
9973 }
9974 return FALSE;
9975}
9976
9977static void waypoint_convert ( const gpointer id, VikWaypoint *wp, VikCoordMode *dest_mode )
9978{
9979 vik_coord_convert ( &(wp->coord), *dest_mode );
9980}
9981
9982static void track_convert ( const gpointer id, VikTrack *tr, VikCoordMode *dest_mode )
9983{
9984 vik_track_convert ( tr, *dest_mode );
9985}
9986
9987static void trw_layer_change_coord_mode ( VikTrwLayer *vtl, VikCoordMode dest_mode )
9988{
9989 if ( vtl->coord_mode != dest_mode )
9990 {
9991 vtl->coord_mode = dest_mode;
9992 g_hash_table_foreach ( vtl->waypoints, (GHFunc) waypoint_convert, &dest_mode );
9993 g_hash_table_foreach ( vtl->tracks, (GHFunc) track_convert, &dest_mode );
9994 g_hash_table_foreach ( vtl->routes, (GHFunc) track_convert, &dest_mode );
9995 }
9996}
9997
9998static void trw_layer_set_menu_selection ( VikTrwLayer *vtl, guint16 selection )
9999{
10000 vtl->menu_selection = selection;
10001}
10002
10003static guint16 trw_layer_get_menu_selection ( VikTrwLayer *vtl )
10004{
10005 return (vtl->menu_selection);
10006}
10007
10008/* ----------- Downloading maps along tracks --------------- */
10009
10010static int get_download_area_width(VikViewport *vvp, gdouble zoom_level, struct LatLon *wh)
10011{
10012 /* TODO: calculating based on current size of viewport */
10013 const gdouble w_at_zoom_0_125 = 0.0013;
10014 const gdouble h_at_zoom_0_125 = 0.0011;
10015 gdouble zoom_factor = zoom_level/0.125;
10016
10017 wh->lat = h_at_zoom_0_125 * zoom_factor;
10018 wh->lon = w_at_zoom_0_125 * zoom_factor;
10019
10020 return 0; /* all OK */
10021}
10022
10023static VikCoord *get_next_coord(VikCoord *from, VikCoord *to, struct LatLon *dist, gdouble gradient)
10024{
10025 if ((dist->lon >= ABS(to->east_west - from->east_west)) &&
10026 (dist->lat >= ABS(to->north_south - from->north_south)))
10027 return NULL;
10028
10029 VikCoord *coord = g_malloc(sizeof(VikCoord));
10030 coord->mode = VIK_COORD_LATLON;
10031
10032 if (ABS(gradient) < 1) {
10033 if (from->east_west > to->east_west)
10034 coord->east_west = from->east_west - dist->lon;
10035 else
10036 coord->east_west = from->east_west + dist->lon;
10037 coord->north_south = gradient * (coord->east_west - from->east_west) + from->north_south;
10038 } else {
10039 if (from->north_south > to->north_south)
10040 coord->north_south = from->north_south - dist->lat;
10041 else
10042 coord->north_south = from->north_south + dist->lat;
10043 coord->east_west = (1/gradient) * (coord->north_south - from->north_south) + from->north_south;
10044 }
10045
10046 return coord;
10047}
10048
10049static GList *add_fillins(GList *list, VikCoord *from, VikCoord *to, struct LatLon *dist)
10050{
10051 /* TODO: handle virtical track (to->east_west - from->east_west == 0) */
10052 gdouble gradient = (to->north_south - from->north_south)/(to->east_west - from->east_west);
10053
10054 VikCoord *next = from;
10055 while (TRUE) {
10056 if ((next = get_next_coord(next, to, dist, gradient)) == NULL)
10057 break;
10058 list = g_list_prepend(list, next);
10059 }
10060
10061 return list;
10062}
10063
10064void vik_track_download_map(VikTrack *tr, VikMapsLayer *vml, VikViewport *vvp, gdouble zoom_level)
10065{
10066 typedef struct _Rect {
10067 VikCoord tl;
10068 VikCoord br;
10069 VikCoord center;
10070 } Rect;
10071#define GLRECT(iter) ((Rect *)((iter)->data))
10072
10073 struct LatLon wh;
10074 GList *rects_to_download = NULL;
10075 GList *rect_iter;
10076
10077 if (get_download_area_width(vvp, zoom_level, &wh))
10078 return;
10079
10080 GList *iter = tr->trackpoints;
10081 if (!iter)
10082 return;
10083
10084 gboolean new_map = TRUE;
10085 VikCoord *cur_coord, tl, br;
10086 Rect *rect;
10087 while (iter) {
10088 cur_coord = &(VIK_TRACKPOINT(iter->data))->coord;
10089 if (new_map) {
10090 vik_coord_set_area(cur_coord, &wh, &tl, &br);
10091 rect = g_malloc(sizeof(Rect));
10092 rect->tl = tl;
10093 rect->br = br;
10094 rect->center = *cur_coord;
10095 rects_to_download = g_list_prepend(rects_to_download, rect);
10096 new_map = FALSE;
10097 iter = iter->next;
10098 continue;
10099 }
10100 gboolean found = FALSE;
10101 for (rect_iter = rects_to_download; rect_iter; rect_iter = rect_iter->next) {
10102 if (vik_coord_inside(cur_coord, &GLRECT(rect_iter)->tl, &GLRECT(rect_iter)->br)) {
10103 found = TRUE;
10104 break;
10105 }
10106 }
10107 if (found)
10108 iter = iter->next;
10109 else
10110 new_map = TRUE;
10111 }
10112
10113 GList *fillins = NULL;
10114 /* 'fillin' doesn't work in UTM mode - potentially ending up in massive loop continually allocating memory - hence don't do it */
10115 /* seems that ATM the function get_next_coord works only for LATLON */
10116 if ( cur_coord->mode == VIK_COORD_LATLON ) {
10117 /* fill-ins for far apart points */
10118 GList *cur_rect, *next_rect;
10119 for (cur_rect = rects_to_download;
10120 (next_rect = cur_rect->next) != NULL;
10121 cur_rect = cur_rect->next) {
10122 if ((wh.lon < ABS(GLRECT(cur_rect)->center.east_west - GLRECT(next_rect)->center.east_west)) ||
10123 (wh.lat < ABS(GLRECT(cur_rect)->center.north_south - GLRECT(next_rect)->center.north_south))) {
10124 fillins = add_fillins(fillins, &GLRECT(cur_rect)->center, &GLRECT(next_rect)->center, &wh);
10125 }
10126 }
10127 } else
10128 g_message("%s: this feature works only in Mercator mode", __FUNCTION__);
10129
10130 if (fillins) {
10131 GList *iter = fillins;
10132 while (iter) {
10133 cur_coord = (VikCoord *)(iter->data);
10134 vik_coord_set_area(cur_coord, &wh, &tl, &br);
10135 rect = g_malloc(sizeof(Rect));
10136 rect->tl = tl;
10137 rect->br = br;
10138 rect->center = *cur_coord;
10139 rects_to_download = g_list_prepend(rects_to_download, rect);
10140 iter = iter->next;
10141 }
10142 }
10143
10144 for (rect_iter = rects_to_download; rect_iter; rect_iter = rect_iter->next) {
10145 vik_maps_layer_download_section (vml, vvp, &(((Rect *)(rect_iter->data))->tl), &(((Rect *)(rect_iter->data))->br), zoom_level);
10146 }
10147
10148 if (fillins) {
10149 for (iter = fillins; iter; iter = iter->next)
10150 g_free(iter->data);
10151 g_list_free(fillins);
10152 }
10153 if (rects_to_download) {
10154 for (rect_iter = rects_to_download; rect_iter; rect_iter = rect_iter->next)
10155 g_free(rect_iter->data);
10156 g_list_free(rects_to_download);
10157 }
10158}
10159
10160static void trw_layer_download_map_along_track_cb ( gpointer pass_along[6] )
10161{
10162 VikMapsLayer *vml;
10163 gint selected_map;
10164 gchar *zoomlist[] = {"0.125", "0.25", "0.5", "1", "2", "4", "8", "16", "32", "64", "128", "256", "512", "1024", NULL };
10165 gdouble zoom_vals[] = {0.125, 0.25, 0.5, 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024};
10166 gint selected_zoom, default_zoom;
10167
10168 VikTrwLayer *vtl = pass_along[0];
10169 VikLayersPanel *vlp = pass_along[1];
10170 VikTrack *trk;
10171 if ( GPOINTER_TO_INT (pass_along[2]) == VIK_TRW_LAYER_SUBLAYER_ROUTE )
10172 trk = (VikTrack *) g_hash_table_lookup ( vtl->routes, pass_along[3] );
10173 else
10174 trk = (VikTrack *) g_hash_table_lookup ( vtl->tracks, pass_along[3] );
10175 if ( !trk )
10176 return;
10177
10178 VikViewport *vvp = vik_window_viewport((VikWindow *)(VIK_GTK_WINDOW_FROM_LAYER(vtl)));
10179
10180 GList *vmls = vik_layers_panel_get_all_layers_of_type(vlp, VIK_LAYER_MAPS, TRUE); // Includes hidden map layer types
10181 int num_maps = g_list_length(vmls);
10182
10183 if (!num_maps) {
10184 a_dialog_error_msg(VIK_GTK_WINDOW_FROM_LAYER(vtl), _("No map layer in use. Create one first") );
10185 return;
10186 }
10187
10188 // Convert from list of vmls to list of names. Allowing the user to select one of them
10189 gchar **map_names = g_malloc(1 + num_maps * sizeof(gpointer));
10190 VikMapsLayer **map_layers = g_malloc(1 + num_maps * sizeof(gpointer));
10191
10192 gchar **np = map_names;
10193 VikMapsLayer **lp = map_layers;
10194 int i;
10195 for (i = 0; i < num_maps; i++) {
10196 vml = (VikMapsLayer *)(vmls->data);
10197 *lp++ = vml;
10198 *np++ = vik_maps_layer_get_map_label(vml);
10199 vmls = vmls->next;
10200 }
10201 // Mark end of the array lists
10202 *lp = NULL;
10203 *np = NULL;
10204
10205 gdouble cur_zoom = vik_viewport_get_zoom(vvp);
10206 for (default_zoom = 0; default_zoom < G_N_ELEMENTS(zoom_vals); default_zoom++) {
10207 if (cur_zoom == zoom_vals[default_zoom])
10208 break;
10209 }
10210 default_zoom = (default_zoom == G_N_ELEMENTS(zoom_vals)) ? G_N_ELEMENTS(zoom_vals) - 1 : default_zoom;
10211
10212 if (!a_dialog_map_n_zoom(VIK_GTK_WINDOW_FROM_LAYER(vtl), map_names, 0, zoomlist, default_zoom, &selected_map, &selected_zoom))
10213 goto done;
10214
10215 vik_track_download_map(trk, map_layers[selected_map], vvp, zoom_vals[selected_zoom]);
10216
10217done:
10218 for (i = 0; i < num_maps; i++)
10219 g_free(map_names[i]);
10220 g_free(map_names);
10221 g_free(map_layers);
10222
10223 g_list_free(vmls);
10224
10225}
10226
10227/**** lowest waypoint number calculation ***/
10228static gint highest_wp_number_name_to_number(const gchar *name) {
10229 if ( strlen(name) == 3 ) {
10230 int n = atoi(name);
10231 if ( n < 100 && name[0] != '0' )
10232 return -1;
10233 if ( n < 10 && name[0] != '0' )
10234 return -1;
10235 return n;
10236 }
10237 return -1;
10238}
10239
10240
10241static void highest_wp_number_reset(VikTrwLayer *vtl)
10242{
10243 vtl->highest_wp_number = -1;
10244}
10245
10246static void highest_wp_number_add_wp(VikTrwLayer *vtl, const gchar *new_wp_name)
10247{
10248 /* if is bigger that top, add it */
10249 gint new_wp_num = highest_wp_number_name_to_number(new_wp_name);
10250 if ( new_wp_num > vtl->highest_wp_number )
10251 vtl->highest_wp_number = new_wp_num;
10252}
10253
10254static void highest_wp_number_remove_wp(VikTrwLayer *vtl, const gchar *old_wp_name)
10255{
10256 /* if wasn't top, do nothing. if was top, count backwards until we find one used */
10257 gint old_wp_num = highest_wp_number_name_to_number(old_wp_name);
10258 if ( vtl->highest_wp_number == old_wp_num ) {
10259 gchar buf[4];
10260 vtl->highest_wp_number--;
10261
10262 g_snprintf(buf,4,"%03d", vtl->highest_wp_number );
10263 /* search down until we find something that *does* exist */
10264
10265 while ( vtl->highest_wp_number > 0 && ! vik_trw_layer_get_waypoint ( vtl, buf )) {
10266 vtl->highest_wp_number--;
10267 g_snprintf(buf,4,"%03d", vtl->highest_wp_number );
10268 }
10269 }
10270}
10271
10272/* get lowest unused number */
10273static gchar *highest_wp_number_get(VikTrwLayer *vtl)
10274{
10275 gchar buf[4];
10276 if ( vtl->highest_wp_number < 0 || vtl->highest_wp_number >= 999 )
10277 return NULL;
10278 g_snprintf(buf,4,"%03d", vtl->highest_wp_number+1 );
10279 return g_strdup(buf);
10280}
10281
10282/**
10283 * trw_layer_create_track_list_both:
10284 *
10285 * Create the latest list of tracks and routes
10286 */
10287static GList* trw_layer_create_track_list_both ( VikLayer *vl, gpointer user_data )
10288{
10289 VikTrwLayer *vtl = VIK_TRW_LAYER(vl);
10290 GList *tracks = NULL;
10291 tracks = g_list_concat ( tracks, g_hash_table_get_values ( vik_trw_layer_get_tracks ( vtl ) ) );
10292 tracks = g_list_concat ( tracks, g_hash_table_get_values ( vik_trw_layer_get_routes ( vtl ) ) );
10293
10294 return vik_trw_layer_build_track_list_t ( vtl, tracks );
10295}
10296
10297static void trw_layer_track_list_dialog_single ( gpointer pass_along[6] )
10298{
10299 VikTrwLayer *vtl = VIK_TRW_LAYER(pass_along[0]);
10300
10301 gchar *title = NULL;
10302 if ( GPOINTER_TO_INT(pass_along[2]) == VIK_TRW_LAYER_SUBLAYER_TRACKS )
10303 title = g_strdup_printf ( _("%s: Track List"), VIK_LAYER(vtl)->name );
10304 else
10305 title = g_strdup_printf ( _("%s: Route List"), VIK_LAYER(vtl)->name );
10306
10307 vik_trw_layer_track_list_show_dialog ( title, VIK_LAYER(vtl), pass_along[2], trw_layer_create_track_list, FALSE );
10308 g_free ( title );
10309}
10310
10311static void trw_layer_track_list_dialog ( gpointer lav[2] )
10312{
10313 VikTrwLayer *vtl = VIK_TRW_LAYER(lav[0]);
10314 //VikLayersPanel *vlp = VIK_LAYERS_PANEL(lav[1]);
10315
10316 gchar *title = g_strdup_printf ( _("%s: Track and Route List"), VIK_LAYER(vtl)->name );
10317 vik_trw_layer_track_list_show_dialog ( title, VIK_LAYER(vtl), NULL, trw_layer_create_track_list_both, FALSE );
10318 g_free ( title );
10319}
10320
10321static void trw_layer_waypoint_list_dialog ( gpointer lav[2] )
10322{
10323 VikTrwLayer *vtl = VIK_TRW_LAYER(lav[0]);
10324 //VikLayersPanel *vlp = VIK_LAYERS_PANEL(lav[1]);
10325
10326 gchar *title = g_strdup_printf ( _("%s: Waypoint List"), VIK_LAYER(vtl)->name );
10327 vik_trw_layer_waypoint_list_show_dialog ( title, VIK_LAYER(vtl), NULL, trw_layer_create_waypoint_list, FALSE );
10328 g_free ( title );
10329}
Viking GPS editor