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