/**
* 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_waypoint_view ( menu_array_values values )
{
VikTrwLayer *vtl = VIK_TRW_LAYER(values[MA_VTL]);
VikWaypoint *wpt = VIK_WAYPOINT(values[MA_WPT]);
VikViewport *vvp = VIK_VIEWPORT(values[MA_VVP]);
vik_viewport_set_center_coord ( vvp, &(wpt->coord), TRUE );
trw_layer_waypoint_select (values);
vik_layer_emit_update ( VIK_LAYER(vtl) );
}
// Instead of hooking automatically on treeview item selection
// This is performed on demand via the specific menu request
static void trw_layer_waypoint_select ( menu_array_values values )
{
VikTrwLayer *vtl = VIK_TRW_LAYER(values[MA_VTL]);
if ( values[MA_WPT_UUID] ) {
GtkTreeIter *iter = NULL;
iter = g_hash_table_lookup ( vik_trw_layer_get_waypoints_iters(vtl), values[MA_WPT_UUID] );
if ( iter )
vik_treeview_select_iter ( VIK_LAYER(vtl)->vt, iter, TRUE );
}
}
int main(int argc, char *argv[])
{
#if !GLIB_CHECK_VERSION (2, 36, 0)
g_type_init();
#endif
VikLayer *vl = vik_layer_create (VIK_LAYER_TRW, NULL, FALSE);
VikTrwLayer *trw = VIK_TRW_LAYER (vl);
a_gpx_read_file(trw, stdin);
a_gpx_write_file(trw, stdout, NULL);
// NB no layer_free functions directly visible anymore
// automatically called by layers_panel_finalize cleanup in full Viking program
return 0;
}
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 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 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 );
}
/**
* aggregate_layer_track_create_list:
* @vl: The layer that should create the track and layers list
* @user_data: Not used in this function
*
* Returns: A list of #vik_trw_track_list_t
*/
static GList* aggregate_layer_track_create_list ( VikLayer *vl, gpointer user_data )
{
VikAggregateLayer *val = VIK_AGGREGATE_LAYER(vl);
// Get all TRW layers
GList *layers = NULL;
layers = vik_aggregate_layer_get_all_layers_of_type ( val, layers, VIK_LAYER_TRW, TRUE );
// For each TRW layers keep adding the tracks and routes to build a list of all of them
GList *tracks_and_layers = NULL;
layers = g_list_first ( layers );
while ( layers ) {
GList *tracks = NULL;
tracks = g_list_concat ( tracks, g_hash_table_get_values ( vik_trw_layer_get_tracks( VIK_TRW_LAYER(layers->data) ) ) );
tracks = g_list_concat ( tracks, g_hash_table_get_values ( vik_trw_layer_get_routes( VIK_TRW_LAYER(layers->data) ) ) );
tracks_and_layers = g_list_concat ( tracks_and_layers, vik_trw_layer_build_track_list_t ( VIK_TRW_LAYER(layers->data), tracks ) );
layers = g_list_next ( layers );
}
g_list_free ( layers );
return tracks_and_layers;
}
/**
* Function called by the entry menu of a TrwLayer
*/
void osm_traces_upload_cb ( gpointer layer_and_vlp[2], guint file_type )
{
osm_traces_upload_viktrwlayer(VIK_TRW_LAYER(layer_and_vlp[0]), NULL);
}
/* 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 );
}
/* depending on type of filter, often only vtl or track will be given.
* the other can be NULL.
*/
static void acquire ( VikWindow *vw, VikLayersPanel *vlp, VikViewport *vvp, VikDataSourceInterface *source_interface,
VikTrwLayer *vtl, VikTrack *track )
{
/* for manual dialogs */
GtkWidget *dialog = NULL;
GtkWidget *status;
gchar *cmd = NULL;
gchar *extra = NULL;
gchar *cmd_off = NULL;
gchar *extra_off = NULL;
acq_dialog_widgets_t *w;
gpointer user_data;
gpointer options = NULL;
/* for UI builder */
gpointer pass_along_data;
VikLayerParamData *paramdatas = NULL;
w_and_interface_t *wi;
/*** INIT AND CHECK EXISTENCE ***/
if ( source_interface->init_func )
user_data = source_interface->init_func();
else
user_data = NULL;
pass_along_data = user_data;
if ( source_interface->check_existence_func ) {
gchar *error_str = source_interface->check_existence_func();
if ( error_str ) {
a_dialog_error_msg ( GTK_WINDOW(vw), error_str );
g_free ( error_str );
return;
}
}
/* BUILD UI & GET OPTIONS IF NECESSARY. */
/* POSSIBILITY 0: NO OPTIONS. DO NOTHING HERE. */
/* POSSIBILITY 1: ADD_SETUP_WIDGETS_FUNC */
if ( source_interface->add_setup_widgets_func ) {
dialog = gtk_dialog_new_with_buttons ( "", GTK_WINDOW(vw), 0, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, NULL );
gtk_dialog_set_default_response ( GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT );
GtkWidget *response_w = NULL;
#if GTK_CHECK_VERSION (2, 20, 0)
response_w = gtk_dialog_get_widget_for_response ( GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT );
#endif
source_interface->add_setup_widgets_func(dialog, vvp, user_data);
gtk_window_set_title ( GTK_WINDOW(dialog), _(source_interface->window_title) );
if ( response_w )
gtk_widget_grab_focus ( response_w );
if ( gtk_dialog_run ( GTK_DIALOG(dialog) ) != GTK_RESPONSE_ACCEPT ) {
source_interface->cleanup_func(user_data);
gtk_widget_destroy(dialog);
return;
}
}
/* POSSIBILITY 2: UI BUILDER */
else if ( source_interface->params ) {
paramdatas = a_uibuilder_run_dialog ( source_interface->window_title, GTK_WINDOW(vw),
source_interface->params, source_interface->params_count,
source_interface->params_groups, source_interface->params_groups_count,
source_interface->params_defaults );
if ( paramdatas )
pass_along_data = paramdatas;
else
return; /* TODO: do we have to free anything here? */
}
/* CREATE INPUT DATA & GET COMMAND STRING */
if ( source_interface->inputtype == VIK_DATASOURCE_INPUTTYPE_TRWLAYER ) {
gchar *name_src = write_tmp_trwlayer ( vtl );
((VikDataSourceGetCmdStringFuncWithInput) source_interface->get_cmd_string_func)
( pass_along_data, &cmd, &extra, name_src );
g_free ( name_src );
/* TODO: delete the tmp file? or delete it only after we're done with it? */
} else if ( source_interface->inputtype == VIK_DATASOURCE_INPUTTYPE_TRWLAYER_TRACK ) {
gchar *name_src = write_tmp_trwlayer ( vtl );
gchar *name_src_track = write_tmp_track ( track );
((VikDataSourceGetCmdStringFuncWithInputInput) source_interface->get_cmd_string_func)
( pass_along_data, &cmd, &extra, name_src, name_src_track );
g_free ( name_src );
g_free ( name_src_track );
} else if ( source_interface->inputtype == VIK_DATASOURCE_INPUTTYPE_TRACK ) {
gchar *name_src_track = write_tmp_track ( track );
((VikDataSourceGetCmdStringFuncWithInput) source_interface->get_cmd_string_func)
( pass_along_data, &cmd, &extra, name_src_track );
g_free ( name_src_track );
} else if ( source_interface->get_cmd_string_func )
source_interface->get_cmd_string_func ( pass_along_data, &cmd, &extra, &options );
/* Get data for Off command */
if ( source_interface->off_func ) {
source_interface->off_func ( pass_along_data, &cmd_off, &extra_off );
}
/* cleanup for option dialogs */
if ( source_interface->add_setup_widgets_func ) {
gtk_widget_destroy(dialog);
dialog = NULL;
} else if ( source_interface->params ) {
a_uibuilder_free_paramdatas ( paramdatas, source_interface->params, source_interface->params_count );
}
w = g_malloc(sizeof(*w));
wi = g_malloc(sizeof(*wi));
wi->w = w;
wi->w->source_interface = source_interface;
wi->cmd = cmd;
wi->extra = extra; /* usually input data type (?) */
wi->options = options;
wi->vtl = vtl;
wi->creating_new_layer = (!vtl);
dialog = gtk_dialog_new_with_buttons ( "", GTK_WINDOW(vw), 0, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, NULL );
gtk_dialog_set_response_sensitive ( GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT, FALSE );
gtk_window_set_title ( GTK_WINDOW(dialog), _(source_interface->window_title) );
w->dialog = dialog;
w->running = TRUE;
status = gtk_label_new (_("Working..."));
gtk_box_pack_start ( GTK_BOX(GTK_DIALOG(dialog)->vbox), status, FALSE, FALSE, 5 );
gtk_dialog_set_default_response ( GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT );
// May not want to see the dialog at all
if ( source_interface->is_thread || source_interface->keep_dialog_open )
gtk_widget_show_all(dialog);
w->status = status;
w->vw = vw;
w->vlp = vlp;
w->vvp = vvp;
if ( source_interface->add_progress_widgets_func ) {
source_interface->add_progress_widgets_func ( dialog, user_data );
}
w->user_data = user_data;
if (source_interface->mode == VIK_DATASOURCE_ADDTOLAYER) {
VikLayer *current_selected = vik_layers_panel_get_selected ( w->vlp );
if ( IS_VIK_TRW_LAYER(current_selected) ) {
wi->vtl = VIK_TRW_LAYER(current_selected);
wi->creating_new_layer = FALSE;
}
}
else if ( source_interface->mode == VIK_DATASOURCE_MANUAL_LAYER_MANAGEMENT ) {
// Don't create in acquire - as datasource will perform the necessary actions
wi->creating_new_layer = FALSE;
VikLayer *current_selected = vik_layers_panel_get_selected ( w->vlp );
if ( IS_VIK_TRW_LAYER(current_selected) )
wi->vtl = VIK_TRW_LAYER(current_selected);
}
if ( wi->creating_new_layer ) {
wi->vtl = VIK_TRW_LAYER ( vik_layer_create ( VIK_LAYER_TRW, w->vvp, NULL, FALSE ) );
vik_layer_rename ( VIK_LAYER ( wi->vtl ), _(source_interface->layer_title) );
}
if ( source_interface->is_thread ) {
if ( cmd ) {
g_thread_create((GThreadFunc)get_from_anything, wi, FALSE, NULL );
gtk_dialog_run ( GTK_DIALOG(dialog) );
if (w->running) {
// Cancel and mark for thread to finish
w->running = FALSE;
// NB Thread will free memory
} else {
if ( cmd_off ) {
/* Turn off */
a_babel_convert_from (NULL, cmd_off, extra_off, NULL, NULL, NULL);
g_free ( cmd_off );
}
if ( extra_off )
g_free ( extra_off );
// Thread finished by normal completion - free memory
g_free ( w );
g_free ( wi );
}
}
else {
// This shouldn't happen...
gtk_label_set_text ( GTK_LABEL(w->status), _("Unable to create command\nAcquire method failed.") );
gtk_dialog_run (GTK_DIALOG (dialog));
}
}
else {
// bypass thread method malarkly - you'll just have to wait...
if ( source_interface->process_func ) {
gboolean result = source_interface->process_func ( wi->vtl, cmd, extra, (BabelStatusFunc) progress_func, w, options );
if ( !result )
a_dialog_msg ( GTK_WINDOW(vw), GTK_MESSAGE_ERROR, _("Error: acquisition failed."), NULL );
}
g_free ( cmd );
g_free ( extra );
g_free ( options );
on_complete_process ( wi );
// Actually show it if necessary
if ( wi->w->source_interface->keep_dialog_open )
gtk_dialog_run ( GTK_DIALOG(dialog) );
g_free ( w );
g_free ( wi );
}
gtk_widget_destroy ( dialog );
}
/**
* Function called by the entry menu of a single track
*/
void osm_traces_upload_track_cb ( gpointer pass_along[6] )
{
osm_traces_upload_viktrwlayer(VIK_TRW_LAYER(pass_along[0]), pass_along[3]);
}
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;
}
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;
}
/**
* 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 );
}