/**
* a_babel_ui_file_type_selector_new:
* @mode: the mode to filter the file types
*
* Create a file type selector.
*
* This widget relies on a combo box listing labels of file formats.
* We store in the "data" of the GtkWidget a list with the BabelFile
* entries, in order to retrieve the selected file format.
*
* Returns: a GtkWidget
*/
GtkWidget *a_babel_ui_file_type_selector_new ( BabelMode mode )
{
GList *formats = NULL;
/* Create the combo */
GtkWidget * combo = vik_combo_box_text_new ();
/* Add a first label to invite user to select a file format */
/* We store a NULL pointer to distinguish this entry */
formats = g_list_append ( formats, NULL );
vik_combo_box_text_append ( combo, _("Select a file format") );
/* Prepare space for file format list */
g_object_set_data ( G_OBJECT(combo), "formats", formats );
/* Add all known and compatible file formats */
if ( mode.tracksRead && mode.routesRead && mode.waypointsRead &&
!mode.tracksWrite && !mode.routesWrite && !mode.waypointsWrite )
a_babel_foreach_file_read_any ( babel_ui_selector_add_entry_cb, combo );
else
a_babel_foreach_file_with_mode ( mode, babel_ui_selector_add_entry_cb, combo );
/* Initialize the selection with the really first entry */
gtk_combo_box_set_active ( GTK_COMBO_BOX(combo), 0 );
return combo;
}
gboolean a_dialog_map_n_zoom(GtkWindow *parent, gchar *mapnames[], gint default_map, gchar *zoom_list[], gint default_zoom, gint *selected_map, gint *selected_zoom)
{
gchar **s;
GtkWidget *dialog = gtk_dialog_new_with_buttons ( _("Download along track"), parent, 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
GtkWidget *map_label = gtk_label_new(_("Map type:"));
GtkWidget *map_combo = vik_combo_box_text_new();
for (s = mapnames; *s; s++)
vik_combo_box_text_append (GTK_COMBO_BOX(map_combo), *s);
gtk_combo_box_set_active (GTK_COMBO_BOX(map_combo), default_map);
GtkWidget *zoom_label = gtk_label_new(_("Zoom level:"));
GtkWidget *zoom_combo = vik_combo_box_text_new();
for (s = zoom_list; *s; s++)
vik_combo_box_text_append (GTK_COMBO_BOX(zoom_combo), *s);
gtk_combo_box_set_active (GTK_COMBO_BOX(zoom_combo), default_zoom);
GtkTable *box = GTK_TABLE(gtk_table_new(2, 2, FALSE));
gtk_table_attach_defaults(box, map_label, 0, 1, 0, 1);
gtk_table_attach_defaults(box, map_combo, 1, 2, 0, 1);
gtk_table_attach_defaults(box, zoom_label, 0, 1, 1, 2);
gtk_table_attach_defaults(box, zoom_combo, 1, 2, 1, 2);
gtk_box_pack_start ( GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), GTK_WIDGET(box), FALSE, FALSE, 5 );
if ( response_w )
gtk_widget_grab_focus ( response_w );
gtk_widget_show_all ( dialog );
if ( gtk_dialog_run ( GTK_DIALOG(dialog) ) != GTK_RESPONSE_ACCEPT ) {
gtk_widget_destroy(dialog);
return FALSE;
}
*selected_map = gtk_combo_box_get_active(GTK_COMBO_BOX(map_combo));
*selected_zoom = gtk_combo_box_get_active(GTK_COMBO_BOX(zoom_combo));
gtk_widget_destroy(dialog);
return TRUE;
}
static void datasource_url_add_setup_widgets ( GtkWidget *dialog, VikViewport *vvp, gpointer user_data )
{
datasource_url_widgets_t *widgets = (datasource_url_widgets_t *)user_data;
GtkWidget *label = gtk_label_new (_("URL:"));
widgets->url = ui_entry_new ( NULL, GTK_ENTRY_ICON_SECONDARY );
// 'ok' when press return in the entry
g_signal_connect_swapped ( widgets->url, "activate", G_CALLBACK(a_dialog_response_accept), dialog );
GtkWidget *type_label = gtk_label_new (_("File type:"));
if ( last_type < 0 ) {
find_entry = -1;
wanted_entry = -1;
gchar *type = NULL;
if ( a_settings_get_string ( VIK_SETTINGS_URL_FILE_DL_TYPE, &type ) ) {
// Use setting
if ( type )
g_list_foreach (a_babel_file_list, find_type, type);
}
else {
// Default to GPX if possible
g_list_foreach (a_babel_file_list, find_type, "gpx");
}
g_free ( type );
// If not found set it to the first entry, otherwise use the entry
last_type = ( wanted_entry < 0 ) ? 0 : wanted_entry;
}
if ( a_babel_available() ) {
widgets->type = vik_combo_box_text_new ();
g_list_foreach (a_babel_file_list, fill_combo_box, widgets->type);
gtk_combo_box_set_active (GTK_COMBO_BOX (widgets->type), last_type);
}
else {
// Only GPX (not using GPSbabel)
widgets->type = gtk_label_new (_("GPX"));
}
/* Packing all widgets */
GtkBox *box = GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog)));
gtk_box_pack_start ( box, label, FALSE, FALSE, 5 );
gtk_box_pack_start ( box, widgets->url, FALSE, FALSE, 5 );
gtk_box_pack_start ( box, type_label, FALSE, FALSE, 5 );
gtk_box_pack_start ( box, widgets->type, FALSE, FALSE, 5 );
gtk_widget_show_all(dialog);
}
GtkWidget *a_uibuilder_new_widget ( VikLayerParam *param, VikLayerParamData data )
{
// Perform pre conversion if necessary
VikLayerParamData vlpd = data;
if ( param->convert_to_display )
vlpd = param->convert_to_display ( data );
GtkWidget *rv = NULL;
switch ( param->widget_type )
{
case VIK_LAYER_WIDGET_COLOR:
if ( param->type == VIK_LAYER_PARAM_COLOR )
rv = gtk_color_button_new_with_color ( &(vlpd.c) );
break;
case VIK_LAYER_WIDGET_CHECKBUTTON:
if ( param->type == VIK_LAYER_PARAM_BOOLEAN )
{
//rv = gtk_check_button_new_with_label ( //param->title );
rv = gtk_check_button_new ();
if ( vlpd.b )
gtk_toggle_button_set_active ( GTK_TOGGLE_BUTTON(rv), TRUE );
}
break;
case VIK_LAYER_WIDGET_COMBOBOX:
if ( param->type == VIK_LAYER_PARAM_UINT && param->widget_data )
{
/* Build a simple combobox */
gchar **pstr = param->widget_data;
rv = vik_combo_box_text_new ();
while ( *pstr )
vik_combo_box_text_append ( rv, *(pstr++) );
if ( param->extra_widget_data ) /* map of alternate uint values for options */
{
/* Set the effective default value */
int i;
for ( i = 0; ((const char **)param->widget_data)[i]; i++ )
if ( ((guint *)param->extra_widget_data)[i] == vlpd.u )
{
/* Match default value */
gtk_combo_box_set_active ( GTK_COMBO_BOX(rv), i );
break;
}
}
else
gtk_combo_box_set_active ( GTK_COMBO_BOX ( rv ), vlpd.u );
}
else if ( param->type == VIK_LAYER_PARAM_STRING && param->widget_data && !param->extra_widget_data )
{
/* Build a combobox with editable text */
gchar **pstr = param->widget_data;
#if GTK_CHECK_VERSION (2, 24, 0)
rv = gtk_combo_box_text_new_with_entry ();
#else
rv = gtk_combo_box_entry_new_text ();
#endif
if ( vlpd.s )
vik_combo_box_text_append ( rv, vlpd.s );
while ( *pstr )
vik_combo_box_text_append ( rv, *(pstr++) );
if ( vlpd.s )
gtk_combo_box_set_active ( GTK_COMBO_BOX ( rv ), 0 );
}
else if ( param->type == VIK_LAYER_PARAM_STRING && param->widget_data && param->extra_widget_data)
{
/* Build a combobox with fixed selections without editable text */
gchar **pstr = param->widget_data;
rv = GTK_WIDGET ( vik_combo_box_text_new () );
while ( *pstr )
vik_combo_box_text_append ( rv, *(pstr++) );
if ( vlpd.s )
{
/* Set the effective default value */
/* In case of value does not exist, set the first value */
gtk_combo_box_set_active ( GTK_COMBO_BOX ( rv ), 0 );
int i;
for ( i = 0; ((const char **)param->widget_data)[i]; i++ )
if ( strcmp(((const char **)param->extra_widget_data)[i], vlpd.s) == 0 )
{
/* Match default value */
gtk_combo_box_set_active ( GTK_COMBO_BOX ( rv ), i );
break;
}
}
else
gtk_combo_box_set_active ( GTK_COMBO_BOX ( rv ), 0 );
}
break;
case VIK_LAYER_WIDGET_RADIOGROUP:
/* widget_data and extra_widget_data are GList */
if ( param->type == VIK_LAYER_PARAM_UINT && param->widget_data )
{
rv = vik_radio_group_new ( param->widget_data );
if ( param->extra_widget_data ) /* map of alternate uint values for options */
{
int i;
int nb_elem = g_list_length(param->widget_data);
for ( i = 0; i < nb_elem; i++ )
if ( GPOINTER_TO_UINT ( g_list_nth_data(param->extra_widget_data, i) ) == vlpd.u )
{
vik_radio_group_set_selected ( VIK_RADIO_GROUP(rv), i );
break;
}
}
else if ( vlpd.u ) /* zero is already default */
vik_radio_group_set_selected ( VIK_RADIO_GROUP(rv), vlpd.u );
}
break;
case VIK_LAYER_WIDGET_RADIOGROUP_STATIC:
if ( param->type == VIK_LAYER_PARAM_UINT && param->widget_data )
{
rv = vik_radio_group_new_static ( (const gchar **) param->widget_data );
if ( param->extra_widget_data ) /* map of alternate uint values for options */
{
int i;
for ( i = 0; ((const char **)param->widget_data)[i]; i++ )
if ( ((guint *)param->extra_widget_data)[i] == vlpd.u )
{
vik_radio_group_set_selected ( VIK_RADIO_GROUP(rv), i );
break;
}
}
else if ( vlpd.u ) /* zero is already default */
vik_radio_group_set_selected ( VIK_RADIO_GROUP(rv), vlpd.u );
}
break;
case VIK_LAYER_WIDGET_SPINBUTTON:
if ( (param->type == VIK_LAYER_PARAM_DOUBLE || param->type == VIK_LAYER_PARAM_UINT
|| param->type == VIK_LAYER_PARAM_INT) && param->widget_data )
{
gdouble init_val = (param->type == VIK_LAYER_PARAM_DOUBLE) ? vlpd.d : (param->type == VIK_LAYER_PARAM_UINT ? vlpd.u : vlpd.i);
VikLayerParamScale *scale = (VikLayerParamScale *) param->widget_data;
rv = gtk_spin_button_new ( GTK_ADJUSTMENT(gtk_adjustment_new( init_val, scale->min, scale->max, scale->step, scale->step, 0 )), scale->step, scale->digits );
}
break;
case VIK_LAYER_WIDGET_ENTRY:
if ( param->type == VIK_LAYER_PARAM_STRING )
{
rv = gtk_entry_new ();
if ( vlpd.s )
gtk_entry_set_text ( GTK_ENTRY(rv), vlpd.s );
}
break;
case VIK_LAYER_WIDGET_PASSWORD:
if ( param->type == VIK_LAYER_PARAM_STRING )
{
rv = gtk_entry_new ();
gtk_entry_set_visibility ( GTK_ENTRY(rv), FALSE );
if ( vlpd.s )
gtk_entry_set_text ( GTK_ENTRY(rv), vlpd.s );
gtk_widget_set_tooltip_text ( GTK_WIDGET(rv),
_("Take care that this password will be stored clearly in a plain file.") );
}
break;
case VIK_LAYER_WIDGET_FILEENTRY:
if ( param->type == VIK_LAYER_PARAM_STRING )
{
rv = vik_file_entry_new (GTK_FILE_CHOOSER_ACTION_OPEN);
if ( vlpd.s )
vik_file_entry_set_filename ( VIK_FILE_ENTRY(rv), vlpd.s );
}
break;
case VIK_LAYER_WIDGET_FOLDERENTRY:
if ( param->type == VIK_LAYER_PARAM_STRING )
{
rv = vik_file_entry_new (GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER);
if ( vlpd.s )
vik_file_entry_set_filename ( VIK_FILE_ENTRY(rv), vlpd.s );
}
break;
case VIK_LAYER_WIDGET_FILELIST:
if ( param->type == VIK_LAYER_PARAM_STRING_LIST )
{
rv = vik_file_list_new ( _(param->title) );
vik_file_list_set_files ( VIK_FILE_LIST(rv), vlpd.sl );
}
break;
case VIK_LAYER_WIDGET_HSCALE:
if ( (param->type == VIK_LAYER_PARAM_DOUBLE || param->type == VIK_LAYER_PARAM_UINT
|| param->type == VIK_LAYER_PARAM_INT) && param->widget_data )
{
gdouble init_val = (param->type == VIK_LAYER_PARAM_DOUBLE) ? vlpd.d : (param->type == VIK_LAYER_PARAM_UINT ? vlpd.u : vlpd.i);
VikLayerParamScale *scale = (VikLayerParamScale *) param->widget_data;
rv = gtk_hscale_new_with_range ( scale->min, scale->max, scale->step );
gtk_scale_set_digits ( GTK_SCALE(rv), scale->digits );
gtk_range_set_value ( GTK_RANGE(rv), init_val );
}
}
if ( rv && !gtk_widget_get_tooltip_text ( rv ) ) {
if ( param->tooltip )
gtk_widget_set_tooltip_text ( rv, _(param->tooltip) );
}
return rv;
}
static gchar *a_prompt_for_goto_string(VikWindow *vw)
{
GtkWidget *dialog = NULL;
dialog = gtk_dialog_new_with_buttons ( "", GTK_WINDOW(vw), 0, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, NULL );
gtk_window_set_title(GTK_WINDOW(dialog), _("goto"));
GtkWidget *tool_label = gtk_label_new(_("goto provider:"));
GtkWidget *tool_list = vik_combo_box_text_new ();
GList *current = g_list_first (goto_tools_list);
while (current != NULL)
{
char *label = NULL;
VikGotoTool *tool = current->data;
label = vik_goto_tool_get_label (tool);
vik_combo_box_text_append ( tool_list, label );
current = g_list_next (current);
}
get_provider ();
gtk_combo_box_set_active ( GTK_COMBO_BOX( tool_list ), last_goto_tool );
GtkWidget *goto_label = gtk_label_new(_("Enter address or place name:"));
GtkWidget *goto_entry = gtk_entry_new();
if (last_goto_str)
gtk_entry_set_text(GTK_ENTRY(goto_entry), last_goto_str);
// 'ok' when press return in the entry
g_signal_connect_swapped (goto_entry, "activate", G_CALLBACK(a_dialog_response_accept), dialog);
gtk_box_pack_start ( GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), tool_label, FALSE, FALSE, 5 );
gtk_box_pack_start ( GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), tool_list, FALSE, FALSE, 5 );
gtk_box_pack_start ( GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), goto_label, FALSE, FALSE, 5 );
gtk_box_pack_start ( GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), goto_entry, FALSE, FALSE, 5 );
gtk_dialog_set_default_response ( GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT );
gtk_widget_show_all(dialog);
// Ensure the text field has focus so we can start typing straight away
gtk_widget_grab_focus ( goto_entry );
if ( gtk_dialog_run ( GTK_DIALOG(dialog) ) != GTK_RESPONSE_ACCEPT ) {
gtk_widget_destroy(dialog);
return NULL;
}
// TODO check if list is empty
last_goto_tool = gtk_combo_box_get_active ( GTK_COMBO_BOX(tool_list) );
gchar *provider = vik_goto_tool_get_label ( g_list_nth_data (goto_tools_list, last_goto_tool) );
a_settings_set_string ( VIK_SETTINGS_GOTO_PROVIDER, provider );
gchar *goto_str = g_strdup ( gtk_entry_get_text ( GTK_ENTRY(goto_entry) ) );
gtk_widget_destroy(dialog);
if (goto_str[0] != '\0') {
if (last_goto_str)
g_free(last_goto_str);
last_goto_str = g_strdup(goto_str);
}
return(goto_str); /* goto_str needs to be freed by caller */
}
static GtkWidget *create_custom_widget_cb(GtkPrintOperation *operation, PrintData *data)
{
GtkWidget *layout;
GtkWidget *main_hbox;
GtkWidget *main_vbox;
GtkWidget *hbox;
GtkWidget *vbox;
GtkWidget *button;
GtkWidget *label;
GtkPageSetup *setup;
CustomWidgetInfo *info = g_malloc0(sizeof(CustomWidgetInfo));
g_signal_connect_swapped (data->operation, _("done"), G_CALLBACK (custom_widgets_cleanup), info);
info->data = data;
setup = gtk_print_operation_get_default_page_setup (data->operation);
if (! setup) {
setup = gtk_page_setup_new ();
gtk_print_operation_set_default_page_setup (data->operation, setup);
}
layout = gtk_vbox_new (FALSE, 6);
gtk_container_set_border_width (GTK_CONTAINER (layout), 12);
/* main hbox */
main_hbox = gtk_hbox_new (FALSE, 12);
gtk_box_pack_start (GTK_BOX (layout), main_hbox, TRUE, TRUE, 0);
gtk_widget_show (main_hbox);
/* main vbox */
main_vbox = gtk_vbox_new (FALSE, 12);
gtk_box_pack_start (GTK_BOX (main_hbox), main_vbox, FALSE, FALSE, 0);
gtk_widget_show (main_vbox);
vbox = gtk_vbox_new (FALSE, 6);
gtk_box_pack_start (GTK_BOX (main_vbox), vbox, FALSE, FALSE, 0);
gtk_widget_show (vbox);
/* Page Size */
button = gtk_button_new_with_mnemonic (_("_Adjust Page Size "
"and Orientation"));
gtk_box_pack_start (GTK_BOX (main_vbox), button, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (page_setup_cb),
info);
gtk_widget_show (button);
/* Center */
GtkWidget *combo;
const PrintCenterName *center;
hbox = gtk_hbox_new (FALSE, 6);
gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
label = gtk_label_new_with_mnemonic (_("C_enter:"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
combo = vik_combo_box_text_new ();
for (center = center_modes; center->name; center++) {
vik_combo_box_text_append (combo, _(center->name));
}
gtk_combo_box_set_active(GTK_COMBO_BOX(combo), VIK_PRINT_CENTER_BOTH);
gtk_box_pack_start (GTK_BOX (hbox), combo, TRUE, TRUE, 0);
gtk_widget_show (combo);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), combo);
g_signal_connect(combo, "changed",
G_CALLBACK(center_changed_cb), info);
info->center_combo = combo;
/* ignore page margins */
button = gtk_check_button_new_with_mnemonic (_("Ignore Page _Margins"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),
data->use_full_page);
gtk_box_pack_start (GTK_BOX (main_vbox), button, FALSE, FALSE, 0);
g_signal_connect (button, "toggled",
G_CALLBACK (full_page_toggled_cb),
info);
gtk_widget_show (button);
/* scale */
vbox = gtk_vbox_new (FALSE, 1);
gtk_box_pack_start (GTK_BOX (main_vbox), vbox, FALSE, FALSE, 0);
gtk_widget_show (vbox);
hbox = gtk_hbox_new (FALSE, 6);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
label = gtk_label_new_with_mnemonic (_("Image S_ize:"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
label = gtk_label_new (NULL);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
info->scale_label = label;
gtk_box_pack_start (GTK_BOX (hbox), info->scale_label, TRUE, TRUE, 0);
gtk_widget_show (info->scale_label);
info->scale = gtk_hscale_new_with_range(1, 100, 1);
gtk_box_pack_start (GTK_BOX (vbox), info->scale, TRUE, TRUE, 0);
gtk_scale_set_draw_value(GTK_SCALE(info->scale), FALSE);
gtk_widget_show (info->scale);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), info->scale);
g_signal_connect(info->scale, "change_value",
G_CALLBACK(scale_change_value_cb), info);
info->preview = vik_print_preview_new (setup, GDK_DRAWABLE(vik_viewport_get_pixmap(data->vvp)));
vik_print_preview_set_use_full_page (VIK_PRINT_PREVIEW(info->preview),
data->use_full_page);
gtk_box_pack_start (GTK_BOX (main_hbox), info->preview, TRUE, TRUE, 0);
gtk_widget_show (info->preview);
g_signal_connect (info->preview, "offsets-changed",
G_CALLBACK (preview_offsets_changed_cb),
info);
update_page_setup (info);
gdouble offset_x_max, offset_y_max;
get_max_offsets (info, &offset_x_max, &offset_y_max);
vik_print_preview_set_image_offsets_max (VIK_PRINT_PREVIEW (info->preview),
offset_x_max, offset_y_max);
set_scale_value(info);
return layout;
}
/**
* 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 );
}
static void datasource_gps_add_setup_widgets ( GtkWidget *dialog, VikViewport *vvp, gpointer user_data )
{
gps_user_data_t *w = (gps_user_data_t *)user_data;
GtkTable *box, *data_type_box;
w->proto_l = gtk_label_new (_("GPS Protocol:"));
w->proto_b = vik_combo_box_text_new ();
g_list_foreach (a_babel_device_list, append_element, w->proto_b);
if ( last_active < 0 ) {
find_entry = -1;
wanted_entry = -1;
gchar *protocol = NULL;
if ( a_settings_get_string ( VIK_SETTINGS_GPS_PROTOCOL, &protocol ) ) {
// Use setting
if ( protocol )
g_list_foreach (a_babel_device_list, find_protocol, protocol);
}
else {
// Attempt to maintain default to Garmin devices (assumed most popular/numerous device)
g_list_foreach (a_babel_device_list, find_protocol, "garmin");
}
// If not found set it to the first entry, otherwise use the entry
last_active = ( wanted_entry < 0 ) ? 0 : wanted_entry;
}
gtk_combo_box_set_active (GTK_COMBO_BOX(w->proto_b), last_active);
g_object_ref(w->proto_b);
w->ser_l = gtk_label_new (_("Serial Port:"));
#if GTK_CHECK_VERSION (2, 24, 0)
w->ser_b = gtk_combo_box_text_new_with_entry ();
#else
w->ser_b = gtk_combo_box_entry_new_text ();
#endif
// Value from the settings is promoted to the top
gchar *gps_port = NULL;
if ( a_settings_get_string ( VIK_SETTINGS_GPS_PORT, &gps_port ) ) {
// Use setting if available
if ( gps_port ) {
#ifndef WINDOWS
if ( !strncmp (gps_port, "/dev/tty", 6) ) {
if (g_access (gps_port, R_OK) == 0) {
vik_combo_box_text_append (w->ser_b, gps_port);
}
}
else
#endif
vik_combo_box_text_append (w->ser_b, gps_port);
}
}
// Note avoid appending the port selected from the settings
#ifdef WINDOWS
if ( gps_port && strcmp (gps_port, "com1") )
vik_combo_box_text_append (w->ser_b, "com1");
#else
/* Here just try to see if the device is available which gets passed onto gpsbabel
List USB devices first as these will generally only be present if autogenerated by udev or similar
User is still able to set their own free text entry */
if ( gps_port && strcmp (gps_port, "/dev/ttyUSB0") )
if (g_access ("/dev/ttyUSB0", R_OK) == 0)
vik_combo_box_text_append (w->ser_b, "/dev/ttyUSB0");
if ( gps_port && strcmp (gps_port, "/dev/ttyUSB1") )
if (g_access ("/dev/ttyUSB1", R_OK) == 0)
vik_combo_box_text_append (w->ser_b, "/dev/ttyUSB1");
if ( gps_port && strcmp (gps_port, "/dev/ttyS0") )
if (g_access ("/dev/ttyS0", R_OK) == 0)
vik_combo_box_text_append (w->ser_b, "/dev/ttyS0");
if ( gps_port && strcmp (gps_port, "/dev/ttyS1") )
if (g_access ("/dev/ttyS1", R_OK) == 0)
vik_combo_box_text_append (w->ser_b, "/dev/ttyS1");
#endif
if ( gps_port && strcmp (gps_port, "usb:") )
vik_combo_box_text_append (w->ser_b, "usb:");
gtk_combo_box_set_active (GTK_COMBO_BOX(w->ser_b), 0);
g_object_ref(w->ser_b);
w->off_request_l = gtk_label_new (_("Turn Off After Transfer\n(Garmin/NAViLink Only)"));
w->off_request_b = GTK_CHECK_BUTTON ( gtk_check_button_new () );
gboolean power_off;
if ( ! a_settings_get_boolean ( VIK_SETTINGS_GPS_POWER_OFF, &power_off ) )
power_off = FALSE;
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w->off_request_b), power_off);
w->get_tracks_l = gtk_label_new (_("Tracks:"));
w->get_tracks_b = GTK_CHECK_BUTTON ( gtk_check_button_new () );
gboolean get_tracks;
if ( ! a_settings_get_boolean ( VIK_SETTINGS_GPS_GET_TRACKS, &get_tracks ) )
get_tracks = TRUE;
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w->get_tracks_b), get_tracks);
w->get_routes_l = gtk_label_new (_("Routes:"));
w->get_routes_b = GTK_CHECK_BUTTON ( gtk_check_button_new () );
gboolean get_routes;
if ( ! a_settings_get_boolean ( VIK_SETTINGS_GPS_GET_ROUTES, &get_routes ) )
get_routes = FALSE;
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w->get_routes_b), get_routes);
w->get_waypoints_l = gtk_label_new (_("Waypoints:"));
w->get_waypoints_b = GTK_CHECK_BUTTON ( gtk_check_button_new () );
gboolean get_waypoints;
if ( ! a_settings_get_boolean ( VIK_SETTINGS_GPS_GET_WAYPOINTS, &get_waypoints ) )
get_waypoints = TRUE;
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w->get_waypoints_b), get_waypoints);
box = GTK_TABLE(gtk_table_new(2, 4, FALSE));
data_type_box = GTK_TABLE(gtk_table_new(4, 1, FALSE));
gtk_table_attach_defaults(box, GTK_WIDGET(w->proto_l), 0, 1, 0, 1);
gtk_table_attach_defaults(box, GTK_WIDGET(w->proto_b), 1, 2, 0, 1);
gtk_table_attach_defaults(box, GTK_WIDGET(w->ser_l), 0, 1, 1, 2);
gtk_table_attach_defaults(box, GTK_WIDGET(w->ser_b), 1, 2, 1, 2);
gtk_table_attach_defaults(data_type_box, GTK_WIDGET(w->get_tracks_l), 0, 1, 0, 1);
gtk_table_attach_defaults(data_type_box, GTK_WIDGET(w->get_tracks_b), 1, 2, 0, 1);
gtk_table_attach_defaults(data_type_box, GTK_WIDGET(w->get_routes_l), 2, 3, 0, 1);
gtk_table_attach_defaults(data_type_box, GTK_WIDGET(w->get_routes_b), 3, 4, 0, 1);
gtk_table_attach_defaults(data_type_box, GTK_WIDGET(w->get_waypoints_l), 4, 5, 0, 1);
gtk_table_attach_defaults(data_type_box, GTK_WIDGET(w->get_waypoints_b), 5, 6, 0, 1);
gtk_table_attach_defaults(box, GTK_WIDGET(data_type_box), 0, 2, 2, 3);
gtk_table_attach_defaults(box, GTK_WIDGET(w->off_request_l), 0, 1, 3, 4);
gtk_table_attach_defaults(box, GTK_WIDGET(w->off_request_b), 1, 3, 3, 4);
gtk_box_pack_start ( GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), GTK_WIDGET(box), FALSE, FALSE, 5 );
gtk_widget_show_all ( dialog );
}
