X-Git-Url: https://git.street.me.uk/andy/viking.git/blobdiff_plain/db79f75f7deef5e8a934324c69dfaa274764514a..548618483cbc363aa049c9be7a2a22db6072f864:/src/viktrwlayer.c diff --git a/src/viktrwlayer.c b/src/viktrwlayer.c index a0ecb32e..295369d2 100644 --- a/src/viktrwlayer.c +++ b/src/viktrwlayer.c @@ -224,16 +224,26 @@ static gint calculate_velocity ( VikTrwLayer *vtl, VikTrackpoint *tp1, VikTrackp static void trw_layer_draw_track_cb ( const gchar *name, VikTrack *track, struct DrawingParams *dp ); static void trw_layer_draw_waypoint ( const gchar *name, VikWaypoint *wp, struct DrawingParams *dp ); +static const gchar* trw_layer_layer_tooltip ( VikTrwLayer *vtl ); +static const gchar* trw_layer_sublayer_tooltip ( VikTrwLayer *l, gint subtype, gpointer sublayer ); + static void goto_coord ( VikLayersPanel *vlp, const VikCoord *coord ); static void trw_layer_goto_track_startpoint ( gpointer pass_along[5] ); static void trw_layer_goto_track_endpoint ( gpointer pass_along[6] ); +static void trw_layer_goto_track_max_speed ( gpointer pass_along[5] ); +static void trw_layer_goto_track_max_alt ( gpointer pass_along[5] ); +static void trw_layer_goto_track_min_alt ( gpointer pass_along[5] ); +static void trw_layer_auto_track_view ( gpointer pass_along[5] ); static void trw_layer_merge_by_timestamp ( gpointer pass_along[6] ); static void trw_layer_split_by_timestamp ( gpointer pass_along[6] ); static void trw_layer_download_map_along_track_cb(gpointer pass_along[6]); static void trw_layer_centerize ( gpointer layer_and_vlp[2] ); +static void trw_layer_auto_view ( gpointer layer_and_vlp[2] ); static void trw_layer_export ( gpointer layer_and_vlp[2], const gchar* title, const gchar* default_name, const gchar* trackname, guint file_type ); static void trw_layer_goto_wp ( gpointer layer_and_vlp[2] ); static void trw_layer_new_wp ( gpointer lav[2] ); +static void trw_layer_auto_waypoints_view ( gpointer lav[2] ); +static void trw_layer_auto_tracks_view ( gpointer lav[2] ); static void trw_layer_new_wikipedia_wp_viewport ( gpointer lav[2] ); static void trw_layer_new_wikipedia_wp_layer ( gpointer lav[2] ); static void trw_layer_merge_with_other ( gpointer pass_along[6] ); @@ -255,6 +265,8 @@ static gboolean trw_layer_set_param ( VikTrwLayer *vtl, guint16 id, VikLayerPara static VikLayerParamData trw_layer_get_param ( VikTrwLayer *vtl, guint16 id, gboolean is_file_operation ); static void trw_layer_del_item ( VikTrwLayer *vtl, gint subtype, gpointer sublayer ); +static void trw_layer_cut_item ( VikTrwLayer *vtl, gint subtype, gpointer sublayer ); + static void trw_layer_copy_item ( VikTrwLayer *vtl, gint subtype, gpointer sublayer, guint8 **item, guint *len ); static gboolean trw_layer_paste_item ( VikTrwLayer *vtl, gint subtype, guint8 *item, guint len ); static void trw_layer_free_copied_item ( gint subtype, gpointer item ); @@ -434,6 +446,8 @@ VikLayerInterface vik_trw_layer_interface = { (VikLayerFuncSublayerRenameRequest) vik_trw_layer_sublayer_rename_request, (VikLayerFuncSublayerToggleVisible) vik_trw_layer_sublayer_toggle_visible, + (VikLayerFuncSublayerTooltip) trw_layer_sublayer_tooltip, + (VikLayerFuncLayerTooltip) trw_layer_layer_tooltip, (VikLayerFuncMarshall) trw_layer_marshall, (VikLayerFuncUnmarshall) trw_layer_unmarshall, @@ -445,6 +459,7 @@ VikLayerInterface vik_trw_layer_interface = { (VikLayerFuncWriteFileData) a_gpspoint_write_file, (VikLayerFuncDeleteItem) trw_layer_del_item, + (VikLayerFuncCutItem) trw_layer_cut_item, (VikLayerFuncCopyItem) trw_layer_copy_item, (VikLayerFuncPasteItem) trw_layer_paste_item, (VikLayerFuncFreeCopiedItem) trw_layer_free_copied_item, @@ -500,6 +515,23 @@ static void trw_layer_del_item ( VikTrwLayer *vtl, gint subtype, gpointer sublay trw_layer_delete_item ( pass_along ); } +static void trw_layer_cut_item ( VikTrwLayer *vtl, gint subtype, gpointer sublayer ) +{ + static gpointer pass_along[5]; + if (!sublayer) { + return; + } + + pass_along[0] = vtl; + pass_along[1] = NULL; + pass_along[2] = GINT_TO_POINTER (subtype); + pass_along[3] = sublayer; + pass_along[4] = NULL; + + trw_layer_copy_item_cb(pass_along); + trw_layer_cut_item_cb(pass_along); +} + static void trw_layer_copy_item_cb( gpointer pass_along[5]) { VikTrwLayer *vtl = VIK_TRW_LAYER(pass_along[0]); @@ -562,6 +594,9 @@ static gboolean trw_layer_paste_item ( VikTrwLayer *vtl, gint subtype, guint8 *i w = vik_waypoint_unmarshall(fi->data + fi->len, len - sizeof(*fi) - fi->len); vik_trw_layer_add_waypoint ( vtl, name, w ); waypoint_convert(name, w, &vtl->coord_mode); + // Consider if redraw necessary for the new item + if ( vtl->vl.visible && vtl->waypoints_visible && w->visible ) + vik_layer_emit_update ( VIK_LAYER(vtl) ); return TRUE; } if ( subtype == VIK_TRW_LAYER_SUBLAYER_TRACK && fi ) @@ -572,6 +607,9 @@ static gboolean trw_layer_paste_item ( VikTrwLayer *vtl, gint subtype, guint8 *i t = vik_track_unmarshall(fi->data + fi->len, len - sizeof(*fi) - fi->len); vik_trw_layer_add_track ( vtl, name, t ); track_convert(name, t, &vtl->coord_mode); + // Consider if redraw necessary for the new item + if ( vtl->vl.visible && vtl->tracks_visible && t->visible ) + vik_layer_emit_update ( VIK_LAYER(vtl) ); return TRUE; } return FALSE; @@ -1374,7 +1412,7 @@ static void trw_layer_new_track_gcs ( VikTrwLayer *vtl, VikViewport *vp ) gc[9] = vik_viewport_new_gc ( vp, "#96059f", width ); gc[10] = vik_viewport_new_gc ( vp, "#f22ef2", width ); - gc[11] = vik_viewport_new_gc ( vp, "#ff0000", width ); /* above range */ + gc[11] = vik_viewport_new_gc ( vp, "#874200", width ); /* above range */ gc[12] = vik_viewport_new_gc ( vp, "#000000", width ); /* black / no speed data */ @@ -1421,7 +1459,7 @@ static void trw_layer_realize_track ( gchar *name, VikTrack *track, gpointer pas #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, 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 ); + vik_treeview_add_sublayer ( (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 ); #endif *new_iter = *((GtkTreeIter *) pass_along[1]); @@ -1437,7 +1475,7 @@ static void trw_layer_realize_waypoint ( gchar *name, VikWaypoint *wp, gpointer #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, 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 ); + vik_treeview_add_sublayer ( (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 ); #endif *new_iter = *((GtkTreeIter *) pass_along[1]); @@ -1505,6 +1543,191 @@ gboolean vik_trw_layer_sublayer_toggle_visible ( VikTrwLayer *l, gint subtype, g return TRUE; } +// Structure to hold multiple track information for a layer +typedef struct { + gdouble length; + time_t start_time; + time_t end_time; + gint duration; +} tooltip_tracks; + +/* + * Build up layer multiple track information via updating the tooltip_tracks structure + */ +static void trw_layer_tracks_tooltip ( const gchar *name, VikTrack *tr, tooltip_tracks *tt ) +{ + tt->length = tt->length + vik_track_get_length (tr); + + // Ensure times are available + if ( tr->trackpoints && + VIK_TRACKPOINT(tr->trackpoints->data)->has_timestamp && + VIK_TRACKPOINT(g_list_last(tr->trackpoints)->data)->has_timestamp ) { + + time_t t1, t2; + t1 = VIK_TRACKPOINT(tr->trackpoints->data)->timestamp; + t2 = VIK_TRACKPOINT(g_list_last(tr->trackpoints)->data)->timestamp; + + // Assume never actually have a track with a time of 0 (1st Jan 1970) + // Hence initialize to the first 'proper' value + if ( tt->start_time == 0 ) + tt->start_time = t1; + if ( tt->end_time == 0 ) + tt->end_time = t2; + + // Update find the earliest / last times + if ( t1 < tt->start_time ) + tt->start_time = t1; + if ( t2 > tt->end_time ) + tt->end_time = t2; + + // Keep track of total time + // there maybe gaps within a track (eg segments) + // but this should be generally good enough for a simple indicator + tt->duration = tt->duration + (int)(t2-t1); + } +} + +/* + * Generate tooltip text for the layer. + * This is relatively complicated as it considers information for + * no tracks, a single track or multiple tracks + * (which may or may not have timing information) + */ +static const gchar* trw_layer_layer_tooltip ( VikTrwLayer *vtl ) +{ + gchar tbuf1[32]; + gchar tbuf2[64]; + gchar tbuf3[64]; + gchar tbuf4[10]; + tbuf1[0] = '\0'; + tbuf2[0] = '\0'; + tbuf3[0] = '\0'; + tbuf4[0] = '\0'; + + static gchar tmp_buf[128]; + tmp_buf[0] = '\0'; + + // For compact date format I'm using '%x' [The preferred date representation for the current locale without the time.] + + // Safety check - I think these should always be valid + if ( vtl->tracks && vtl->waypoints ) { + tooltip_tracks tt = { 0.0, 0, 0 }; + g_hash_table_foreach ( vtl->tracks, (GHFunc) trw_layer_tracks_tooltip, &tt ); + + GDate* gdate_start = g_date_new (); + g_date_set_time_t (gdate_start, tt.start_time); + + GDate* gdate_end = g_date_new (); + g_date_set_time_t (gdate_end, tt.end_time); + + if ( g_date_compare (gdate_start, gdate_end) ) { + // Dates differ so print range on separate line + g_date_strftime (tbuf1, sizeof(tbuf1), "%x", gdate_start); + g_date_strftime (tbuf2, sizeof(tbuf2), "%x", gdate_end); + g_snprintf (tbuf3, sizeof(tbuf3), "%s to %s\n", tbuf1, tbuf2); + } + else { + // Same date so just show it and keep rest of text on the same line - provided it's a valid time! + if ( tt.start_time != 0 ) + g_date_strftime (tbuf3, sizeof(tbuf3), "%x: ", gdate_start); + } + + tbuf2[0] = '\0'; + if ( tt.length > 0.0 ) { + gdouble len_in_units; + + // Setup info dependent on distance units + if ( a_vik_get_units_distance() == VIK_UNITS_DISTANCE_MILES ) { + g_snprintf (tbuf4, sizeof(tbuf4), "miles"); + len_in_units = VIK_METERS_TO_MILES(tt.length); + } + else { + g_snprintf (tbuf4, sizeof(tbuf4), "kms"); + len_in_units = tt.length/1000.0; + } + + // Timing information if available + tbuf1[0] = '\0'; + if ( tt.duration > 0 ) { + g_snprintf (tbuf1, sizeof(tbuf1), + _(" in %d:%02d hrs:mins"), + (int)round(tt.duration/3600), (int)round((tt.duration/60)%60)); + } + g_snprintf (tbuf2, sizeof(tbuf2), + _("\n%sTotal Length %.1f %s%s"), + tbuf3, len_in_units, tbuf4, tbuf1); + } + + // Put together all the elements to form compact tooltip text + g_snprintf (tmp_buf, sizeof(tmp_buf), + _("Tracks: %d - Waypoints: %d%s"), + g_hash_table_size (vtl->tracks), g_hash_table_size (vtl->waypoints), tbuf2); + + g_date_free (gdate_start); + g_date_free (gdate_end); + + } + + return tmp_buf; +} + +static const gchar* trw_layer_sublayer_tooltip ( VikTrwLayer *l, gint subtype, gpointer sublayer ) +{ + switch ( subtype ) + { + case VIK_TRW_LAYER_SUBLAYER_TRACKS: return NULL; + case VIK_TRW_LAYER_SUBLAYER_WAYPOINTS: return NULL; + case VIK_TRW_LAYER_SUBLAYER_TRACK: + { + VikTrack *tr = g_hash_table_lookup ( l->tracks, sublayer ); + if ( tr ) { + // Could be a better way of handling strings - but this works... + gchar time_buf1[20]; + gchar time_buf2[20]; + time_buf1[0] = '\0'; + time_buf2[0] = '\0'; + static gchar tmp_buf[100]; + // Compact info: Short date eg (11/20/99), duration and length + // Hopefully these are the things that are most useful and so promoted into the tooltip + if ( tr->trackpoints && VIK_TRACKPOINT(tr->trackpoints->data)->has_timestamp ) { + // %x The preferred date representation for the current locale without the time. + strftime (time_buf1, sizeof(time_buf1), "%x: ", gmtime(&(VIK_TRACKPOINT(tr->trackpoints->data)->timestamp))); + if ( VIK_TRACKPOINT(g_list_last(tr->trackpoints)->data)->has_timestamp ) { + gint dur = ( (VIK_TRACKPOINT(g_list_last(tr->trackpoints)->data)->timestamp) - (VIK_TRACKPOINT(tr->trackpoints->data)->timestamp) ); + if ( dur > 0 ) + g_snprintf ( time_buf2, sizeof(time_buf2), _("- %d:%02d hrs:mins"), (int)round(dur/3600), (int)round((dur/60)%60) ); + } + } + // Get length and consider the appropriate distance units + gdouble tr_len = vik_track_get_length(tr); + vik_units_distance_t dist_units = a_vik_get_units_distance (); + switch (dist_units) { + case VIK_UNITS_DISTANCE_KILOMETRES: + g_snprintf (tmp_buf, sizeof(tmp_buf), _("%s%.1f km %s"), time_buf1, tr_len/1000.0, time_buf2); + break; + case VIK_UNITS_DISTANCE_MILES: + g_snprintf (tmp_buf, sizeof(tmp_buf), _("%s%.1f miles %s"), time_buf1, VIK_METERS_TO_MILES(tr_len), time_buf2); + break; + default: + break; + } + return tmp_buf; + } + } + break; + case VIK_TRW_LAYER_SUBLAYER_WAYPOINT: + { + VikWaypoint *w = g_hash_table_lookup ( l->waypoints, sublayer ); + // NB It's OK to return NULL + return w->comment; + } + break; + default: break; + } + return NULL; +} + + GHashTable *vik_trw_layer_get_tracks ( VikTrwLayer *l ) { return l->tracks; @@ -1606,6 +1829,77 @@ static void trw_layer_centerize ( gpointer layer_and_vlp[2] ) a_dialog_info_msg ( VIK_GTK_WINDOW_FROM_LAYER(layer_and_vlp[0]), _("This layer has no waypoints or trackpoints.") ); } +static void trw_layer_zoom_to_show_latlons ( VikTrwLayer *vtl, VikViewport *vvp, struct LatLon maxmin[2] ) +{ + /* First set the center [in case previously viewing from elsewhere] */ + /* Then loop through zoom levels until provided positions are in view */ + /* This method is not particularly fast - but should work well enough */ + struct LatLon average = { (maxmin[0].lat+maxmin[1].lat)/2, (maxmin[0].lon+maxmin[1].lon)/2 }; + VikCoord coord; + vik_coord_load_from_latlon ( &coord, vtl->coord_mode, &average ); + vik_viewport_set_center_coord ( vvp, &coord ); + + /* Convert into definite 'smallest' and 'largest' positions */ + struct LatLon minmin; + if ( maxmin[0].lat < maxmin[1].lat ) + minmin.lat = maxmin[0].lat; + else + minmin.lat = maxmin[1].lat; + + struct LatLon maxmax; + if ( maxmin[0].lon > maxmin[1].lon ) + maxmax.lon = maxmin[0].lon; + else + maxmax.lon = maxmin[1].lon; + + /* Never zoom in too far - generally not that useful, as too close ! */ + /* Always recalculate the 'best' zoom level */ + gdouble zoom = 1.0; + vik_viewport_set_zoom ( vvp, zoom ); + + gdouble min_lat, max_lat, min_lon, max_lon; + /* Should only be a maximum of about 18 iterations from min to max zoom levels */ + while ( zoom <= VIK_VIEWPORT_MAX_ZOOM ) { + vik_viewport_get_min_max_lat_lon ( vvp, &min_lat, &max_lat, &min_lon, &max_lon ); + /* NB I think the logic used in this test to determine if the bounds is within view + fails if track goes across 180 degrees longitude. + Hopefully that situation is not too common... + Mind you viking doesn't really do edge locations to well anyway */ + if ( min_lat < minmin.lat && + max_lat > minmin.lat && + min_lon < maxmax.lon && + max_lon > maxmax.lon ) + /* Found within zoom level */ + break; + + /* Try next */ + zoom = zoom * 2; + vik_viewport_set_zoom ( vvp, zoom ); + } +} + +gboolean vik_trw_layer_auto_set_view ( VikTrwLayer *vtl, VikViewport *vvp ) +{ + /* TODO: what if there's only one waypoint @ 0,0, it will think nothing found. */ + struct LatLon maxmin[2] = { {0.0,0.0}, {0.0,0.0} }; + trw_layer_find_maxmin (vtl, maxmin); + if (maxmin[0].lat == 0.0 && maxmin[0].lon == 0.0 && maxmin[1].lat == 0.0 && maxmin[1].lon == 0.0) + return FALSE; + else { + trw_layer_zoom_to_show_latlons ( vtl, vvp, maxmin ); + return TRUE; + } +} + +static void trw_layer_auto_view ( gpointer layer_and_vlp[2] ) +{ + if ( vik_trw_layer_auto_set_view ( VIK_TRW_LAYER(layer_and_vlp[0]), vik_layers_panel_get_viewport (VIK_LAYERS_PANEL(layer_and_vlp[1])) ) ) { + vik_layers_panel_emit_update ( VIK_LAYERS_PANEL(layer_and_vlp[1]) ); + } + else + a_dialog_info_msg ( VIK_GTK_WINDOW_FROM_LAYER(layer_and_vlp[0]), _("This layer has no waypoints or trackpoints.") ); +} + static void trw_layer_export ( gpointer layer_and_vlp[2], const gchar *title, const gchar* default_name, const gchar* trackname, guint file_type ) { GtkWidget *file_selector; @@ -1630,7 +1924,7 @@ static void trw_layer_export ( gpointer layer_and_vlp[2], const gchar *title, co } else { - if ( a_dialog_overwrite ( GTK_WINDOW(file_selector), _("The file \"%s\" exists, do you wish to overwrite it?"), a_file_basename ( fn ) ) ) + if ( a_dialog_yes_or_no ( 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, trackname); @@ -1726,16 +2020,20 @@ static void trw_layer_goto_wp ( gpointer layer_and_vlp[2] ) gboolean vik_trw_layer_new_waypoint ( VikTrwLayer *vtl, GtkWindow *w, const VikCoord *def_coord ) { - gchar *name = highest_wp_number_get(vtl); + gchar *default_name = highest_wp_number_get(vtl); VikWaypoint *wp = vik_waypoint_new(); + gchar *returned_name; + gboolean updated; wp->coord = *def_coord; - if ( a_dialog_new_waypoint ( w, &name, wp, vik_trw_layer_get_waypoints ( vtl ), vtl->coord_mode ) ) + if ( ( returned_name = a_dialog_waypoint ( w, default_name, wp, vik_trw_layer_get_waypoints ( vtl ), vtl->coord_mode, TRUE, &updated ) ) ) { wp->visible = TRUE; - vik_trw_layer_add_waypoint ( vtl, name, wp ); + vik_trw_layer_add_waypoint ( vtl, returned_name, wp ); + g_free (default_name); return TRUE; } + g_free (default_name); vik_waypoint_free(wp); return FALSE; } @@ -1793,6 +2091,46 @@ static void trw_layer_new_wp ( gpointer lav[2] ) vik_layers_panel_emit_update ( vlp ); } +static void trw_layer_auto_tracks_view ( gpointer lav[2] ) +{ + VikTrwLayer *vtl = VIK_TRW_LAYER(lav[0]); + VikLayersPanel *vlp = VIK_LAYERS_PANEL(lav[1]); + + if ( g_hash_table_size (vtl->tracks) > 0 ) { + struct LatLon maxmin[2] = { {0,0}, {0,0} }; + g_hash_table_foreach ( vtl->tracks, (GHFunc) trw_layer_find_maxmin_tracks, maxmin ); + trw_layer_zoom_to_show_latlons ( vtl, vik_layers_panel_get_viewport (vlp), maxmin ); + vik_layers_panel_emit_update ( vlp ); + } +} + +static void trw_layer_single_waypoint_jump ( const gchar *name, const VikWaypoint *wp, gpointer vvp ) +{ + /* NB do not care if wp is visible or not */ + vik_viewport_set_center_coord ( VIK_VIEWPORT(vvp), &(wp->coord) ); +} + +static void trw_layer_auto_waypoints_view ( gpointer lav[2] ) +{ + VikTrwLayer *vtl = VIK_TRW_LAYER(lav[0]); + VikLayersPanel *vlp = VIK_LAYERS_PANEL(lav[1]); + + /* Only 1 waypoint - jump straight to it */ + if ( g_hash_table_size (vtl->waypoints) == 1 ) { + VikViewport *vvp = vik_layers_panel_get_viewport (vlp); + g_hash_table_foreach ( vtl->waypoints, (GHFunc) trw_layer_single_waypoint_jump, (gpointer) vvp ); + } + /* If at least 2 waypoints - find center and then zoom to fit */ + else if ( g_hash_table_size (vtl->waypoints) > 1 ) + { + struct LatLon maxmin[2] = { {0,0}, {0,0} }; + g_hash_table_foreach ( vtl->waypoints, (GHFunc) trw_layer_find_maxmin_waypoints, maxmin ); + trw_layer_zoom_to_show_latlons ( vtl, vik_layers_panel_get_viewport (vlp), maxmin ); + } + + vik_layers_panel_emit_update ( vlp ); +} + void vik_trw_layer_add_menu_items ( VikTrwLayer *vtl, GtkMenu *menu, gpointer vlp ) { static gpointer pass_along[2]; @@ -1806,6 +2144,21 @@ void vik_trw_layer_add_menu_items ( VikTrwLayer *vtl, GtkMenu *menu, gpointer vl gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item ); gtk_widget_show ( item ); + item = gtk_menu_item_new_with_mnemonic ( _("_View Layer") ); + g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_auto_view), pass_along ); + gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); + gtk_widget_show ( item ); + + item = gtk_menu_item_new_with_mnemonic ( _("View All Trac_ks") ); + g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_auto_tracks_view), pass_along ); + gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); + gtk_widget_show ( item ); + + item = gtk_menu_item_new_with_mnemonic ( _("V_iew All Waypoints") ); + g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_auto_waypoints_view), pass_along ); + gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); + gtk_widget_show ( item ); + item = gtk_menu_item_new_with_mnemonic ( _("_Goto Center of Layer") ); g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_centerize), pass_along ); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); @@ -1892,18 +2245,18 @@ void vik_trw_layer_add_waypoint ( VikTrwLayer *vtl, gchar *name, VikWaypoint *wp else { GtkTreeIter *iter = g_malloc(sizeof(GtkTreeIter)); + // Visibility column always needed for waypoints #ifdef VIK_CONFIG_ALPHABETIZED_TRW vik_treeview_add_sublayer_alphabetized ( VIK_LAYER(vtl)->vt, &(vtl->waypoints_iter), iter, name, vtl, name, VIK_TRW_LAYER_SUBLAYER_WAYPOINT, NULL, TRUE, TRUE ); #else vik_treeview_add_sublayer ( VIK_LAYER(vtl)->vt, &(vtl->waypoints_iter), iter, name, vtl, name, VIK_TRW_LAYER_SUBLAYER_WAYPOINT, NULL, TRUE, TRUE ); #endif + // Actual setting of visibility dependent on the waypoint + vik_treeview_item_set_visible ( VIK_LAYER(vtl)->vt, iter, wp->visible ); vik_treeview_select_iter ( VIK_LAYER(vtl)->vt, iter ); g_hash_table_insert ( vtl->waypoints_iters, name, iter ); - wp->visible = TRUE; } } - else - wp->visible = TRUE; highest_wp_number_add_wp(vtl, name); g_hash_table_insert ( vtl->waypoints, name, wp ); @@ -1920,18 +2273,18 @@ void vik_trw_layer_add_track ( VikTrwLayer *vtl, gchar *name, VikTrack *t ) else { GtkTreeIter *iter = g_malloc(sizeof(GtkTreeIter)); + // Visibility column always needed for tracks #ifdef VIK_CONFIG_ALPHABETIZED_TRW - vik_treeview_add_sublayer_alphabetized ( VIK_LAYER(vtl)->vt, &(vtl->tracks_iter), iter, name, vtl, name, VIK_TRW_LAYER_SUBLAYER_TRACK, NULL, t->visible, TRUE ); + vik_treeview_add_sublayer_alphabetized ( VIK_LAYER(vtl)->vt, &(vtl->tracks_iter), iter, name, vtl, name, VIK_TRW_LAYER_SUBLAYER_TRACK, NULL, TRUE, TRUE ); #else - vik_treeview_add_sublayer ( VIK_LAYER(vtl)->vt, &(vtl->tracks_iter), iter, name, vtl, name, VIK_TRW_LAYER_SUBLAYER_TRACK, NULL, t->visible, TRUE ); + vik_treeview_add_sublayer ( VIK_LAYER(vtl)->vt, &(vtl->tracks_iter), iter, name, vtl, name, VIK_TRW_LAYER_SUBLAYER_TRACK, NULL, TRUE, TRUE ); #endif + // Actual setting of visibility dependent on the track + vik_treeview_item_set_visible ( VIK_LAYER(vtl)->vt, iter, t->visible ); vik_treeview_select_iter ( VIK_LAYER(vtl)->vt, iter ); g_hash_table_insert ( vtl->tracks_iters, name, iter ); - /* t->visible = TRUE; */ } } - else - ; /* t->visible = TRUE; // this is now used by file input functions */ g_hash_table_insert ( vtl->tracks, name, t ); @@ -2159,10 +2512,11 @@ static void trw_layer_properties_item ( gpointer pass_along[5] ) VikWaypoint *wp = g_hash_table_lookup ( vtl->waypoints, pass_along[3] ); if ( wp ) { - if ( a_dialog_new_waypoint ( VIK_GTK_WINDOW_FROM_LAYER(vtl), NULL, wp, NULL, vtl->coord_mode ) ) + gboolean updated = FALSE; + a_dialog_waypoint ( VIK_GTK_WINDOW_FROM_LAYER(vtl), pass_along[3], wp, NULL, vtl->coord_mode, FALSE, &updated ); - if ( VIK_LAYER(vtl)->visible ) - vik_layer_emit_update ( VIK_LAYER(vtl) ); + if ( updated && VIK_LAYER(vtl)->visible ) + vik_layer_emit_update ( VIK_LAYER(vtl) ); } } else @@ -2256,6 +2610,45 @@ static void trw_layer_goto_track_endpoint ( gpointer pass_along[6] ) goto_coord ( VIK_LAYERS_PANEL(pass_along[1]), &(((VikTrackpoint *) trps->data)->coord)); } +static void trw_layer_goto_track_max_speed ( gpointer pass_along[5] ) +{ + VikTrackpoint* vtp = vik_track_get_tp_by_max_speed ( g_hash_table_lookup ( VIK_TRW_LAYER(pass_along[0])->tracks, pass_along[3] ) ); + if ( !vtp ) + return; + goto_coord ( VIK_LAYERS_PANEL(pass_along[1]), &(vtp->coord)); +} + +static void trw_layer_goto_track_max_alt ( gpointer pass_along[5] ) +{ + VikTrackpoint* vtp = vik_track_get_tp_by_max_alt ( g_hash_table_lookup ( VIK_TRW_LAYER(pass_along[0])->tracks, pass_along[3] ) ); + if ( !vtp ) + return; + goto_coord ( VIK_LAYERS_PANEL(pass_along[1]), &(vtp->coord)); +} + +static void trw_layer_goto_track_min_alt ( gpointer pass_along[5] ) +{ + VikTrackpoint* vtp = vik_track_get_tp_by_min_alt ( g_hash_table_lookup ( VIK_TRW_LAYER(pass_along[0])->tracks, pass_along[3] ) ); + if ( !vtp ) + return; + goto_coord ( VIK_LAYERS_PANEL(pass_along[1]), &(vtp->coord)); +} + +/* + * Automatically change the viewport to center on the track and zoom to see the extent of the track + */ +static void trw_layer_auto_track_view ( gpointer pass_along[5] ) +{ + GList **trps = g_hash_table_lookup ( VIK_TRW_LAYER(pass_along[0])->tracks, pass_along[3] ); + if ( trps && *trps ) + { + struct LatLon maxmin[2] = { {0,0}, {0,0} }; + trw_layer_find_maxmin_tracks ( NULL, trps, maxmin ); + + trw_layer_zoom_to_show_latlons ( VIK_TRW_LAYER(pass_along[0]), vik_layers_panel_get_viewport (VIK_LAYERS_PANEL(pass_along[1])), maxmin ); + vik_layers_panel_emit_update ( VIK_LAYERS_PANEL(pass_along[1]) ); + } +} /************************************* * merge/split by time routines @@ -2364,6 +2757,22 @@ static gint trackpoint_compare(gconstpointer a, gconstpointer b) return 0; } +#ifdef VIK_CONFIG_ALPHABETIZED_TRW +/** + * comparison function which can be used to sort tracks or waypoints by name + */ +static gint sort_alphabetically (gconstpointer a, gconstpointer b, gpointer user_data) +{ + const gchar* namea = (const gchar*) a; + const gchar* nameb = (const gchar*) b; + if ( namea == NULL || nameb == NULL) + return 0; + else + // Same sort method as used in the vik_treeview_*_alphabetize functions + return strcmp ( namea, nameb ); +} +#endif + static void trw_layer_merge_with_other ( gpointer pass_along[6] ) { VikTrwLayer *vtl = (VikTrwLayer *)pass_along[0]; @@ -2391,8 +2800,13 @@ static void trw_layer_merge_with_other ( gpointer pass_along[6] ) return; } +#ifdef VIK_CONFIG_ALPHABETIZED_TRW + // Sort alphabetically for user presentation + tracks_with_timestamp = g_list_sort_with_data (tracks_with_timestamp, sort_alphabetically, NULL); +#endif + GList *merge_list = a_dialog_select_from_list(VIK_GTK_WINDOW_FROM_LAYER(vtl), - vtl->tracks, tracks_with_timestamp, TRUE, + tracks_with_timestamp, TRUE, _("Merge with..."), _("Select track to merge with")); g_list_free(tracks_with_timestamp); @@ -2768,8 +3182,16 @@ gboolean vik_trw_layer_sublayer_add_menu_items ( VikTrwLayer *l, GtkMenu *menu, if ( subtype == VIK_TRW_LAYER_SUBLAYER_WAYPOINT ) { + gboolean separator_created = FALSE; + /* could be a right-click using the tool */ if ( vlp != NULL ) { + item = gtk_menu_item_new (); + gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item ); + gtk_widget_show ( item ); + + separator_created = TRUE; + item = gtk_menu_item_new_with_mnemonic ( _("_Goto") ); g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_goto_waypoint), pass_along ); gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item ); @@ -2778,6 +3200,12 @@ gboolean vik_trw_layer_sublayer_add_menu_items ( VikTrwLayer *l, GtkMenu *menu, if ( is_valid_geocache_name ( (gchar *) sublayer ) ) { + if ( !separator_created ) { + item = gtk_menu_item_new (); + gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item ); + gtk_widget_show ( item ); + } + item = gtk_menu_item_new_with_mnemonic ( _("_Visit Geocache Webpage") ); g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_waypoint_gc_webpage), pass_along ); gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item ); @@ -2787,24 +3215,59 @@ gboolean vik_trw_layer_sublayer_add_menu_items ( VikTrwLayer *l, GtkMenu *menu, } } + if ( vlp && (subtype == VIK_TRW_LAYER_SUBLAYER_WAYPOINTS || subtype == VIK_TRW_LAYER_SUBLAYER_WAYPOINT) ) + { + item = gtk_menu_item_new_with_mnemonic ( _("_New Waypoint") ); + g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_new_wp), pass_along ); + gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); + gtk_widget_show ( item ); + } + if ( subtype == VIK_TRW_LAYER_SUBLAYER_TRACK ) { + GtkWidget *goto_submenu; item = gtk_menu_item_new (); gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item ); gtk_widget_show ( item ); - item = gtk_menu_item_new_with_mnemonic ( _("_Goto Startpoint") ); + goto_submenu = gtk_menu_new (); + item = gtk_menu_item_new_with_mnemonic ( _("_Goto") ); + gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); + gtk_widget_show ( item ); + gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), goto_submenu ); + + item = gtk_menu_item_new_with_mnemonic ( _("_Startpoint") ); g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_goto_track_startpoint), pass_along ); - gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item ); + gtk_menu_shell_append ( GTK_MENU_SHELL(goto_submenu), item ); gtk_widget_show ( item ); - item = gtk_menu_item_new_with_mnemonic ( _("Goto \"_Center\"") ); + item = gtk_menu_item_new_with_mnemonic ( _("\"_Center\"") ); g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_goto_track_center), pass_along ); - gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item ); + gtk_menu_shell_append ( GTK_MENU_SHELL(goto_submenu), item ); gtk_widget_show ( item ); - item = gtk_menu_item_new_with_mnemonic ( _("Goto _Endpoint") ); + item = gtk_menu_item_new_with_mnemonic ( _("_Endpoint") ); g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_goto_track_endpoint), pass_along ); + gtk_menu_shell_append ( GTK_MENU_SHELL(goto_submenu), item ); + gtk_widget_show ( item ); + + item = gtk_menu_item_new_with_mnemonic ( _("_Highest Altitude") ); + g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_goto_track_max_alt), pass_along ); + gtk_menu_shell_append ( GTK_MENU_SHELL(goto_submenu), item ); + gtk_widget_show ( item ); + + item = gtk_menu_item_new_with_mnemonic ( _("_Lowest Altitude") ); + g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_goto_track_min_alt), pass_along ); + gtk_menu_shell_append ( GTK_MENU_SHELL(goto_submenu), item ); + gtk_widget_show ( item ); + + item = gtk_menu_item_new_with_mnemonic ( _("_Maximum Speed") ); + g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_goto_track_max_speed), pass_along ); + gtk_menu_shell_append ( GTK_MENU_SHELL(goto_submenu), item ); + gtk_widget_show ( item ); + + item = gtk_menu_item_new_with_mnemonic ( _("_View Track") ); + g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_auto_track_view), pass_along ); gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item ); gtk_widget_show ( item ); @@ -2877,18 +3340,6 @@ gboolean vik_trw_layer_sublayer_add_menu_items ( VikTrwLayer *l, GtkMenu *menu, } } - if ( vlp && (subtype == VIK_TRW_LAYER_SUBLAYER_WAYPOINTS || subtype == VIK_TRW_LAYER_SUBLAYER_WAYPOINT) ) - { - item = gtk_menu_item_new (); - gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item ); - gtk_widget_show ( item ); - - item = gtk_menu_item_new_with_mnemonic ( _("_New Waypoint") ); - g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_new_wp), pass_along ); - gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); - gtk_widget_show ( item ); - } - return rv; } @@ -2981,8 +3432,8 @@ static void trw_layer_tpwin_response ( VikTrwLayer *vtl, gint response ) trw_layer_cancel_current_tp ( vtl, TRUE ); else if ( response == VIK_TRW_LAYER_TPWIN_SPLIT && vtl->current_tpl->next && vtl->current_tpl->prev ) { - gchar *name; - if ( ( name = a_dialog_new_track ( GTK_WINDOW(vtl->tpwin), vtl->tracks, NULL ) ) ) + gchar *name = get_new_unique_sublayer_name(vtl, VIK_TRW_LAYER_SUBLAYER_TRACK, vtl->current_tp_track_name); + if ( ( name = a_dialog_new_track ( GTK_WINDOW(vtl->tpwin), vtl->tracks, name ) ) ) { VikTrack *tr = vik_track_new (); GList *newglist = g_list_alloc (); @@ -3089,6 +3540,11 @@ static void trw_layer_tpwin_response ( VikTrwLayer *vtl, gint response ) trw_layer_cancel_last_tp ( vtl ); /* same TP, can't join. */ vik_layer_emit_update(VIK_LAYER(vtl)); } + else if ( response == VIK_TRW_LAYER_TPWIN_INSERT && vtl->current_tpl->next ) + { + trw_layer_insert_tp_after_current_tp ( vtl ); + vik_layer_emit_update(VIK_LAYER(vtl)); + } else if ( response == VIK_TRW_LAYER_TPWIN_DATA_CHANGED ) vik_layer_emit_update (VIK_LAYER(vtl)); } @@ -3915,7 +4371,10 @@ static void create_thumbnails_thread ( GSList *pics, gpointer threaddata ) while ( pics ) { a_thumbnails_create ( (gchar *) pics->data ); - a_background_thread_progress ( threaddata, ((gdouble) ++done) / total ); + int result = a_background_thread_progress ( threaddata, ((gdouble) ++done) / total ); + if ( result != 0 ) + return -1; /* Abort thread */ + pics = pics->next; } }