#include "viking.h"
#include "vikmapslayer.h"
-#include "viktrwlayer_pixmap.h"
#include "viktrwlayer_tpwin.h"
#include "viktrwlayer_propwin.h"
#include "garminsymbols.h"
#include <math.h>
#include <string.h>
#include <stdlib.h>
+#include <stdio.h>
#include <ctype.h>
#include <gdk/gdkkeysyms.h>
+#include <glib.h>
+#include <glib/gstdio.h>
#include <glib/gi18n.h>
/* Relax some dependencies */
static g_hash_table_remove_all (GHashTable *ght) { g_hash_table_foreach_remove ( ght, (GHRFunc) return_true, FALSE ); }
#endif
-#define GOOGLE_DIRECTIONS_STRING "(wget -O - \"http://maps.google.com/maps?q=%f,%f to %f,%f&output=js\" 2>/dev/null)"
+#define GOOGLE_DIRECTIONS_STRING "maps.google.com/maps?q=from:%s,%s+to:%s,%s&output=js"
#define VIK_TRW_LAYER_TRACK_GC 13
#define VIK_TRW_LAYER_TRACK_GC_RATES 10
#define VIK_TRW_LAYER_TRACK_GC_MIN 0
/* menu */
VikStdLayerMenuItem menu_selection;
+ gint highest_wp_number;
};
/* A caached waypoint image. */
static gpointer tool_edit_trackpoint_create ( VikWindow *vw, VikViewport *vvp);
static gboolean tool_edit_trackpoint_click ( VikTrwLayer *vtl, GdkEventButton *event, gpointer data );
-static gboolean tool_edit_trackpoint_move ( VikTrwLayer *vtl, GdkEventButton *event, gpointer data );
+static gboolean tool_edit_trackpoint_move ( VikTrwLayer *vtl, GdkEventMotion *event, gpointer data );
static gboolean tool_edit_trackpoint_release ( VikTrwLayer *vtl, GdkEventButton *event, gpointer data );
static gpointer tool_show_picture_create ( VikWindow *vw, VikViewport *vvp);
static gboolean tool_show_picture_click ( VikTrwLayer *vtl, GdkEventButton *event, VikViewport *vvp );
static gpointer tool_edit_waypoint_create ( VikWindow *vw, VikViewport *vvp);
static gboolean tool_edit_waypoint_click ( VikTrwLayer *vtl, GdkEventButton *event, gpointer data );
-static gboolean tool_edit_waypoint_move ( VikTrwLayer *vtl, GdkEventButton *event, gpointer data );
+static gboolean tool_edit_waypoint_move ( VikTrwLayer *vtl, GdkEventMotion *event, gpointer data );
static gboolean tool_edit_waypoint_release ( VikTrwLayer *vtl, GdkEventButton *event, gpointer data );
static gpointer tool_begin_track_create ( VikWindow *vw, VikViewport *vvp);
static gboolean tool_begin_track_click ( VikTrwLayer *vtl, GdkEventButton *event, VikViewport *vvp );
static gpointer tool_new_track_create ( VikWindow *vw, VikViewport *vvp);
static gboolean tool_new_track_click ( VikTrwLayer *vtl, GdkEventButton *event, VikViewport *vvp );
-static VikLayerToolFuncStatus tool_new_track_move ( VikTrwLayer *vtl, GdkEventButton *event, VikViewport *vvp );
+static VikLayerToolFuncStatus tool_new_track_move ( VikTrwLayer *vtl, GdkEventMotion *event, VikViewport *vvp );
static gboolean tool_new_track_key_press ( VikTrwLayer *vtl, GdkEventKey *event, VikViewport *vvp );
static gpointer tool_new_waypoint_create ( VikWindow *vw, VikViewport *vvp);
static gboolean tool_new_waypoint_click ( VikTrwLayer *vtl, GdkEventButton *event, VikViewport *vvp );
static gboolean tool_magic_scissors_click ( VikTrwLayer *vtl, GdkEventButton *event, VikViewport *vvp );
-static gboolean uppercase_exists_in_hash ( GHashTable *hash, const gchar *str );
-
static void cached_pixbuf_free ( CachedPixbuf *cp );
static gint cached_pixbuf_cmp ( CachedPixbuf *cp, const gchar *name );
static void trw_layer_verify_thumbnails ( VikTrwLayer *vtl, GtkWidget *vp );
static void waypoint_convert ( const gchar *name, VikWaypoint *wp, VikCoordMode *dest_mode );
static void track_convert ( const gchar *name, VikTrack *tr, VikCoordMode *dest_mode );
+static gchar *highest_wp_number_get(VikTrwLayer *vtl);
+static void highest_wp_number_reset(VikTrwLayer *vtl);
+static void highest_wp_number_add_wp(VikTrwLayer *vtl, const gchar *new_wp_name);
+static void highest_wp_number_remove_wp(VikTrwLayer *vtl, const gchar *old_wp_name);
+
+
static VikToolInterface trw_layer_tools[] = {
{ N_("Create Waypoint"), (VikToolConstructorFunc) tool_new_waypoint_create, NULL, NULL, NULL,
- (VikToolMouseFunc) tool_new_waypoint_click, NULL, NULL, (VikToolKeyFunc) NULL, &cursor_addwp },
+ (VikToolMouseFunc) tool_new_waypoint_click, NULL, NULL, (VikToolKeyFunc) NULL, GDK_CURSOR_IS_PIXMAP, &cursor_addwp_pixbuf },
{ N_("Create Track"), (VikToolConstructorFunc) tool_new_track_create, NULL, NULL, NULL,
- (VikToolMouseFunc) tool_new_track_click, (VikToolMouseFunc) tool_new_track_move, NULL,
- (VikToolKeyFunc) tool_new_track_key_press, &cursor_addtr },
+ (VikToolMouseFunc) tool_new_track_click, (VikToolMouseMoveFunc) tool_new_track_move, NULL,
+ (VikToolKeyFunc) tool_new_track_key_press, GDK_CURSOR_IS_PIXMAP, &cursor_addtr_pixbuf },
{ N_("Begin Track"), (VikToolConstructorFunc) tool_begin_track_create, NULL, NULL, NULL,
- (VikToolMouseFunc) tool_begin_track_click, NULL, NULL, (VikToolKeyFunc) NULL, &cursor_begintr },
+ (VikToolMouseFunc) tool_begin_track_click, NULL, NULL, (VikToolKeyFunc) NULL, GDK_CURSOR_IS_PIXMAP, &cursor_begintr_pixbuf },
{ N_("Edit Waypoint"), (VikToolConstructorFunc) tool_edit_waypoint_create, NULL, NULL, NULL,
(VikToolMouseFunc) tool_edit_waypoint_click,
- (VikToolMouseFunc) tool_edit_waypoint_move,
- (VikToolMouseFunc) tool_edit_waypoint_release, (VikToolKeyFunc) NULL, &cursor_edwp },
+ (VikToolMouseMoveFunc) tool_edit_waypoint_move,
+ (VikToolMouseFunc) tool_edit_waypoint_release, (VikToolKeyFunc) NULL, GDK_CURSOR_IS_PIXMAP, &cursor_edwp_pixbuf },
{ N_("Edit Trackpoint"), (VikToolConstructorFunc) tool_edit_trackpoint_create, NULL, NULL, NULL,
(VikToolMouseFunc) tool_edit_trackpoint_click,
- (VikToolMouseFunc) tool_edit_trackpoint_move,
- (VikToolMouseFunc) tool_edit_trackpoint_release, (VikToolKeyFunc) NULL, &cursor_edtr },
+ (VikToolMouseMoveFunc) tool_edit_trackpoint_move,
+ (VikToolMouseFunc) tool_edit_trackpoint_release, (VikToolKeyFunc) NULL, GDK_CURSOR_IS_PIXMAP, &cursor_edtr_pixbuf },
{ N_("Show Picture"), (VikToolConstructorFunc) tool_show_picture_create, NULL, NULL, NULL,
- (VikToolMouseFunc) tool_show_picture_click, NULL, NULL, (VikToolKeyFunc) NULL, &cursor_showpic },
+ (VikToolMouseFunc) tool_show_picture_click, NULL, NULL, (VikToolKeyFunc) NULL, GDK_CURSOR_IS_PIXMAP, &cursor_showpic_pixbuf },
{ N_("Magic Scissors"), (VikToolConstructorFunc) tool_magic_scissors_create, NULL, NULL, NULL,
- (VikToolMouseFunc) tool_magic_scissors_click, NULL, NULL, (VikToolKeyFunc) NULL, &cursor_iscissors },
+ (VikToolMouseFunc) tool_magic_scissors_click, NULL, NULL, (VikToolKeyFunc) NULL, GDK_CURSOR_IS_PIXMAP, &cursor_iscissors_pixbuf },
};
enum { TOOL_CREATE_WAYPOINT=0, TOOL_CREATE_TRACK, TOOL_BEGIN_TRACK, TOOL_EDIT_WAYPOINT, TOOL_EDIT_TRACKPOINT, TOOL_SHOW_PICTURE, NUM_TOOLS };
VikLayerInterface vik_trw_layer_interface = {
"TrackWaypoint",
- &trwlayer_pixbuf,
+ &viktrwlayer_pixbuf,
trw_layer_tools,
sizeof(trw_layer_tools) / sizeof(VikToolInterface),
pass_along[0] = vtl;
pass_along[1] = NULL;
- pass_along[2] = (gpointer) subtype;
+ pass_along[2] = GINT_TO_POINTER (subtype);
pass_along[3] = sublayer;
pass_along[4] = NULL;
static void trw_layer_copy_item_cb( gpointer pass_along[5])
{
VikTrwLayer *vtl = VIK_TRW_LAYER(pass_along[0]);
- gint subtype = (gint)pass_along[2];
+ gint subtype = GPOINTER_TO_INT (pass_along[2]);
gpointer * sublayer = pass_along[3];
guint8 *data = NULL;
guint len;
a_gpx_write_file(vtl, f);
vik_layer_marshall_params(VIK_LAYER(vtl), &pd, &pl);
fclose(f);
+ f = NULL;
g_file_get_contents(tmpname, (void *)&dd, (void *)&dl, NULL);
*len = sizeof(pl) + pl + dl;
*data = g_malloc(*len);
g_free(pd);
g_free(dd);
- remove(tmpname);
+ g_remove(tmpname);
g_free(tmpname);
}
}
data += pl;
if (!(f = fdopen(g_file_open_tmp (NULL, &tmpname, NULL), "r+"))) {
- g_critical("couldn't open temp file\n");
+ g_critical("couldn't open temp file");
exit(1);
}
fwrite(data, len - pl - sizeof(pl), 1, f);
rewind(f);
a_gpx_read_file(rv, f);
fclose(f);
- remove(tmpname);
+ f = NULL;
+ g_remove(tmpname);
g_free(tmpname);
return rv;
}
-static GList * a_array_to_glist(gpointer data[])
+static GList * str_array_to_glist(gchar* data[])
{
GList *gl = NULL;
gpointer * p;
- for (p = data; *p; p++)
+ for (p = (gpointer)data; *p; p++)
gl = g_list_prepend(gl, *p);
return(g_list_reverse(gl));
}
+static gboolean strcase_equal(gconstpointer s1, gconstpointer s2)
+{
+ return (strcasecmp(s1, s2) == 0);
+}
+
+static guint strcase_hash(gconstpointer v)
+{
+ /* 31 bit hash function */
+ int i;
+ const gchar *t = v;
+ gchar s[128]; /* malloc is too slow for reading big files */
+ gchar *p = s;
+
+ for (i = 0; (i < (sizeof(s)- 1)) && t[i]; i++)
+ p[i] = toupper(t[i]);
+ p[i] = '\0';
+
+ p = s;
+ guint32 h = *p;
+ if (h) {
+ for (p += 1; *p != '\0'; p++)
+ h = (h << 5) - h + *p;
+ }
+
+ return h;
+}
+
VikTrwLayer *vik_trw_layer_new ( gint drawmode )
{
if (trw_layer_params[PARAM_DM].widget_data == NULL)
- trw_layer_params[PARAM_DM].widget_data = a_array_to_glist(params_drawmodes);
+ trw_layer_params[PARAM_DM].widget_data = str_array_to_glist(params_drawmodes);
if (trw_layer_params[PARAM_WPSYM].widget_data == NULL)
- trw_layer_params[PARAM_WPSYM].widget_data = a_array_to_glist(params_wpsymbols);
+ trw_layer_params[PARAM_WPSYM].widget_data = str_array_to_glist(params_wpsymbols);
VikTrwLayer *rv = VIK_TRW_LAYER ( g_object_new ( VIK_TRW_LAYER_TYPE, NULL ) );
vik_layer_init ( VIK_LAYER(rv), VIK_LAYER_TRW );
- rv->waypoints = g_hash_table_new_full ( g_str_hash, g_str_equal, g_free, (GDestroyNotify) vik_waypoint_free );
+ rv->waypoints = g_hash_table_new_full ( strcase_hash, strcase_equal, g_free, (GDestroyNotify) vik_waypoint_free );
rv->tracks = g_hash_table_new_full ( g_str_hash, g_str_equal, g_free, (GDestroyNotify) vik_track_free );
rv->tracks_iters = g_hash_table_new_full ( g_str_hash, g_str_equal, NULL, g_free );
- rv->waypoints_iters = g_hash_table_new_full ( g_str_hash, g_str_equal, NULL, g_free );
+ rv->waypoints_iters = g_hash_table_new_full ( strcase_hash, strcase_equal, NULL, g_free );
/* TODO: constants at top */
rv->waypoints_visible = rv->tracks_visible = TRUE;
GtkTreeIter *new_iter = g_malloc(sizeof(GtkTreeIter));
#ifdef VIK_CONFIG_ALPHABETIZED_TRW
- 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 );
+ vik_treeview_add_sublayer_alphabetized ( (VikTreeview *) pass_along[3], (GtkTreeIter *) pass_along[0], (GtkTreeIter *) pass_along[1], name, pass_along[2], name, GPOINTER_TO_INT (pass_along[4]), NULL, TRUE, TRUE );
#else
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 );
#endif
{
GtkTreeIter *new_iter = g_malloc(sizeof(GtkTreeIter));
#ifdef VIK_CONFIG_ALPHABETIZED_TRW
- 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 );
+ vik_treeview_add_sublayer_alphabetized ( (VikTreeview *) pass_along[3], (GtkTreeIter *) pass_along[0], (GtkTreeIter *) pass_along[1], name, pass_along[2], name, GPOINTER_TO_INT (pass_along[4]), NULL, TRUE, TRUE );
#else
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 );
#endif
GtkWidget *file_selector;
const gchar *fn;
gboolean failed = FALSE;
- file_selector = gtk_file_selection_new (_("Export Layer"));
- gtk_file_selection_set_filename (GTK_FILE_SELECTION(file_selector), vik_layer_get_name(VIK_LAYER(layer_and_vlp[0])));
-
- while ( gtk_dialog_run ( GTK_DIALOG(file_selector) ) == GTK_RESPONSE_OK )
+ file_selector = gtk_file_chooser_dialog_new (_("Export Layer"),
+ NULL,
+ GTK_FILE_CHOOSER_ACTION_SAVE,
+ GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
+ GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
+ NULL);
+ gtk_file_chooser_set_filename (GTK_FILE_CHOOSER(file_selector), vik_layer_get_name(VIK_LAYER(layer_and_vlp[0])));
+
+ while ( gtk_dialog_run ( GTK_DIALOG(file_selector) ) == GTK_RESPONSE_ACCEPT )
{
- fn = gtk_file_selection_get_filename (GTK_FILE_SELECTION(file_selector) );
- if ( access ( fn, F_OK ) != 0 )
+ fn = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER(file_selector) );
+ if ( g_file_test ( fn, G_FILE_TEST_EXISTS ) == FALSE )
{
gtk_widget_hide ( file_selector );
failed = ! a_file_export ( VIK_TRW_LAYER(layer_and_vlp[0]), fn, file_type );
}
else
{
- 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 ) ) )
+ if ( a_dialog_overwrite ( GTK_WINDOW(file_selector), _("The file \"%s\" exists, do you wish to overwrite it?"), a_file_basename ( fn ) ) )
{
gtk_widget_hide ( file_selector );
failed = ! a_file_export ( VIK_TRW_LAYER(layer_and_vlp[0]), fn, file_type );
gboolean vik_trw_layer_new_waypoint ( VikTrwLayer *vtl, GtkWindow *w, const VikCoord *def_coord )
{
- gchar *name;
+ gchar *name = highest_wp_number_get(vtl);
VikWaypoint *wp = vik_waypoint_new();
wp->coord = *def_coord;
wp->altitude = VIK_DEFAULT_ALTITUDE;
else
wp->visible = TRUE;
+ highest_wp_number_add_wp(vtl, name);
g_hash_table_insert ( vtl->waypoints, name, wp );
}
}
-static gboolean uppercase_exists_in_hash ( GHashTable *hash, const gchar *str )
-{
- gchar *upp = g_strdup ( str );
- gboolean rv;
- char *tmp = upp;
- while ( *tmp )
- {
- *tmp = toupper(*tmp);
- tmp++;
- }
- rv = g_hash_table_lookup ( hash, upp ) ? TRUE : FALSE;
- g_free (upp);
- return rv;
-}
-
/* to be called whenever a track has been deleted or may have been changed. */
void trw_layer_cancel_tps_of_track ( VikTrwLayer *vtl, const gchar *trk_name )
{
g_assert ( ( it = g_hash_table_lookup ( vtl->waypoints_iters, (gchar *) wp_name ) ) );
vik_treeview_item_delete ( VIK_LAYER(vtl)->vt, it );
g_hash_table_remove ( vtl->waypoints_iters, (gchar *) wp_name );
+
+ highest_wp_number_remove_wp(vtl, wp_name);
g_hash_table_remove ( vtl->waypoints, wp_name ); /* last because this frees name */
}
vtl->current_wp_name = NULL;
vtl->moving_wp = FALSE;
+ highest_wp_number_reset(vtl);
+
g_hash_table_foreach(vtl->waypoints_iters, (GHFunc) remove_item_from_treeview, VIK_LAYER(vtl)->vt);
g_hash_table_remove_all(vtl->waypoints_iters);
g_hash_table_remove_all(vtl->waypoints);
{
VikTrwLayer *vtl = VIK_TRW_LAYER(pass_along[0]);
gboolean was_visible = FALSE;
- if ( (gint) pass_along[2] == VIK_TRW_LAYER_SUBLAYER_WAYPOINT )
+ if ( GPOINTER_TO_INT (pass_along[2]) == VIK_TRW_LAYER_SUBLAYER_WAYPOINT )
{
was_visible = vik_trw_layer_delete_waypoint ( vtl, (gchar *) pass_along[3] );
}
static void trw_layer_properties_item ( gpointer pass_along[5] )
{
VikTrwLayer *vtl = VIK_TRW_LAYER(pass_along[0]);
- if ( (gint) pass_along[2] == VIK_TRW_LAYER_SUBLAYER_WAYPOINT )
+ if ( GPOINTER_TO_INT (pass_along[2]) == VIK_TRW_LAYER_SUBLAYER_WAYPOINT )
{
VikWaypoint *wp = g_hash_table_lookup ( vtl->waypoints, pass_along[3] );
if ( wp )
VikTrack *track = g_hash_table_lookup ( VIK_TRW_LAYER(pass_along[0])->tracks, pass_along[3] );
vtl->current_track = track;
- vik_window_enable_layer_tool ( VIK_WINDOW(VIK_GTK_WINDOW_FROM_LAYER(vtl)), VIK_LAYER_TRW, TOOL_CREATE_TRACK );
+ vik_window_enable_layer_tool ( VIK_WINDOW(VIK_GTK_WINDOW_FROM_LAYER(vtl)), VIK_LAYER_TRW, TOOL_CREATE_TRACK);
if ( track->trackpoints )
goto_coord ( VIK_LAYERS_PANEL(pass_along[1]), &(((VikTrackpoint *)g_list_last(track->trackpoints)->data)->coord) );
}
+/**
+ * extend a track using magic scissors
+ */
+static void trw_layer_extend_track_end_ms ( gpointer pass_along[6] )
+{
+ VikTrwLayer *vtl = VIK_TRW_LAYER(pass_along[0]);
+ VikTrack *track = g_hash_table_lookup ( VIK_TRW_LAYER(pass_along[0])->tracks, pass_along[3] );
+ VikCoord last_coord = (((VikTrackpoint *)g_list_last(track->trackpoints)->data)->coord);
+
+ vik_window_enable_layer_tool ( VIK_WINDOW(VIK_GTK_WINDOW_FROM_LAYER(vtl)), VIK_LAYER_TRW, NUM_TOOLS );
+ vtl->magic_scissors_coord = last_coord;
+ vtl->magic_scissors_current_track = track;
+
+ if ( track->trackpoints )
+ goto_coord ( VIK_LAYERS_PANEL(pass_along[1]), &last_coord) ;
+
+}
+
static void trw_layer_apply_dem_data ( gpointer pass_along[6] )
{
/* TODO: check & warn if no DEM data, or no applicable DEM data. */
GList **nearby_tracks = ((gpointer *)user_data)[0];
GList *orig_track = ((gpointer *)user_data)[1];
- guint thr = (guint)((gpointer *)user_data)[2];
+ guint thr = GPOINTER_TO_UINT (((gpointer *)user_data)[2]);
- t1 = VIK_TRACKPOINT(orig_track->data)->timestamp;
- t2 = VIK_TRACKPOINT(g_list_last(orig_track)->data)->timestamp;
+ /* outline:
+ * detect reasons for not merging, and return
+ * if no reason is found not to merge, then do it.
+ */
if (VIK_TRACK(value)->trackpoints == orig_track) {
return;
}
- p1 = VIK_TRACKPOINT(VIK_TRACK(value)->trackpoints->data);
- p2 = VIK_TRACKPOINT(g_list_last(VIK_TRACK(value)->trackpoints)->data);
+ t1 = VIK_TRACKPOINT(orig_track->data)->timestamp;
+ t2 = VIK_TRACKPOINT(g_list_last(orig_track)->data)->timestamp;
- if (!p1->has_timestamp || !p2->has_timestamp) {
- g_print("no timestamp\n");
- return;
- }
+ if (VIK_TRACK(value)->trackpoints) {
+ p1 = VIK_TRACKPOINT(VIK_TRACK(value)->trackpoints->data);
+ p2 = VIK_TRACKPOINT(g_list_last(VIK_TRACK(value)->trackpoints)->data);
- /* g_print("Got track named %s, times %d, %d\n", (gchar *)key, p1->timestamp, p2->timestamp); */
- if (abs(t1 - p2->timestamp) < thr*60 ||
- /* p1 p2 t1 t2 */
- abs(p1->timestamp - t2) < thr*60
- /* t1 t2 p1 p2 */
- ) {
- *nearby_tracks = g_list_prepend(*nearby_tracks, key);
+ if (!p1->has_timestamp || !p2->has_timestamp) {
+ g_print("no timestamp\n");
+ return;
+ }
+
+ /* g_print("Got track named %s, times %d, %d\n", (gchar *)key, p1->timestamp, p2->timestamp); */
+ if (! (abs(t1 - p2->timestamp) < thr*60 ||
+ /* p1 p2 t1 t2 */
+ abs(p1->timestamp - t2) < thr*60)
+ /* t1 t2 p1 p2 */
+ ) {
+ return;
+ }
}
+
+ *nearby_tracks = g_list_prepend(*nearby_tracks, key);
}
/* comparison function used to sort tracks; a and b are hash table keys */
/* merge by time routine */
static void trw_layer_merge_by_timestamp ( gpointer pass_along[6] )
{
+ VikTrwLayer *vtl = (VikTrwLayer *)pass_along[0];
+ gchar *orig_track_name = strdup(pass_along[3]);
+
time_t t1, t2;
- GList *nearby_tracks = NULL;
+ GList *nearby_tracks;
VikTrack *track;
GList *trps;
static guint thr = 1;
guint track_count = 0;
- gchar *orig_track_name = strdup(pass_along[3]);
- if (!a_dialog_time_threshold(VIK_GTK_WINDOW_FROM_LAYER(pass_along[0]),
+ if (!a_dialog_time_threshold(VIK_GTK_WINDOW_FROM_LAYER(vtl),
_("Merge Threshold..."),
- _("Merge when time between trackpoints less than:"),
+ _("Merge when time between tracks less than:"),
&thr)) {
return;
}
/* merge tracks until we can't */
+ nearby_tracks = NULL;
do {
gpointer params[3];
- track = (VikTrack *) g_hash_table_lookup ( VIK_TRW_LAYER(pass_along[0])->tracks, orig_track_name );
+ track = (VikTrack *) g_hash_table_lookup ( vtl->tracks, orig_track_name );
trps = track->trackpoints;
if ( !trps )
return;
/* g_print("Original track times: %d and %d\n", t1, t2); */
params[0] = &nearby_tracks;
params[1] = trps;
- params[2] = (gpointer)thr;
+ params[2] = GUINT_TO_POINTER (thr);
/* get a list of adjacent-in-time tracks */
- g_hash_table_foreach(VIK_TRW_LAYER(pass_along[0])->tracks, find_nearby_track, (gpointer)params);
+ g_hash_table_foreach(vtl->tracks, find_nearby_track, (gpointer)params);
/* add original track */
nearby_tracks = g_list_prepend(nearby_tracks, orig_track_name);
- /* sort by first trackpoint; assumes they don't overlap */
- nearby_tracks = g_list_sort_with_data(nearby_tracks, track_compare, VIK_TRW_LAYER(pass_along[0])->tracks);
-
/* merge them */
{
-#define get_track(x) VIK_TRACK(g_hash_table_lookup(VIK_TRW_LAYER(pass_along[0])->tracks, (gchar *)((x)->data)))
+#define get_track(x) VIK_TRACK(g_hash_table_lookup(vtl->tracks, (gchar *)((x)->data)))
#define get_first_trackpoint(x) VIK_TRACKPOINT(get_track(x)->trackpoints->data)
#define get_last_trackpoint(x) VIK_TRACKPOINT(g_list_last(get_track(x)->trackpoints)->data)
GList *l = nearby_tracks;
/* remove trackpoints from merged track, delete track */
tr->trackpoints = g_list_concat(tr->trackpoints, get_track(l)->trackpoints);
get_track(l)->trackpoints = NULL;
- vik_trw_layer_delete_track(VIK_TRW_LAYER(pass_along[0]), l->data);
+ vik_trw_layer_delete_track(vtl, l->data);
track_count ++;
l = g_list_next(l);
}
tr->trackpoints = g_list_sort(tr->trackpoints, trackpoint_compare);
- vik_trw_layer_add_track(VIK_TRW_LAYER(pass_along[0]), strdup(orig_track_name), tr);
+ vik_trw_layer_add_track(vtl, strdup(orig_track_name), tr);
#undef get_first_trackpoint
#undef get_last_trackpoint
} while (track_count > 1);
g_list_free(nearby_tracks);
free(orig_track_name);
- vik_layer_emit_update(VIK_LAYER(pass_along[0]));
+ vik_layer_emit_update( VIK_LAYER(vtl) );
}
/* split by time routine */
{
if ( subtype == VIK_TRW_LAYER_SUBLAYER_WAYPOINT )
{
- int i;
gchar *rv;
VikWaypoint *wp;
- if ( strcasecmp ( newname, sublayer ) == 0 )
+ if (strcmp(newname, sublayer) == 0 )
return NULL;
- if ( uppercase_exists_in_hash ( l->waypoints, newname ) )
- {
- a_dialog_error_msg ( VIK_GTK_WINDOW_FROM_LAYER(l), _("Waypoint Already Exists") );
- return NULL;
+ if (strcasecmp(newname, sublayer)) { /* Not just changing case */
+ if (g_hash_table_lookup( l->waypoints, newname))
+ {
+ a_dialog_error_msg ( VIK_GTK_WINDOW_FROM_LAYER(l), _("Waypoint Already Exists") );
+ return NULL;
+ }
}
iter = g_hash_table_lookup ( l->waypoints_iters, sublayer );
g_hash_table_steal ( l->waypoints_iters, sublayer );
wp = vik_waypoint_copy ( VIK_WAYPOINT(g_hash_table_lookup ( l->waypoints, sublayer )) );
+ highest_wp_number_remove_wp(l, sublayer);
g_hash_table_remove ( l->waypoints, sublayer );
rv = g_strdup(newname);
- for ( i = strlen(rv) - 1; i >= 0; i-- )
- rv[i] = toupper(rv[i]);
vik_treeview_item_set_pointer ( VIK_LAYER(l)->vt, iter, rv );
+ highest_wp_number_add_wp(l, rv);
g_hash_table_insert ( l->waypoints, rv, wp );
g_hash_table_insert ( l->waypoints_iters, rv, iter );
}
if ( subtype == VIK_TRW_LAYER_SUBLAYER_TRACK )
{
- int i;
gchar *rv;
VikTrack *tr;
GtkTreeIter *iter;
gchar *orig_key;
- if ( strcasecmp ( newname, sublayer ) == 0 )
+ if (strcmp(newname, sublayer) == 0)
return NULL;
- if ( uppercase_exists_in_hash ( l->tracks, newname ) )
- {
- a_dialog_error_msg ( VIK_GTK_WINDOW_FROM_LAYER(l), _("Track Already Exists") );
- return NULL;
+ if (strcasecmp(newname, sublayer)) { /* Not just changing case */
+ if (g_hash_table_lookup( l->waypoints, newname))
+ {
+ a_dialog_error_msg ( VIK_GTK_WINDOW_FROM_LAYER(l), _("Track Already Exists") );
+ return NULL;
+ }
}
g_hash_table_lookup_extended ( l->tracks, sublayer, (void *)&orig_key, (void *)&tr );
g_hash_table_steal ( l->tracks_iters, sublayer );
rv = g_strdup(newname);
- for ( i = strlen(rv) - 1; i >= 0; i-- )
- rv[i] = toupper(rv[i]);
vik_treeview_item_set_pointer ( VIK_LAYER(l)->vt, iter, rv );
pass_along[0] = l;
pass_along[1] = vlp;
- pass_along[2] = (gpointer) subtype;
+ pass_along[2] = GINT_TO_POINTER (subtype);
pass_along[3] = sublayer;
staticiter = *iter; /* will exist after function has ended */
pass_along[4] = &staticiter;
gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
gtk_widget_show ( item );
- item = gtk_menu_item_new_with_label ( "Extend track end" );
+ item = gtk_menu_item_new_with_label ( _("Extend track end") );
g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_extend_track_end), pass_along );
gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
gtk_widget_show ( item );
+ item = gtk_menu_item_new_with_label ( _("Extend using magic scissors") );
+ g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_extend_track_end_ms), pass_along );
+ gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
+ gtk_widget_show ( item );
+
#ifdef VIK_CONFIG_OPENSTREETMAP
item = gtk_menu_item_new_with_label ( _("Upload to OSM") );
g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(osm_traces_upload_track_cb), pass_along );
if ( is_valid_google_route ( l, (gchar *) sublayer ) )
{
- item = gtk_menu_item_new_with_label ( "View Google Directions" );
+ item = gtk_menu_item_new_with_label ( _("View Google Directions") );
g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_track_google_route_webpage), pass_along );
gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
gtk_widget_show ( item );
}
- item = gtk_menu_item_new_with_label ( "Use with filter" );
+ item = gtk_menu_item_new_with_label ( _("Use with filter") );
g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_track_use_with_filter), pass_along );
gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
gtk_widget_show ( item );
return FALSE;
}
-static gboolean tool_edit_waypoint_move ( VikTrwLayer *vtl, GdkEventButton *event, gpointer data )
+static gboolean tool_edit_waypoint_move ( VikTrwLayer *vtl, GdkEventMotion *event, gpointer data )
{
tool_ed_t *t = data;
VikViewport *vvp = t->vvp;
return FALSE;
}
-static VikLayerToolFuncStatus tool_new_track_move ( VikTrwLayer *vtl, GdkEventButton *event, VikViewport *vvp )
+static VikLayerToolFuncStatus tool_new_track_move ( VikTrwLayer *vtl, GdkEventMotion *event, VikViewport *vvp )
{
/* if we haven't sync'ed yet, we don't have time to do more. */
if ( vtl->ct_sync_done && vtl->current_track && vtl->current_track->trackpoints ) {
return FALSE;
}
-static gboolean tool_edit_trackpoint_move ( VikTrwLayer *vtl, GdkEventButton *event, gpointer data )
+static gboolean tool_edit_trackpoint_move ( VikTrwLayer *vtl, GdkEventMotion *event, gpointer data )
{
tool_ed_t *t = data;
VikViewport *vvp = t->vvp;
}
else if ( vtl->magic_scissors_started || (event->state & GDK_CONTROL_MASK && vtl->magic_scissors_current_track) ) {
struct LatLon start, end;
- gchar *cmd;
+ gchar startlat[G_ASCII_DTOSTR_BUF_SIZE], startlon[G_ASCII_DTOSTR_BUF_SIZE];
+ gchar endlat[G_ASCII_DTOSTR_BUF_SIZE], endlon[G_ASCII_DTOSTR_BUF_SIZE];
+ gchar *url;
vik_coord_to_latlon ( &(vtl->magic_scissors_coord), &start );
vik_coord_to_latlon ( &(tmp), &end );
- cmd = g_strdup_printf(GOOGLE_DIRECTIONS_STRING, start.lat, start.lon, end.lat, end.lon );
vtl->magic_scissors_coord = tmp; /* for continuations */
/* these are checked when adding a track from a file (vik_trw_layer_filein_add_track) */
vtl->magic_scissors_started = FALSE;
}
- a_babel_convert_from_shellcommand ( vtl, cmd, "google", NULL, NULL );
- g_free ( cmd );
+ url = g_strdup_printf(GOOGLE_DIRECTIONS_STRING,
+ g_ascii_dtostr (startlat, G_ASCII_DTOSTR_BUF_SIZE, (gdouble) start.lat),
+ g_ascii_dtostr (startlon, G_ASCII_DTOSTR_BUF_SIZE, (gdouble) start.lon),
+ g_ascii_dtostr (endlat, G_ASCII_DTOSTR_BUF_SIZE, (gdouble) end.lat),
+ g_ascii_dtostr (endlon, G_ASCII_DTOSTR_BUF_SIZE, (gdouble) end.lon));
+ a_babel_convert_from_url ( vtl, url, "google", NULL, NULL );
+ g_free ( url );
/* see if anything was done -- a track was added or appended to */
if ( vtl->magic_scissors_check_added_track && vtl->magic_scissors_added_track_name ) {
}
+/**** lowest waypoint number calculation ***/
+static gint highest_wp_number_name_to_number(const gchar *name) {
+ if ( strlen(name) == 3 ) {
+ int n = atoi(name);
+ if ( n < 100 && name[0] != '0' )
+ return -1;
+ if ( n < 10 && name[0] != '0' )
+ return -1;
+ return n;
+ }
+ return -1;
+}
+
+
+static void highest_wp_number_reset(VikTrwLayer *vtl)
+{
+ vtl->highest_wp_number = -1;
+}
+
+static void highest_wp_number_add_wp(VikTrwLayer *vtl, const gchar *new_wp_name)
+{
+ /* if is bigger that top, add it */
+ gint new_wp_num = highest_wp_number_name_to_number(new_wp_name);
+ if ( new_wp_num > vtl->highest_wp_number )
+ vtl->highest_wp_number = new_wp_num;
+}
+
+static void highest_wp_number_remove_wp(VikTrwLayer *vtl, const gchar *old_wp_name)
+{
+ /* if wasn't top, do nothing. if was top, count backwards until we find one used */
+ gint old_wp_num = highest_wp_number_name_to_number(old_wp_name);
+ if ( vtl->highest_wp_number == old_wp_num ) {
+ gchar buf[4];
+ vtl->highest_wp_number --;
+
+ g_snprintf(buf,4,"%03d", vtl->highest_wp_number );
+ /* search down until we find something that *does* exist */
+
+ while ( vtl->highest_wp_number > 0 && ! g_hash_table_lookup ( vtl->waypoints, buf ) ) {
+ vtl->highest_wp_number --;
+ g_snprintf(buf,4,"%03d", vtl->highest_wp_number );
+ }
+ }
+}
+
+/* get lowest unused number */
+static gchar *highest_wp_number_get(VikTrwLayer *vtl)
+{
+ gchar buf[4];
+ if ( vtl->highest_wp_number < 0 || vtl->highest_wp_number >= 999 )
+ return NULL;
+ g_snprintf(buf,4,"%03d", vtl->highest_wp_number+1 );
+ return g_strdup(buf);
+}