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