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 );
}
/**
* Process selected files and try to generate waypoints storing them in the given vtl
*/
static gboolean datasource_geotag_process ( VikTrwLayer *vtl, ProcessOptions *po, BabelStatusFunc status_cb, acq_dialog_widgets_t *adw, gpointer not_used )
{
datasource_geotag_user_data_t *user_data = (datasource_geotag_user_data_t *)adw->user_data;
// Process selected files
// In prinicple this loading should be quite fast and so don't need to have any progress monitoring
GSList *cur_file = user_data->filelist;
while ( cur_file ) {
gchar *filename = cur_file->data;
gchar *name;
VikWaypoint *wp = a_geotag_create_waypoint_from_file ( filename, vik_viewport_get_coord_mode ( adw->vvp ), &name );
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 ( vtl, name, wp );
g_free ( name );
}
else {
gchar* msg = g_strdup_printf ( _("Unable to create waypoint from %s"), filename );
vik_window_statusbar_update ( adw->vw, msg, VIK_STATUSBAR_INFO );
g_free (msg);
}
g_free ( filename );
cur_file = g_slist_next ( cur_file );
}
/* Free memory */
g_slist_free ( user_data->filelist );
// No failure
return TRUE;
}
/**
* Process selected files and try to generate waypoints storing them in the given vtl
*/
static gboolean datasource_geojson_process ( VikTrwLayer *vtl, const gchar *cmd, const gchar *extra, BabelStatusFunc status_cb, acq_dialog_widgets_t *adw, gpointer not_used )
{
datasource_geojson_user_data_t *user_data = (datasource_geojson_user_data_t *)adw->user_data;
// Process selected files
GSList *cur_file = user_data->filelist;
while ( cur_file ) {
gchar *filename = cur_file->data;
gchar *gpx_filename = a_geojson_import_to_gpx ( filename );
if ( gpx_filename ) {
// Important that this process is run in the main thread
vik_window_open_file ( adw->vw, gpx_filename, FALSE );
// Delete the temporary file
g_remove (gpx_filename);
g_free (gpx_filename);
}
else {
gchar* msg = g_strdup_printf ( _("Unable to import from: %s"), filename );
vik_window_statusbar_update ( adw->vw, msg, VIK_STATUSBAR_INFO );
g_free (msg);
}
g_free ( filename );
cur_file = g_slist_next ( cur_file );
}
// Free memory
g_slist_free ( user_data->filelist );
// No failure
return TRUE;
}
static gboolean datasource_osm_my_traces_process ( VikTrwLayer *vtl, ProcessOptions *process_options, 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();
// Support .zip + bzip2 files directly
DownloadMapOptions options = { FALSE, FALSE, NULL, 2, NULL, user_pass, a_try_decompress_file }; // Allow a couple of redirects
gchar *tmpname = a_download_uri_to_tmp_file ( DS_OSM_TRACES_GPX_FILES, &options );
if ( !tmpname )
return FALSE;
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;
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 ) {
(void)util_remove ( tmpname );
g_free ( tmpname );
}
if ( ! result ) {
g_free ( xd );
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) );
g_free ( xd );
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 non thread - show program is 'doing something...'
if ( !vik_datasource_osm_my_traces_interface.is_thread )
vik_window_set_busy_cursor ( adw->vw );
// 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, adw->vvp, 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") );
}
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 );
// NB download type is GPX (or a compressed version)
ProcessOptions my_po = *process_options;
my_po.url = url;
result = a_babel_convert_from ( vtlX, &my_po, status_cb, adw, &options );
// TODO investigate using a progress bar:
// http://developer.gnome.org/gtk/2.24/GtkProgressBar.html
got_something = got_something || result;
if ( !result ) {
// Report errors to the status bar
gchar* msg = g_strdup_printf ( _("Unable to get trace: %s"), url );
vik_window_statusbar_update ( adw->vw, msg, VIK_STATUSBAR_INFO );
g_free (msg);
}
g_free ( url );
}
if ( result ) {
// Can use the layer
vik_aggregate_layer_add_layer ( vik_layers_panel_get_top_layer (adw->vlp), VIK_LAYER(vtlX), TRUE );
// Move to area of the track
vik_layer_post_read ( VIK_LAYER(vtlX), vik_window_viewport(adw->vw), TRUE );
vik_trw_layer_auto_set_view ( vtlX, vik_window_viewport(adw->vw) );
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;
if ( !vik_datasource_osm_my_traces_interface.is_thread )
vik_window_clear_busy_cursor ( adw->vw );
return result;
}
void a_background_update_status ( VikWindow *vw, gpointer data )
{
static gchar buf[20];
g_snprintf(buf, sizeof(buf), _("%d items"), bgitemcount);
vik_window_statusbar_update ( vw, buf, VIK_STATUSBAR_ITEMS );
}
/**
* 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));
}
}
