static void srtm_dem_download_thread ( DEMDownloadParams *p, gpointer threaddata ) { gint intlat, intlon; const gchar *continent_dir; intlat = (int)floor(p->lat); intlon = (int)floor(p->lon); continent_dir = srtm_continent_dir(intlat, intlon); if (!continent_dir) { if ( p->vdl ) { gchar *msg = g_strdup_printf ( _("No SRTM data available for %f, %f"), p->lat, p->lon ); vik_window_statusbar_update ( (VikWindow*)VIK_GTK_WINDOW_FROM_LAYER(p->vdl), msg, VIK_STATUSBAR_INFO ); g_free ( msg ); } return; } gchar *src_fn = g_strdup_printf("%s%s/%c%02d%c%03d.hgt.zip", SRTM_HTTP_URI, continent_dir, (intlat >= 0) ? 'N' : 'S', ABS(intlat), (intlon >= 0) ? 'E' : 'W', ABS(intlon) ); static DownloadMapOptions options = { FALSE, FALSE, NULL, 0, a_check_map_file, NULL, NULL }; a_http_download_get_url ( SRTM_HTTP_SITE, src_fn, p->dest, &options, NULL ); g_free ( src_fn ); }
/** * vik_trw_layer_waypoint_list_show_dialog: * @title: The title for the dialog * @vl: The #VikLayer passed on into get_waypoints_and_layers_cb() * @user_data: Data passed on into get_waypoints_and_layers_cb() * @get_waypoints_and_layers_cb: The function to call to construct items to be analysed * @show_layer_names: Normally only set when called from an aggregate level * * Common method for showing a list of waypoints with extended information * */ void vik_trw_layer_waypoint_list_show_dialog ( gchar *title, VikLayer *vl, gpointer user_data, VikTrwlayerGetWaypointsAndLayersFunc get_waypoints_and_layers_cb, gboolean show_layer_names ) { GtkWidget *dialog = gtk_dialog_new_with_buttons ( title, VIK_GTK_WINDOW_FROM_LAYER(vl), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, NULL ); GList *gl = get_waypoints_and_layers_cb ( vl, user_data ); vik_trw_layer_waypoint_list_internal ( dialog, gl, show_layer_names ); // Use response to close the dialog with tidy up g_signal_connect ( G_OBJECT(dialog), "response", G_CALLBACK(waypoint_close_cb), gl ); gtk_widget_show_all ( dialog ); // Yes - set the size *AGAIN* - this time widgets are expanded nicely gtk_window_resize ( GTK_WINDOW(dialog), show_layer_names ? 800 : 600, 400 ); // ATM lock out on dialog run - to prevent list contents being manipulated in other parts of the GUI whilst shown here. gtk_dialog_run (GTK_DIALOG (dialog)); // Unfortunately seems subsequently opening the Waypoint Properties we can't interact with it until this dialog is closed // Thus this dialog is then forcibly closed when opening the properties. // Occassionally the 'View' doesn't update the viewport properly // viewport center + zoom is changed but the viewport isn't updated // not sure why yet.. }
gboolean vik_layer_selected ( VikLayer *l, gint subtype, gpointer sublayer, gint type, gpointer vlp ) { if ( vik_layer_interfaces[l->type]->layer_selected ) return vik_layer_interfaces[l->type]->layer_selected ( l, subtype, sublayer, type, vlp ); /* Since no 'layer_selected' function explicitly turn off here */ return vik_window_clear_highlight ( (VikWindow *)VIK_GTK_WINDOW_FROM_LAYER(l) ); }
static void check_br_is_good_or_msg_user ( VikGeorefLayer *vgl ) { // if a 'blank' ll value that's alright if ( vgl->ll_br.lat == 0.0 && vgl->ll_br.lon == 0.0 ) return; struct LatLon ll_tl = get_ll_tl (vgl); if ( ll_tl.lat < vgl->ll_br.lat || ll_tl.lon > vgl->ll_br.lon ) a_dialog_warning_msg ( VIK_GTK_WINDOW_FROM_LAYER(vgl), _("Lower right corner values may not be consistent with upper right values") ); }
/** * Draw specified layer */ void vik_layer_emit_update ( VikLayer *vl ) { if ( vl->visible && vl->realized ) { vik_window_set_redraw_trigger(vl); // Only ever draw when there is time to do so if ( g_thread_self() != vik_window_get_thread (VIK_WINDOW(VIK_GTK_WINDOW_FROM_LAYER(vl))) ) // Drawing requested from another (background) thread, so handle via the gdk thread method gdk_threads_add_idle ( (GSourceFunc) idle_draw, vl ); else g_idle_add ( (GSourceFunc) idle_draw, vl ); } }
static void clip_add_wp(VikLayersPanel *vlp, struct LatLon *coord) { VikCoord vc; VikLayer *sel = vik_layers_panel_get_selected ( vlp ); vik_coord_load_from_latlon ( &vc, VIK_COORD_LATLON, coord ); if (sel && sel->type == VIK_LAYER_TRW) { vik_trw_layer_new_waypoint ( VIK_TRW_LAYER(sel), VIK_GTK_WINDOW_FROM_LAYER(sel), &vc ); } else { a_dialog_error_msg_extra ( VIK_GTK_WINDOW_FROM_WIDGET(GTK_WIDGET(vlp)), _("In order to paste a waypoint, please select an appropriate layer to paste into."), NULL); } }
/** * Search all TrackWaypoint layers in this aggregate layer for an item on the user specified date */ static void aggregate_layer_search_date ( menu_array_values values ) { VikAggregateLayer *val = VIK_AGGREGATE_LAYER ( values[MA_VAL] ); VikCoord position; gchar *date_str = a_dialog_get_date ( VIK_GTK_WINDOW_FROM_LAYER(val), _("Search by Date") ); if ( !date_str ) return; VikViewport *vvp = vik_window_viewport ( VIK_WINDOW(VIK_GTK_WINDOW_FROM_LAYER(val)) ); GList *gl = NULL; gl = vik_aggregate_layer_get_all_layers_of_type ( val, gl, VIK_LAYER_TRW, TRUE ); gboolean found = FALSE; // Search tracks first while ( gl && !found ) { // Make it auto select the item if found found = vik_trw_layer_find_date ( VIK_TRW_LAYER(gl->data), date_str, &position, vvp, TRUE, TRUE ); gl = g_list_next ( gl ); } g_list_free ( gl ); if ( !found ) { // Reset and try on Waypoints gl = NULL; gl = vik_aggregate_layer_get_all_layers_of_type ( val, gl, VIK_LAYER_TRW, TRUE ); while ( gl && !found ) { // Make it auto select the item if found found = vik_trw_layer_find_date ( VIK_TRW_LAYER(gl->data), date_str, &position, vvp, FALSE, TRUE ); gl = g_list_next ( gl ); } g_list_free ( gl ); } if ( !found ) a_dialog_info_msg ( VIK_GTK_WINDOW_FROM_LAYER(val), _("No items found with the requested date.") ); g_free ( date_str ); }
static void aggregate_layer_analyse ( gpointer data[2] ) { VikAggregateLayer *val = VIK_AGGREGATE_LAYER(data[0]); // There can only be one! if ( val->tracks_analysis_dialog ) return; val->tracks_analysis_dialog = vik_trw_layer_analyse_this ( VIK_GTK_WINDOW_FROM_LAYER(VIK_LAYER(val)), VIK_LAYER(val)->name, VIK_LAYER(val), NULL, aggregate_layer_track_create_list, aggregate_layer_analyse_close ); }
static void aggregate_layer_analyse ( menu_array_values values ) { VikAggregateLayer *val = VIK_AGGREGATE_LAYER ( values[MA_VAL] ); // There can only be one! if ( val->tracks_analysis_dialog ) return; val->tracks_analysis_dialog = vik_trw_layer_analyse_this ( VIK_GTK_WINDOW_FROM_LAYER(VIK_LAYER(val)), VIK_LAYER(val)->name, VIK_LAYER(val), NULL, aggregate_layer_track_create_list, aggregate_layer_analyse_close ); }
/** * Load a single JPG into a Trackwaypoint Layer as a waypoint * * @top: The Aggregate layer that a new TRW layer may be created in * @filename: The JPG filename * @vvp: The viewport * * Returns: Whether the loading was a success or not * * If the JPG has geotag information then the waypoint will be created with the appropriate position. * Otherwise the waypoint will be positioned at the current screen center. * If a TRW layer is already selected the waypoint will be created in that layer. */ gboolean a_jpg_load_file ( VikAggregateLayer *top, const gchar *filename, VikViewport *vvp ) { gboolean auto_zoom = TRUE; VikWindow *vw = (VikWindow *)(VIK_GTK_WINDOW_FROM_LAYER(VIK_LAYER(top))); VikLayersPanel *vlp = vik_window_layers_panel ( vw ); // Auto load into TrackWaypoint layer if one is selected VikLayer *vtl = vik_layers_panel_get_selected ( vlp ); gboolean create_layer = FALSE; if ( vtl == NULL || vtl->type != VIK_LAYER_TRW ) { // Create layer if necessary vtl = vik_layer_create ( VIK_LAYER_TRW, vvp, FALSE ); vik_layer_rename ( vtl, a_file_basename ( filename ) ); create_layer = TRUE; } gchar *name = NULL; VikWaypoint *wp = NULL; #ifdef VIK_CONFIG_GEOTAG wp = a_geotag_create_waypoint_from_file ( filename, vik_viewport_get_coord_mode (vvp), &name ); #endif if ( wp ) { // Create name if geotag method didn't return one if ( !name ) name = g_strdup ( a_file_basename ( filename ) ); vik_trw_layer_filein_add_waypoint ( VIK_TRW_LAYER(vtl), name, wp ); g_free ( name ); } else { wp = vik_waypoint_new (); wp->visible = TRUE; vik_trw_layer_filein_add_waypoint ( VIK_TRW_LAYER(vtl), (gchar*) a_file_basename(filename), wp ); vik_waypoint_set_image ( wp, filename ); // Simply set position to the current center wp->coord = *( vik_viewport_get_center ( vvp ) ); auto_zoom = FALSE; } // Complete the setup vik_layer_post_read ( vtl, vvp, TRUE ); if ( create_layer ) vik_aggregate_layer_add_layer ( top, vtl, FALSE ); if ( auto_zoom ) vik_trw_layer_auto_set_view ( VIK_TRW_LAYER(vtl), vvp ); // ATM This routine can't fail return TRUE; }
static void trw_layer_show_picture ( menu_array_values values ) { VikWaypoint *wpt = VIK_WAYPOINT(values[MA_WPT]); #ifdef WINDOWS ShellExecute(NULL, "open", wpt->image, NULL, NULL, SW_SHOWNORMAL); #else VikTrwLayer *vtl = VIK_TRW_LAYER(values[MA_VTL]); GError *err = NULL; gchar *quoted_file = g_shell_quote ( wpt->image ); gchar *cmd = g_strdup_printf ( "%s %s", a_vik_get_image_viewer(), quoted_file ); g_free ( quoted_file ); if ( ! g_spawn_command_line_async ( cmd, &err ) ) { a_dialog_error_msg_extra ( VIK_GTK_WINDOW_FROM_LAYER(vtl), _("Could not launch %s to open file."), a_vik_get_image_viewer() ); g_error_free ( err ); } g_free ( cmd ); #endif }
static void trw_layer_waypoint_properties ( menu_array_values values ) { VikTrwLayer *vtl = VIK_TRW_LAYER(values[MA_VTL]); VikWaypoint *wpt = VIK_WAYPOINT(values[MA_WPT]); if ( wpt && wpt->name ) { // Kill off this dialog to allow interaction with properties window // since the properties also allows waypoint manipulations it won't cause conflicts here. GtkWidget *gw = gtk_widget_get_toplevel ( values[MA_TREEVIEW] ); waypoint_close_cb ( gw, 0, values[MA_WPTS_LIST] ); gboolean updated = FALSE; gchar *new_name = a_dialog_waypoint ( VIK_GTK_WINDOW_FROM_LAYER(vtl), wpt->name, vtl, wpt, vik_trw_layer_get_coord_mode(vtl), FALSE, &updated ); if ( new_name ) trw_layer_waypoint_rename ( vtl, wpt, new_name ); if ( updated ) trw_layer_waypoint_reset_icon ( vtl, wpt ); if ( updated && VIK_LAYER(vtl)->visible ) vik_layer_emit_update ( VIK_LAYER(vtl) ); } }
/** * uploading function executed by the background" thread */ static void osm_traces_upload_thread ( OsmTracesInfo *oti, gpointer threaddata ) { /* Due to OSM limits, we have to enforce ele and time fields */ static GpxWritingOptions options = { TRUE, TRUE }; FILE *file = NULL; gchar *filename = NULL; int fd; GError *error = NULL; int ret; g_assert(oti != NULL); /* Opening temporary file */ fd = g_file_open_tmp("viking_osm_upload_XXXXXX.gpx", &filename, &error); if (fd < 0) { g_error(_("failed to open temporary file: %s"), strerror(errno)); return; } g_clear_error(&error); g_debug("%s: temporary file = %s", __FUNCTION__, filename); /* Creating FILE* */ file = fdopen(fd, "w"); /* writing gpx file */ if (oti->track_name != NULL) { /* Upload only the selected track */ VikTrack *track = vik_trw_layer_get_track(oti->vtl, oti->track_name); a_gpx_write_track_file_options(&options, oti->track_name, track, file); } else { /* Upload the whole VikTrwLayer */ a_gpx_write_file_options(&options, oti->vtl, file); } /* We can close the file */ /* This also close the associated fd */ fclose(file); file = NULL; /* finally, upload it */ gint ans = osm_traces_upload_file(user, password, filename, oti->name, oti->description, oti->tags, oti->vistype); // // Show result in statusbar or failure in dialog for user feedback // // Get current time to put into message to show when result was generated // since need to show difference between operations (when displayed on statusbar) // NB If on dialog then don't need time. time_t timenow; struct tm* timeinfo; time ( &timenow ); timeinfo = localtime ( &timenow ); gchar timestr[80]; // Compact time only - as days/date isn't very useful here strftime ( timestr, sizeof(timestr), "%X)", timeinfo ); // // Test to see if window it was invoked on is still valid // Not sure if this test really works! (i.e. if the window was closed in the mean time) // if ( IS_VIK_WINDOW ((VikWindow *)VIK_GTK_WINDOW_FROM_LAYER(oti->vtl)) ) { gchar* msg; if ( ans == 0 ) { // Success msg = g_strdup_printf ( "%s (@%s)", _("Uploaded to OSM"), timestr ); vik_statusbar_set_message ( vik_window_get_statusbar ( (VikWindow *)VIK_GTK_WINDOW_FROM_LAYER(oti->vtl) ), VIK_STATUSBAR_INFO, msg ); } // Use UPPER CASE for bad news :( else if ( ans < 0 ) { msg = g_strdup_printf ( "%s (@%s)", _("FAILED TO UPLOAD DATA TO OSM - CURL PROBLEM"), timestr ); vik_statusbar_set_message ( vik_window_get_statusbar ( (VikWindow *)VIK_GTK_WINDOW_FROM_LAYER(oti->vtl) ), VIK_STATUSBAR_INFO, msg ); //a_dialog_error_msg ( VIK_GTK_WINDOW_FROM_LAYER(oti->vtl), msg ); } else { msg = g_strdup_printf ( "%s : %s %d (@%s)", _("FAILED TO UPLOAD DATA TO OSM"), _("HTTP response code"), ans, timestr ); vik_statusbar_set_message ( vik_window_get_statusbar ( (VikWindow *)VIK_GTK_WINDOW_FROM_LAYER(oti->vtl) ), VIK_STATUSBAR_INFO, msg ); //VikTrwLayer *vtl = oti->vtl; // Crashes here - multi-thread issue... //a_dialog_error_msg ( VIK_GTK_WINDOW_FROM_LAYER(vtl), msg ); } g_free (msg); } /* Removing temporary file */ ret = g_unlink(filename); if (ret != 0) { g_error(_("failed to unlink temporary file: %s"), strerror(errno)); } }
/** * Parse user input from dialog response */ static void trw_layer_geotag_response_cb ( GtkDialog *dialog, gint resp, GeoTagWidgets *widgets ) { switch (resp) { case GTK_RESPONSE_DELETE_EVENT: /* received delete event (not from buttons) */ case GTK_RESPONSE_REJECT: break; default: { //GTK_RESPONSE_ACCEPT: // Get options geotag_options_t *options = g_malloc ( sizeof(geotag_options_t) ); options->vtl = widgets->vtl; options->track = widgets->track; // Values extracted from the widgets: options->ov.create_waypoints = gtk_toggle_button_get_active ( GTK_TOGGLE_BUTTON(widgets->create_waypoints_b) ); options->ov.write_exif = gtk_toggle_button_get_active ( GTK_TOGGLE_BUTTON(widgets->write_exif_b) ); options->ov.overwrite_gps_exif = gtk_toggle_button_get_active ( GTK_TOGGLE_BUTTON(widgets->overwrite_gps_exif_b) ); options->ov.no_change_mtime = gtk_toggle_button_get_active ( GTK_TOGGLE_BUTTON(widgets->no_change_mtime_b) ); options->ov.interpolate_segments = gtk_toggle_button_get_active ( GTK_TOGGLE_BUTTON(widgets->interpolate_segments_b) ); options->ov.TimeZoneHours = 0; options->ov.TimeZoneMins = 0; const gchar* TZString = gtk_entry_get_text(GTK_ENTRY(widgets->time_zone_b)); /* Check the string. If there is a colon, then (hopefully) it's a time in xx:xx format. * If not, it's probably just a +/-xx format. In all other cases, * it will be interpreted as +/-xx, which, if given a string, returns 0. */ if (strstr(TZString, ":")) { /* Found colon. Split into two. */ sscanf(TZString, "%d:%d", &options->ov.TimeZoneHours, &options->ov.TimeZoneMins); if (options->ov.TimeZoneHours < 0) options->ov.TimeZoneMins *= -1; } else { /* No colon. Just parse. */ options->ov.TimeZoneHours = atoi(TZString); } options->ov.time_offset = atoi ( gtk_entry_get_text ( GTK_ENTRY(widgets->time_offset_b) ) ); options->redraw = FALSE; // Save settings for reuse default_values = options->ov; options->files = g_list_copy ( vik_file_list_get_files ( widgets->files ) ); gint len = g_list_length ( options->files ); gchar *tmp = g_strdup_printf ( _("Geotagging %d Images..."), len ); // Processing lots of files can take time - so run a background effort a_background_thread ( VIK_GTK_WINDOW_FROM_LAYER(options->vtl), tmp, (vik_thr_func) trw_layer_geotag_thread, options, (vik_thr_free_func) trw_layer_geotag_thread_free, NULL, len ); g_free ( tmp ); break; } } geotag_widgets_free ( widgets ); gtk_widget_destroy ( GTK_WIDGET(dialog) ); }
/** * Uploading a VikTrwLayer * * @param vtl VikTrwLayer * @param trk if not null, the track to upload */ void osm_traces_upload_viktrwlayer ( VikTrwLayer *vtl, VikTrack *trk ) { GtkWidget *dia = gtk_dialog_new_with_buttons (_("OSM upload"), VIK_GTK_WINDOW_FROM_LAYER(vtl), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, NULL); const gchar *name = NULL; GtkWidget *user_label, *user_entry = NULL; GtkWidget *password_label, *password_entry = NULL; GtkWidget *name_label, *name_entry; GtkWidget *description_label, *description_entry; GtkWidget *tags_label, *tags_entry; GtkWidget *visibility; GtkWidget *anonymize_checkbutton = NULL; const OsmTraceVis_t *vis_t; if ( osm_use_basic_auth() ) { user_label = gtk_label_new(_("Email/username:"******"The email/username used as login\n" "<small>Enter the email/username you use to login into www.openstreetmap.org.</small>")); password_label = gtk_label_new(_("Password:"******"The password used to login\n" "<small>Enter the password you use to login into www.openstreetmap.org.</small>")); osm_login_widgets ( user_entry, password_entry ); } name_label = gtk_label_new(_("File's name:")); name_entry = ui_entry_new ( NULL, GTK_ENTRY_ICON_SECONDARY ); if (trk != NULL) name = trk->name; else name = vik_layer_get_name(VIK_LAYER(vtl)); gtk_entry_set_text(GTK_ENTRY(name_entry), name); gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dia))), name_label, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dia))), name_entry, FALSE, FALSE, 0); gtk_widget_set_tooltip_markup(GTK_WIDGET(name_entry), _("The name of the file on OSM\n" "<small>This is the name of the file created on the server." "This is not the name of the local file.</small>")); description_label = gtk_label_new(_("Description:")); description_entry = ui_entry_new ( NULL, GTK_ENTRY_ICON_SECONDARY ); const gchar *description = NULL; if (trk != NULL) description = trk->description; else { VikTRWMetadata *md = vik_trw_layer_get_metadata (vtl); description = md ? md->description : NULL; } if (description) gtk_entry_set_text(GTK_ENTRY(description_entry), description); gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dia))), description_label, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dia))), description_entry, FALSE, FALSE, 0); gtk_widget_set_tooltip_text(GTK_WIDGET(description_entry), _("The description of the trace")); if (trk != NULL) { GtkWidget *label = gtk_label_new(_("Anonymize Times:")); anonymize_checkbutton = gtk_check_button_new (); gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dia))), label, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dia))), anonymize_checkbutton, FALSE, FALSE, 0); gtk_widget_set_tooltip_text(GTK_WIDGET(anonymize_checkbutton), _("Anonymize times of the trace.\n" "<small>You may choose to make the trace identifiable, yet mask the actual real time values</small>")); } tags_label = gtk_label_new(_("Tags:")); tags_entry = ui_entry_new ( NULL, GTK_ENTRY_ICON_SECONDARY ); VikTRWMetadata *md = vik_trw_layer_get_metadata (vtl); if (md->keywords) gtk_entry_set_text(GTK_ENTRY(tags_entry), md->keywords); gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dia))), tags_label, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dia))), tags_entry, FALSE, FALSE, 0); gtk_widget_set_tooltip_text(GTK_WIDGET(tags_entry), _("The tags associated to the trace")); visibility = vik_combo_box_text_new(); for (vis_t = OsmTraceVis; vis_t->combostr != NULL; vis_t++) vik_combo_box_text_append (visibility, vis_t->combostr); // Set identifiable by default or use the settings for the value if ( last_active < 0 ) { gint find_entry = -1; gint wanted_entry = -1; gchar *vis = NULL; if ( a_settings_get_string ( VIK_SETTINGS_OSM_TRACE_VIS, &vis ) ) { // Use setting if ( vis ) { for (vis_t = OsmTraceVis; vis_t->apistr != NULL; vis_t++) { find_entry++; if (!strcmp(vis, vis_t->apistr)) { wanted_entry = find_entry; } } } g_free ( vis ); // If not found set it to the first entry, otherwise use the entry last_active = ( wanted_entry < 0 ) ? 0 : wanted_entry; } else last_active = 0; } gtk_combo_box_set_active(GTK_COMBO_BOX(visibility), last_active); gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dia))), GTK_WIDGET(visibility), FALSE, FALSE, 0); /* User should think about it first... */ gtk_dialog_set_default_response ( GTK_DIALOG(dia), GTK_RESPONSE_REJECT ); gtk_widget_show_all ( dia ); gtk_widget_grab_focus ( description_entry ); if ( gtk_dialog_run ( GTK_DIALOG(dia) ) == GTK_RESPONSE_ACCEPT ) { gchar *title = NULL; if ( osm_use_basic_auth() ) { /* overwrite authentication info */ osm_set_login(gtk_entry_get_text(GTK_ENTRY(user_entry)), gtk_entry_get_text(GTK_ENTRY(password_entry))); } /* Storing data for the future thread */ OsmTracesInfo *info = g_malloc(sizeof(OsmTracesInfo)); info->name = g_strdup(gtk_entry_get_text(GTK_ENTRY(name_entry))); info->description = g_strdup(gtk_entry_get_text(GTK_ENTRY(description_entry))); /* TODO Normalize tags: they will be used as URL part */ info->tags = g_strdup(gtk_entry_get_text(GTK_ENTRY(tags_entry))); info->vistype = &OsmTraceVis[gtk_combo_box_get_active(GTK_COMBO_BOX(visibility))]; info->vtl = VIK_TRW_LAYER(g_object_ref(vtl)); info->trk = trk; if (trk != NULL && anonymize_checkbutton != NULL ) info->anonymize_times = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(anonymize_checkbutton)); else info->anonymize_times = FALSE; // Save visibility value for default reuse last_active = gtk_combo_box_get_active(GTK_COMBO_BOX(visibility)); a_settings_set_string ( VIK_SETTINGS_OSM_TRACE_VIS, OsmTraceVis[last_active].apistr ); title = g_strdup_printf(_("Uploading %s to OSM"), info->name); // launch the thread a_background_thread( BACKGROUND_POOL_REMOTE, VIK_GTK_WINDOW_FROM_LAYER(vtl), /* parent window */ title, /* description string */ (vik_thr_func) osm_traces_upload_thread, /* function to call within thread */ info, /* pass along data */ (vik_thr_free_func) oti_free, /* function to free pass along data */ (vik_thr_free_func) NULL, 1 ); g_free ( title ); title = NULL; } gtk_widget_destroy ( dia ); }
/** * uploading function executed by the background" thread */ static void osm_traces_upload_thread ( OsmTracesInfo *oti, gpointer threaddata ) { /* Due to OSM limits, we have to enforce ele and time fields also don't upload invisible tracks */ static GpxWritingOptions options = { TRUE, TRUE, FALSE, FALSE }; if (!oti) return; gchar *filename = NULL; /* writing gpx file */ if (oti->trk != NULL) { /* Upload only the selected track */ if ( oti->anonymize_times ) { VikTrack *trk = vik_track_copy(oti->trk, TRUE); vik_track_anonymize_times(trk); filename = a_gpx_write_track_tmp_file(trk, &options); vik_track_free(trk); } else filename = a_gpx_write_track_tmp_file (oti->trk, &options); } else { /* Upload the whole VikTrwLayer */ filename = a_gpx_write_tmp_file (oti->vtl, &options); } if ( !filename ) return; /* finally, upload it */ gint ans = osm_traces_upload_file(osm_user, osm_password, filename, oti->name, oti->description, oti->tags, oti->vistype); // // Show result in statusbar or failure in dialog for user feedback // // Get current time to put into message to show when result was generated // since need to show difference between operations (when displayed on statusbar) // NB If on dialog then don't need time. time_t timenow; struct tm* timeinfo; time ( &timenow ); timeinfo = localtime ( &timenow ); gchar timestr[80]; // Compact time only - as days/date isn't very useful here strftime ( timestr, sizeof(timestr), "%X)", timeinfo ); // // Test to see if window it was invoked on is still valid // Not sure if this test really works! (i.e. if the window was closed in the mean time) // if ( IS_VIK_WINDOW ((VikWindow *)VIK_GTK_WINDOW_FROM_LAYER(oti->vtl)) ) { gchar* msg; if ( ans == 0 ) { // Success msg = g_strdup_printf ( "%s (@%s)", _("Uploaded to OSM"), timestr ); } // Use UPPER CASE for bad news :( else if ( ans == 1001 ) { msg = g_strdup_printf ( "%s (@%s)", _("FAILED TO UPLOAD DATA TO OSM - Ensure the OSM access token preferences are setup."), timestr ); } else if ( ans < 0 ) { msg = g_strdup_printf ( "%s (@%s)", _("FAILED TO UPLOAD DATA TO OSM - CURL PROBLEM"), timestr ); } else { msg = g_strdup_printf ( "%s : %s %d (@%s)", _("FAILED TO UPLOAD DATA TO OSM"), _("HTTP response code"), ans, timestr ); } vik_window_statusbar_update ( (VikWindow*)VIK_GTK_WINDOW_FROM_LAYER(oti->vtl), msg, VIK_STATUSBAR_INFO ); g_free (msg); } /* Removing temporary file */ int ret = g_unlink(filename); if (ret != 0) { g_critical(_("failed to unlink temporary file: %s"), strerror(errno)); } }
/** * Uploading a VikTrwLayer * * @param vtl VikTrwLayer * @param track_name if not null, the name of the track to upload */ static void osm_traces_upload_viktrwlayer ( VikTrwLayer *vtl, const gchar *track_name ) { GtkWidget *dia = gtk_dialog_new_with_buttons (_("OSM upload"), VIK_GTK_WINDOW_FROM_LAYER(vtl), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, NULL); const gchar *default_user = get_default_user(); const gchar *pref_user = a_preferences_get(VIKING_OSM_TRACES_PARAMS_NAMESPACE "username")->s; const gchar *pref_password = a_preferences_get(VIKING_OSM_TRACES_PARAMS_NAMESPACE "password")->s; const gchar *name = NULL; GtkWidget *user_label, *user_entry; GtkWidget *password_label, *password_entry; GtkWidget *name_label, *name_entry; GtkWidget *description_label, *description_entry; GtkWidget *tags_label, *tags_entry; GtkComboBox *visibility; const OsmTraceVis_t *vis_t; user_label = gtk_label_new(_("Email:")); user_entry = gtk_entry_new(); if (user != NULL && user[0] != '\0') gtk_entry_set_text(GTK_ENTRY(user_entry), user); else if (pref_user != NULL && pref_user[0] != '\0') gtk_entry_set_text(GTK_ENTRY(user_entry), pref_user); else if (default_user != NULL) gtk_entry_set_text(GTK_ENTRY(user_entry), default_user); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dia)->vbox), user_label, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dia)->vbox), user_entry, FALSE, FALSE, 0); gtk_widget_set_tooltip_markup(GTK_WIDGET(user_entry), _("The email used as login\n" "<small>Enter the email you use to login into www.openstreetmap.org.</small>")); password_label = gtk_label_new(_("Password:"******"The password used to login\n" "<small>Enter the password you use to login into www.openstreetmap.org.</small>")); name_label = gtk_label_new(_("File's name:")); name_entry = gtk_entry_new(); if (track_name != NULL) name = track_name; else name = vik_layer_get_name(VIK_LAYER(vtl)); gtk_entry_set_text(GTK_ENTRY(name_entry), name); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dia)->vbox), name_label, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dia)->vbox), name_entry, FALSE, FALSE, 0); gtk_widget_set_tooltip_markup(GTK_WIDGET(name_entry), _("The name of the file on OSM\n" "<small>This is the name of the file created on the server." "This is not the name of the local file.</small>")); description_label = gtk_label_new(_("Description:")); description_entry = gtk_entry_new(); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dia)->vbox), description_label, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dia)->vbox), description_entry, FALSE, FALSE, 0); gtk_widget_set_tooltip_text(GTK_WIDGET(description_entry), _("The description of the trace")); tags_label = gtk_label_new(_("Tags:")); tags_entry = gtk_entry_new(); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dia)->vbox), tags_label, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dia)->vbox), tags_entry, FALSE, FALSE, 0); gtk_widget_set_tooltip_text(GTK_WIDGET(tags_entry), _("The tags associated to the trace")); visibility = GTK_COMBO_BOX(gtk_combo_box_new_text ()); for (vis_t = OsmTraceVis; vis_t->combostr != NULL; vis_t++) gtk_combo_box_append_text(visibility, vis_t->combostr); /* Set identifiable by default */ gtk_combo_box_set_active(visibility, 0); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dia)->vbox), GTK_WIDGET(visibility), FALSE, FALSE, 0); /* User should think about it first... */ gtk_dialog_set_default_response ( GTK_DIALOG(dia), GTK_RESPONSE_REJECT ); gtk_widget_show_all ( dia ); gtk_widget_grab_focus ( description_entry ); if ( gtk_dialog_run ( GTK_DIALOG(dia) ) == GTK_RESPONSE_ACCEPT ) { gchar *title = NULL; /* overwrite authentication info */ set_login(gtk_entry_get_text(GTK_ENTRY(user_entry)), gtk_entry_get_text(GTK_ENTRY(password_entry))); /* Storing data for the future thread */ OsmTracesInfo *info = g_malloc(sizeof(OsmTracesInfo)); info->name = g_strdup(gtk_entry_get_text(GTK_ENTRY(name_entry))); info->description = g_strdup(gtk_entry_get_text(GTK_ENTRY(description_entry))); /* TODO Normalize tags: they will be used as URL part */ info->tags = g_strdup(gtk_entry_get_text(GTK_ENTRY(tags_entry))); info->vistype = &OsmTraceVis[gtk_combo_box_get_active(visibility)]; info->vtl = VIK_TRW_LAYER(g_object_ref(vtl)); info->track_name = (track_name == NULL) ? NULL : g_strdup(track_name); title = g_strdup_printf(_("Uploading %s to OSM"), info->name); /* launch the thread */ a_background_thread(VIK_GTK_WINDOW_FROM_LAYER(vtl), /* parent window */ title, /* description string */ (vik_thr_func) osm_traces_upload_thread, /* function to call within thread */ info, /* pass along data */ (vik_thr_free_func) oti_free, /* function to free pass along data */ (vik_thr_free_func) NULL, 1 ); g_free ( title ); title = NULL; } gtk_widget_destroy ( dia ); }
static gboolean dem_layer_download_release ( VikDEMLayer *vdl, GdkEventButton *event, VikViewport *vvp ) { VikCoord coord; static struct LatLon ll; gchar *full_path; gchar *dem_file = NULL; vik_viewport_screen_to_coord ( vvp, event->x, event->y, &coord ); vik_coord_to_latlon ( &coord, &ll ); if ( vdl->source == DEM_SOURCE_SRTM ) dem_file = srtm_lat_lon_to_dest_fn ( ll.lat, ll.lon ); #ifdef VIK_CONFIG_DEM24K else if ( vdl->source == DEM_SOURCE_DEM24K ) dem_file = dem24k_lat_lon_to_dest_fn ( ll.lat, ll.lon ); #endif if ( ! dem_file ) return TRUE; full_path = g_strdup_printf("%s%s", MAPS_CACHE_DIR, dem_file ); g_debug("%s: %s", __FUNCTION__, full_path); if ( event->button == 1 ) { // TODO: check if already in filelist if ( ! dem_layer_add_file(vdl, full_path) ) { gchar *tmp = g_strdup_printf ( _("Downloading DEM %s"), dem_file ); DEMDownloadParams *p = g_malloc(sizeof(DEMDownloadParams)); p->dest = g_strdup(full_path); p->lat = ll.lat; p->lon = ll.lon; p->vdl = vdl; p->mutex = g_mutex_new(); p->source = vdl->source; g_object_weak_ref(G_OBJECT(p->vdl), weak_ref_cb, p ); a_background_thread ( VIK_GTK_WINDOW_FROM_LAYER(vdl), tmp, (vik_thr_func) dem_download_thread, p, (vik_thr_free_func) free_dem_download_params, NULL, 1 ); g_free ( tmp ); } else vik_layer_emit_update ( VIK_LAYER(vdl) ); } else { if ( !vdl->right_click_menu ) { GtkWidget *item; vdl->right_click_menu = GTK_MENU ( gtk_menu_new () ); item = gtk_image_menu_item_new_with_mnemonic ( _("_Show DEM File Information") ); gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_INFO, GTK_ICON_SIZE_MENU) ); g_signal_connect ( G_OBJECT(item), "activate", G_CALLBACK(dem_layer_file_info), &ll ); gtk_menu_shell_append (GTK_MENU_SHELL(vdl->right_click_menu), item); } gtk_menu_popup ( vdl->right_click_menu, NULL, NULL, NULL, NULL, event->button, event->time ); gtk_widget_show_all ( GTK_WIDGET(vdl->right_click_menu) ); } g_free ( dem_file ); g_free ( full_path ); return TRUE; }
static gboolean trw_layer_waypoint_menu_popup ( GtkWidget *tree_view, GdkEventButton *event, gpointer data ) { static GtkTreeIter iter; // Use selected item to get a single iterator ref // This relies on an row being selected as part of the right click GtkTreeSelection *selection = gtk_tree_view_get_selection ( GTK_TREE_VIEW(tree_view) ); if ( gtk_tree_selection_count_selected_rows (selection) != 1 ) return FALSE; GtkTreePath *path; GtkTreeModel *model = gtk_tree_view_get_model ( GTK_TREE_VIEW(tree_view) ); // All this just to get the iter if ( gtk_tree_view_get_path_at_pos ( GTK_TREE_VIEW(tree_view), (gint) event->x, (gint) event->y, &path, NULL, NULL, NULL)) { gtk_tree_model_get_iter_from_string ( model, &iter, gtk_tree_path_to_string (path) ); gtk_tree_path_free ( path ); } else return FALSE; VikWaypoint *wpt; gtk_tree_model_get ( model, &iter, WPT_COL_NUM, &wpt, -1 ); if ( !wpt ) return FALSE; VikTrwLayer *vtl; gtk_tree_model_get ( model, &iter, TRW_COL_NUM, &vtl, -1 ); if ( !IS_VIK_TRW_LAYER(vtl) ) return FALSE; wpu_udata udataU; udataU.wp = wpt; udataU.uuid = NULL; gpointer *wptf; wptf = g_hash_table_find ( vik_trw_layer_get_waypoints(vtl), (GHRFunc) trw_layer_waypoint_find_uuid, &udataU ); if ( wptf && udataU.uuid ) { VikViewport *vvp = vik_window_viewport((VikWindow *)(VIK_GTK_WINDOW_FROM_LAYER(vtl))); GtkWidget *menu = gtk_menu_new(); // Originally started to reuse the trw_layer menu items // however these offer too many ways to edit the waypoint data // so without an easy way to distinguish read only operations, // create a very minimal new set of operations add_menu_items ( GTK_MENU(menu), vtl, wpt, udataU.uuid, vvp, tree_view, data ); gtk_menu_popup ( GTK_MENU(menu), NULL, NULL, NULL, NULL, event->button, gtk_get_current_event_time() ); return TRUE; } return FALSE; }