/** * Some common things to do on completion of a datasource process * . Update layer * . Update dialog info * . Update main dsisplay */ static void on_complete_process (w_and_interface_t *wi) { if (wi->w->running) { gtk_label_set_text ( GTK_LABEL(wi->w->status), _("Done.") ); if ( wi->creating_new_layer ) { /* Only create the layer if it actually contains anything useful */ // TODO: create function for this operation to hide detail: if ( ! vik_trw_layer_is_empty ( wi->vtl ) ) { vik_layer_post_read ( VIK_LAYER(wi->vtl), wi->w->vvp, TRUE ); vik_aggregate_layer_add_layer( vik_layers_panel_get_top_layer(wi->w->vlp), VIK_LAYER(wi->vtl)); } else gtk_label_set_text ( GTK_LABEL(wi->w->status), _("No data.") ); } /* View this data if available and is desired */ if ( wi->vtl && wi->w->source_interface->autoview ) { vik_trw_layer_auto_set_view ( wi->vtl, vik_layers_panel_get_viewport(wi->w->vlp) ); } if ( wi->w->source_interface->keep_dialog_open ) { gtk_dialog_set_response_sensitive ( GTK_DIALOG(wi->w->dialog), GTK_RESPONSE_ACCEPT, TRUE ); gtk_dialog_set_response_sensitive ( GTK_DIALOG(wi->w->dialog), GTK_RESPONSE_REJECT, FALSE ); } else { gtk_dialog_response ( GTK_DIALOG(wi->w->dialog), GTK_RESPONSE_ACCEPT ); } // Main display update if ( wi->vtl ) vik_layers_panel_emit_update ( wi->w->vlp ); } else { /* cancelled */ if ( wi->creating_new_layer ) g_object_unref(wi->vtl); } }
/** * 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 gboolean datasource_osm_my_traces_process ( VikTrwLayer *vtl, const gchar *cmd, const gchar *extra, BabelStatusFunc status_cb, acq_dialog_widgets_t *adw, DownloadMapOptions *options_unused ) { //datasource_osm_my_traces_t *data = (datasource_osm_my_traces_t *)adw->user_data; gboolean result; gchar *user_pass = osm_get_login(); DownloadMapOptions options = { FALSE, FALSE, NULL, 2, NULL, user_pass }; // Allow a couple of redirects xml_data *xd = g_malloc ( sizeof (xml_data) ); //xd->xpath = g_string_new ( "" ); xd->c_cdata = g_string_new ( "" ); xd->current_tag = tt_unknown; xd->current_gpx_meta_data = new_gpx_meta_data_t(); xd->list_of_gpx_meta_data = NULL; gchar *tmpname = a_download_uri_to_tmp_file ( DS_OSM_TRACES_GPX_FILES, &options ); result = read_gpx_files_metadata_xml ( tmpname, xd ); // Test already downloaded metadata file: eg: //result = read_gpx_files_metadata_xml ( "/tmp/viking-download.GI47PW", xd ); if ( tmpname ) { g_remove ( tmpname ); g_free ( tmpname ); } if ( ! result ) return FALSE; if ( g_list_length ( xd->list_of_gpx_meta_data ) == 0 ) { if (!vik_datasource_osm_my_traces_interface.is_thread) none_found ( GTK_WINDOW(adw->vw) ); return FALSE; } xd->list_of_gpx_meta_data = g_list_reverse ( xd->list_of_gpx_meta_data ); set_in_current_view_property ( vtl, adw->user_data, xd->list_of_gpx_meta_data ); if (vik_datasource_osm_my_traces_interface.is_thread) gdk_threads_enter(); GList *selected = select_from_list ( GTK_WINDOW(adw->vw), xd->list_of_gpx_meta_data, "Select GPS Traces", "Select the GPS traces you want to add." ); if (vik_datasource_osm_my_traces_interface.is_thread) gdk_threads_leave(); // If passed in on an existing layer - we will create everything into that. // thus with many differing gpx's - this will combine all waypoints into this single layer! // Hence the preference is to create multiple layers // and so this creation of the layers must be managed here gboolean create_new_layer = ( !vtl ); // Only update the screen on the last layer acquired VikTrwLayer *vtl_last = vtl; gboolean got_something = FALSE; GList *selected_iterator = selected; while ( selected_iterator ) { VikTrwLayer *vtlX = vtl; if ( create_new_layer ) { // Have data but no layer - so create one vtlX = VIK_TRW_LAYER ( vik_layer_create ( VIK_LAYER_TRW, vik_window_viewport(adw->vw), NULL, FALSE ) ); if ( ((gpx_meta_data_t*)selected_iterator->data)->name ) vik_layer_rename ( VIK_LAYER ( vtlX ), ((gpx_meta_data_t*)selected_iterator->data)->name ); else vik_layer_rename ( VIK_LAYER ( vtlX ), _("My OSM Traces") ); vik_aggregate_layer_add_layer ( vik_layers_panel_get_top_layer (adw->vlp), VIK_LAYER(vtlX) ); } result = FALSE; gint gpx_id = ((gpx_meta_data_t*)selected_iterator->data)->id; if ( gpx_id ) { gchar *url = g_strdup_printf ( DS_OSM_TRACES_GPX_URL_FMT, gpx_id ); result = a_babel_convert_from_url ( vtlX, url, "gpx", status_cb, adw, &options ); // TODO investigate using a progress bar: // http://developer.gnome.org/gtk/2.24/GtkProgressBar.html got_something = got_something || result; // TODO feedback to UI to inform which traces failed if ( !result ) g_warning ( _("Unable to get trace: %s"), url ); } if ( result ) { // Move to area of the track vik_trw_layer_auto_set_view ( vtlX, vik_window_viewport(adw->vw) ); vik_layer_post_read ( VIK_LAYER(vtlX), vik_window_viewport(adw->vw), TRUE ); vtl_last = vtlX; } else if ( create_new_layer ) { // Layer not needed as no data has been acquired g_object_unref ( vtlX ); } selected_iterator = g_list_next ( selected_iterator ); } // Free memory if ( xd->current_gpx_meta_data ) free_gpx_meta_data ( xd->current_gpx_meta_data, NULL ); g_free ( xd->current_gpx_meta_data ); free_gpx_meta_data_list ( xd->list_of_gpx_meta_data ); free_gpx_meta_data_list ( selected ); g_free ( xd ); g_free ( user_pass ); // Would prefer to keep the update in acquire.c, // however since we may create the layer - need to do the update here if ( got_something ) vik_layer_emit_update ( VIK_LAYER(vtl_last) ); // ATM The user is only informed if all getting *all* of the traces failed if ( selected ) result = got_something; else // Process was cancelled but need to return that it proceeded as expected result = TRUE; return result; }
VikLoadType_t a_file_load ( VikAggregateLayer *top, VikViewport *vp, const gchar *filename_or_uri ) { g_return_val_if_fail ( vp != NULL, LOAD_TYPE_READ_FAILURE ); char *filename = (char *)filename_or_uri; if (strncmp(filename, "file://", 7) == 0) { // Consider replacing this with: // filename = g_filename_from_uri ( entry, NULL, NULL ); // Since this doesn't support URIs properly (i.e. will failure if is it has %20 characters in it) filename = filename + 7; g_debug ( "Loading file %s from URI %s", filename, filename_or_uri ); } FILE *f = xfopen ( filename ); if ( ! f ) return LOAD_TYPE_READ_FAILURE; VikLoadType_t load_answer = LOAD_TYPE_OTHER_SUCCESS; gchar *dirpath = g_path_get_dirname ( filename ); // Attempt loading the primary file type first - our internal .vik file: if ( check_magic ( f, VIK_MAGIC ) ) { if ( file_read ( top, f, dirpath, vp ) ) load_answer = LOAD_TYPE_VIK_SUCCESS; else load_answer = LOAD_TYPE_VIK_FAILURE_NON_FATAL; } else if ( a_jpg_magic_check ( filename ) ) { if ( ! a_jpg_load_file ( top, filename, vp ) ) load_answer = LOAD_TYPE_UNSUPPORTED_FAILURE; } else { // For all other file types which consist of tracks, routes and/or waypoints, // must be loaded into a new TrackWaypoint layer (hence it be created) gboolean success = TRUE; // Detect load failures - mainly to remove the layer created as it's not required VikLayer *vtl = vik_layer_create ( VIK_LAYER_TRW, vp, FALSE ); vik_layer_rename ( vtl, a_file_basename ( filename ) ); // In fact both kml & gpx files start the same as they are in xml if ( a_file_check_ext ( filename, ".kml" ) && check_magic ( f, GPX_MAGIC ) ) { // Implicit Conversion if ( ! ( success = a_babel_convert_from ( VIK_TRW_LAYER(vtl), "-i kml", filename, NULL, NULL, NULL ) ) ) { load_answer = LOAD_TYPE_GPSBABEL_FAILURE; } } // NB use a extension check first, as a GPX file header may have a Byte Order Mark (BOM) in it // - which currently confuses our check_magic function else if ( a_file_check_ext ( filename, ".gpx" ) || check_magic ( f, GPX_MAGIC ) ) { if ( ! ( success = a_gpx_read_file ( VIK_TRW_LAYER(vtl), f ) ) ) { load_answer = LOAD_TYPE_GPX_FAILURE; } } else { // Try final supported file type if ( ! ( success = a_gpspoint_read_file ( VIK_TRW_LAYER(vtl), f, dirpath ) ) ) { // Failure here means we don't know how to handle the file load_answer = LOAD_TYPE_UNSUPPORTED_FAILURE; } } g_free ( dirpath ); // Clean up when we can't handle the file if ( ! success ) { // free up layer g_object_unref ( vtl ); } else { // Complete the setup from the successful load vik_layer_post_read ( vtl, vp, TRUE ); vik_aggregate_layer_add_layer ( top, vtl, FALSE ); vik_trw_layer_auto_set_view ( VIK_TRW_LAYER(vtl), vp ); } } xfclose(f); return load_answer; }
/* this routine is the worker thread. there is only one simultaneous download allowed */ static void get_from_anything ( w_and_interface_t *wi ) { gchar *cmd = wi->cmd; gchar *extra = wi->extra; gboolean result = TRUE; VikTrwLayer *vtl = NULL; gboolean creating_new_layer = TRUE; acq_dialog_widgets_t *w = wi->w; VikDataSourceInterface *source_interface = wi->w->source_interface; g_free ( wi ); wi = NULL; gdk_threads_enter(); if (source_interface->mode == VIK_DATASOURCE_ADDTOLAYER) { VikLayer *current_selected = vik_layers_panel_get_selected ( w->vlp ); if ( IS_VIK_TRW_LAYER(current_selected) ) { vtl = VIK_TRW_LAYER(current_selected); creating_new_layer = FALSE; } } if ( creating_new_layer ) { vtl = VIK_TRW_LAYER ( vik_layer_create ( VIK_LAYER_TRW, w->vvp, NULL, FALSE ) ); vik_layer_rename ( VIK_LAYER ( vtl ), _(source_interface->layer_title) ); gtk_label_set_text ( GTK_LABEL(w->status), _("Working...") ); } gdk_threads_leave(); switch ( source_interface->type ) { case VIK_DATASOURCE_GPSBABEL_DIRECT: result = a_babel_convert_from (vtl, cmd, (BabelStatusFunc) progress_func, extra, w); break; case VIK_DATASOURCE_URL: result = a_babel_convert_from_url (vtl, cmd, extra, (BabelStatusFunc) progress_func, w); break; case VIK_DATASOURCE_SHELL_CMD: result = a_babel_convert_from_shellcommand ( vtl, cmd, extra, (BabelStatusFunc) progress_func, w); break; default: g_critical("Houston, we've had a problem."); } g_free ( cmd ); g_free ( extra ); if (!result) { gdk_threads_enter(); gtk_label_set_text ( GTK_LABEL(w->status), _("Error: acquisition failed.") ); if ( creating_new_layer ) g_object_unref ( G_OBJECT ( vtl ) ); gdk_threads_leave(); } else { gdk_threads_enter(); if (w->ok) { gtk_label_set_text ( GTK_LABEL(w->status), _("Done.") ); if ( creating_new_layer ) { /* Only create the layer if it actually contains anything useful */ if ( g_hash_table_size (vik_trw_layer_get_tracks(vtl)) || g_hash_table_size (vik_trw_layer_get_waypoints(vtl)) ) vik_aggregate_layer_add_layer( vik_layers_panel_get_top_layer(w->vlp), VIK_LAYER(vtl)); else gtk_label_set_text ( GTK_LABEL(w->status), _("No data.") ); } /* View this data if available and is desired */ if ( vtl && source_interface->autoview ) { vik_trw_layer_auto_set_view ( vtl, vik_layers_panel_get_viewport(w->vlp) ); vik_layers_panel_emit_update (w->vlp); } if ( source_interface->keep_dialog_open ) { gtk_dialog_set_response_sensitive ( GTK_DIALOG(w->dialog), GTK_RESPONSE_ACCEPT, TRUE ); gtk_dialog_set_response_sensitive ( GTK_DIALOG(w->dialog), GTK_RESPONSE_REJECT, FALSE ); } else { gtk_dialog_response ( GTK_DIALOG(w->dialog), GTK_RESPONSE_ACCEPT ); } } else { /* canceled */ if ( creating_new_layer ) g_object_unref(vtl); } } if ( source_interface->cleanup_func ) source_interface->cleanup_func ( w->user_data ); if ( w->ok ) { w->ok = FALSE; } else { g_free ( w ); } gdk_threads_leave(); g_thread_exit ( NULL ); }