void
dlg_catalog_properties (GthBrowser *browser,
GthFileData *file_data)
{
DialogData *data;
g_return_if_fail (file_data != NULL);
data = g_new0 (DialogData, 1);
data->browser = browser;
data->file_data = gth_file_data_dup (file_data);
data->original_file = g_file_dup (data->file_data->file);
data->builder = _gtk_builder_new_from_file ("catalog-properties.ui", "catalogs");
/* Set widgets data. */
data->dialog = g_object_new (GTK_TYPE_DIALOG,
"title", _("Properties"),
"transient-for", GTK_WINDOW (browser),
"modal", TRUE,
"destroy-with-parent", FALSE,
"use-header-bar", _gtk_settings_get_dialogs_use_header (),
NULL);
gtk_container_add (GTK_CONTAINER (gtk_dialog_get_content_area (GTK_DIALOG (data->dialog))),
_gtk_builder_get_widget (data->builder, "dialog_content"));
gtk_dialog_add_buttons (GTK_DIALOG (data->dialog),
_GTK_LABEL_CANCEL, GTK_RESPONSE_CANCEL,
_GTK_LABEL_SAVE, GTK_RESPONSE_OK,
NULL);
_gtk_dialog_add_class_to_response (GTK_DIALOG (data->dialog), GTK_RESPONSE_OK, GTK_STYLE_CLASS_SUGGESTED_ACTION);
data->time_selector = gth_time_selector_new ();
gth_time_selector_show_time (GTH_TIME_SELECTOR (data->time_selector), FALSE, FALSE);
gtk_widget_show (data->time_selector);
gtk_box_pack_start (GTK_BOX (GET_WIDGET ("date_container_box")), data->time_selector, TRUE, TRUE, 0);
/* Set the signals handlers. */
g_signal_connect (G_OBJECT (data->dialog),
"destroy",
G_CALLBACK (destroy_cb),
data);
g_signal_connect (gtk_dialog_get_widget_for_response (GTK_DIALOG (data->dialog), GTK_RESPONSE_OK),
"clicked",
G_CALLBACK (save_button_clicked_cb),
data);
g_signal_connect_swapped (gtk_dialog_get_widget_for_response (GTK_DIALOG (data->dialog), GTK_RESPONSE_CANCEL),
"clicked",
G_CALLBACK (gtk_widget_destroy),
data->dialog);
/* run dialog. */
gtk_widget_grab_focus (GET_WIDGET ("name_entry"));
gth_catalog_load_from_file_async (file_data->file, NULL, catalog_ready_cb, data);
}
static void compound_changed(GtkEditable *widget, gpointer data) {
const char *textPtr,*textPtr2;
char *endPtr;
const char *lastPtr;
XmiMsimGuiCompoundDialog *dialog = (XmiMsimGuiCompoundDialog *) data;
struct compoundData *cd;
double weight;
textPtr = gtk_entry_get_text(GTK_ENTRY(dialog->compoundEntry));
textPtr2 = gtk_entry_get_text(GTK_ENTRY(dialog->weightEntry));
weight = strtod(textPtr2, &endPtr);
cd = CompoundParser(textPtr);
lastPtr = textPtr2 + strlen(textPtr2);
if (GTK_WIDGET(widget) == dialog->compoundEntry) {
if (cd) {
gtk_widget_modify_base(GTK_WIDGET(widget), GTK_STATE_NORMAL, NULL);
}
else {
//bad value
gtk_widget_modify_base(GTK_WIDGET(widget), GTK_STATE_NORMAL, &red);
gtk_widget_set_sensitive(gtk_dialog_get_widget_for_response(GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT), FALSE);
}
if (cd && lastPtr == endPtr && weight > 0.0) {
gtk_widget_set_sensitive(gtk_dialog_get_widget_for_response(GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT), TRUE);
}
}
else if (GTK_WIDGET(widget) == dialog->weightEntry) {
if (lastPtr == endPtr && weight > 0.0) {
gtk_widget_modify_base(GTK_WIDGET(widget), GTK_STATE_NORMAL, NULL);
}
else {
//bad value
gtk_widget_modify_base(GTK_WIDGET(widget), GTK_STATE_NORMAL, &red);
gtk_widget_set_sensitive(gtk_dialog_get_widget_for_response(GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT), FALSE);
}
if (cd && lastPtr == endPtr && weight > 0.0) {
gtk_widget_set_sensitive(gtk_dialog_get_widget_for_response(GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT), TRUE);
}
}
if (cd)
FreeCompoundData(cd);
}
Php::Value GtkDialog_::get_widget_for_response(Php::Parameters ¶meters)
{
gint response_id = (gint)parameters[0];
GtkWidget *ret = gtk_dialog_get_widget_for_response (GTK_DIALOG(instance), response_id);
GtkWidget_ *return_parsed = new GtkWidget_();
return_parsed->set_instance((gpointer *)ret);
return Php::Object("GtkWidget", return_parsed);
}
void _fcitx_im_dialog_im_selection_changed(GtkTreeSelection *selection, gpointer data)
{
FcitxImDialog* self = data;
GtkWidget* button = gtk_dialog_get_widget_for_response(GTK_DIALOG(self), GTK_RESPONSE_OK);
if (!button)
return;
if (gtk_tree_selection_count_selected_rows(selection))
gtk_widget_set_sensitive(button, TRUE);
else
gtk_widget_set_sensitive(button, FALSE);
}
/**
* a_background_init:
*
* Initialize background feature.
*/
void a_background_init()
{
/* initialize thread pool */
gint max_threads = 10; /* limit maximum number of threads running at one time */
gint maxt;
if ( a_settings_get_integer ( VIK_SETTINGS_BACKGROUND_MAX_THREADS, &maxt ) )
max_threads = maxt;
thread_pool = g_thread_pool_new ( (GFunc) thread_helper, NULL, max_threads, FALSE, NULL );
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkWidget *scrolled_window;
g_debug(__FUNCTION__);
/* store & treeview */
bgstore = gtk_list_store_new ( N_COLUMNS, G_TYPE_STRING, G_TYPE_DOUBLE, G_TYPE_POINTER );
bgtreeview = gtk_tree_view_new_with_model ( GTK_TREE_MODEL(bgstore) );
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (bgtreeview), TRUE);
gtk_tree_selection_set_mode (gtk_tree_view_get_selection (GTK_TREE_VIEW (bgtreeview)),
GTK_SELECTION_SINGLE);
/* add columns */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ( _("Job"), renderer, "text", TITLE_COLUMN, NULL );
gtk_tree_view_append_column ( GTK_TREE_VIEW(bgtreeview), column );
renderer = gtk_cell_renderer_progress_new ();
column = gtk_tree_view_column_new_with_attributes ( _("Progress"), renderer, "value", PROGRESS_COLUMN, NULL );
gtk_tree_view_append_column ( GTK_TREE_VIEW(bgtreeview), column );
/* setup window */
scrolled_window = gtk_scrolled_window_new ( NULL, NULL );
gtk_container_add ( GTK_CONTAINER(scrolled_window), bgtreeview );
gtk_scrolled_window_set_policy ( GTK_SCROLLED_WINDOW(scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC );
bgwindow = gtk_dialog_new_with_buttons ( "", NULL, 0, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, GTK_STOCK_DELETE, 1, GTK_STOCK_CLEAR, 2, NULL );
gtk_dialog_set_default_response ( GTK_DIALOG(bgwindow), GTK_RESPONSE_ACCEPT );
GtkWidget *response_w = NULL;
#if GTK_CHECK_VERSION (2, 20, 0)
response_w = gtk_dialog_get_widget_for_response ( GTK_DIALOG(bgwindow), GTK_RESPONSE_ACCEPT );
#endif
gtk_box_pack_start ( GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(bgwindow))), scrolled_window, TRUE, TRUE, 0 );
gtk_window_set_default_size ( GTK_WINDOW(bgwindow), 400, 400 );
gtk_window_set_title ( GTK_WINDOW(bgwindow), _("Viking Background Jobs") );
if ( response_w )
gtk_widget_grab_focus ( response_w );
/* don't destroy win */
g_signal_connect ( G_OBJECT(bgwindow), "delete-event", G_CALLBACK(gtk_widget_hide_on_delete), NULL );
g_signal_connect ( G_OBJECT(bgwindow), "response", G_CALLBACK(bgwindow_response), 0 );
}
static void
copy_dlg_entry_changed_cb (GtkEntry *entry, GtkDialog *dlg)
{
gboolean can_create = FALSE;
const gchar *name;
name = gtk_entry_get_text (entry);
if (name && *name && !gda_config_get_dsn_info (name))
can_create = TRUE;
GtkWidget *resp;
resp = gtk_dialog_get_widget_for_response (dlg, GTK_RESPONSE_ACCEPT);
gtk_widget_set_sensitive (resp, can_create);
}
static void
ide_workbench_actions_open_with_dialog (GSimpleAction *action,
GVariant *param,
gpointer user_data)
{
IdeWorkbench *self = user_data;
GtkWidget *button;
GtkWidget *dialog;
gint ret;
IDE_ENTRY;
g_assert (IDE_IS_WORKBENCH (self));
dialog = gtk_file_chooser_dialog_new (_("Open File"),
GTK_WINDOW (self),
GTK_FILE_CHOOSER_ACTION_OPEN,
_("Cancel"), GTK_RESPONSE_CANCEL,
_("Open"), GTK_RESPONSE_OK,
NULL);
gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (dialog), FALSE);
button = gtk_dialog_get_widget_for_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
gtk_style_context_add_class (gtk_widget_get_style_context (button),
GTK_STYLE_CLASS_SUGGESTED_ACTION);
/*
* TODO: Allow workbench addins to specify file filters?
* Do we want to move this to a custom interface and use that
* for file loading as well?
*/
ret = gtk_dialog_run (GTK_DIALOG (dialog));
if (ret == GTK_RESPONSE_OK)
{
g_autoptr(GFile) file = NULL;
IDE_PROBE;
file = gtk_file_chooser_get_file (GTK_FILE_CHOOSER (dialog));
ide_workbench_open_files_async (self, &file, 1, NULL, NULL,
ide_workbench_actions_open_with_dialog_cb,
NULL);
}
gtk_widget_destroy (dialog);
IDE_EXIT;
}
char * show_username_dialog(GtkWindow * window)
{
GtkWidget *dialog, *label, *content_area,*entry,*button;
entry = gtk_entry_new();
/* Create the widgets */
dialog = gtk_dialog_new_with_buttons("Username setup",
window,
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_APPLY,
GTK_RESPONSE_ACCEPT,
NULL);
content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog));
label = gtk_label_new("Please enter your youtube username\n");
button = gtk_dialog_get_widget_for_response(GTK_DIALOG(dialog),GTK_RESPONSE_ACCEPT);
gtk_widget_set_sensitive(button,gtk_false());
g_signal_connect(G_OBJECT(entry), "insert_text",
G_CALLBACK(insert_text_handler),
button);
g_signal_connect(G_OBJECT(entry), "delete-text",
G_CALLBACK(delete_text_handler),
button);
/* Ensure that the dialog box is destroyed when the user responds. */
g_signal_connect_swapped(dialog,"response",G_CALLBACK(gtk_widget_destroy),dialog);
/* Add the label, and show everything we've added to the dialog. */
gtk_container_add(GTK_CONTAINER (content_area), label);
gtk_container_add(GTK_CONTAINER (content_area), entry);
gtk_entry_set_max_length(GTK_ENTRY(entry),30);
gtk_widget_show_all(dialog);
gint result = gtk_dialog_run(GTK_DIALOG (dialog));
switch (result)
{
case GTK_RESPONSE_ACCEPT:
printf("hello this %s",gtk_entry_get_text(GTK_ENTRY(entry)));
put_username(entry);
break;
default:
printf("hello");
gtk_main_quit();
break;
}
gtk_widget_destroy(dialog);
fetch_new_videos(GTK_WINDOW(window));
}
static void
ide_editor_view_actions_save_as (GSimpleAction *action,
GVariant *param,
gpointer user_data)
{
IdeEditorView *self = user_data;
IdeBuffer *buffer;
GtkWidget *suggested;
GtkWidget *toplevel;
GtkWidget *dialog;
IdeFile *file;
GFile *gfile;
g_assert (IDE_IS_EDITOR_VIEW (self));
toplevel = gtk_widget_get_toplevel (GTK_WIDGET (self));
dialog = g_object_new (GTK_TYPE_FILE_CHOOSER_DIALOG,
"action", GTK_FILE_CHOOSER_ACTION_SAVE,
"do-overwrite-confirmation", TRUE,
"local-only", FALSE,
"modal", TRUE,
"select-multiple", FALSE,
"show-hidden", FALSE,
"transient-for", toplevel,
"title", _("Save Document As"),
NULL);
buffer = IDE_BUFFER (self->document);
file = ide_buffer_get_file (buffer);
gfile = ide_file_get_file (file);
if (gfile != NULL)
gtk_file_chooser_set_file (GTK_FILE_CHOOSER (dialog), gfile, NULL);
gtk_dialog_add_buttons (GTK_DIALOG (dialog),
_("Cancel"), GTK_RESPONSE_CANCEL,
_("Save"), GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
suggested = gtk_dialog_get_widget_for_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
gtk_style_context_add_class (gtk_widget_get_style_context (suggested),
GTK_STYLE_CLASS_SUGGESTED_ACTION);
g_signal_connect (dialog, "response", G_CALLBACK (save_as_response), g_object_ref (self));
gtk_window_present (GTK_WINDOW (dialog));
}
static void on_dir_select(GtkWidget * widget, gpointer data)
{
char * dir;
gboolean sensitive;
//log_info("selection-changed signal");
dir = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(data));
sensitive = FALSE;
if (dir != NULL)
{
sensitive = is_project_dir(dir);
g_free(dir);
}
gtk_widget_set_sensitive(gtk_dialog_get_widget_for_response(GTK_DIALOG(data), GTK_RESPONSE_ACCEPT), sensitive);
}
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 add_to_catalog_button_clicked(GtkButton *button, XmiMsimGuiLayerDialog *dialog) {
GtkWidget *update_dialog;
GtkWidget *content_area, *vbox;
update_dialog = gtk_dialog_new_with_buttons("Add current layer to the catalog",
GTK_WINDOW(dialog),
(GtkDialogFlags) (GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT),
"_Ok", GTK_RESPONSE_ACCEPT, "_Cancel", GTK_RESPONSE_REJECT, NULL);
gtk_widget_set_size_request(update_dialog, 300,-1);
content_area = gtk_dialog_get_content_area(GTK_DIALOG(update_dialog));
vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 2);
gtk_box_set_homogeneous(GTK_BOX(vbox), FALSE);
gtk_box_pack_start(GTK_BOX(vbox), gtk_label_new("Choose a name for the layer"), TRUE, FALSE, 2);
gtk_container_set_border_width(GTK_CONTAINER(vbox), 15);
GtkWidget *nameEntry = gtk_entry_new();
gtk_box_pack_start(GTK_BOX(vbox), nameEntry, TRUE, TRUE, 2);
GtkWidget *okButton = gtk_dialog_get_widget_for_response(GTK_DIALOG(update_dialog), GTK_RESPONSE_ACCEPT);
gtk_widget_set_sensitive(okButton, FALSE);
g_signal_connect(G_OBJECT(nameEntry),"changed",G_CALLBACK(name_entry_changed), (gpointer) okButton);
gtk_widget_show_all(vbox);
gtk_container_add (GTK_CONTAINER (content_area), vbox);
if (gtk_dialog_run(GTK_DIALOG(update_dialog)) == GTK_RESPONSE_ACCEPT) {
gchar *layer_name = g_strstrip(g_strdup(gtk_entry_get_text(GTK_ENTRY(nameEntry))));
GtkWidget *error_dialog;
xmi_layer *layer = xmi_msim_gui_layer_dialog_get_layer(dialog);
if (xmimsim_gui_add_user_defined_layer(layer, layer_name) == 1) {
error_dialog = gtk_message_dialog_new(GTK_WINDOW(update_dialog), (GtkDialogFlags) (GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT), GTK_MESSAGE_INFO, GTK_BUTTONS_CLOSE, "Layer %s has been added to the catalog", layer_name);
}
else {
error_dialog = gtk_message_dialog_new(GTK_WINDOW(update_dialog), (GtkDialogFlags) (GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT), GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, "Could not add layer %s to the catalog.\nReport this incident to the developers.", layer_name);
}
gtk_dialog_run(GTK_DIALOG(error_dialog));
gtk_widget_destroy(error_dialog);
g_free(layer_name);
xmi_layer_free(layer);
g_free(layer);
}
gtk_widget_destroy(update_dialog);
return;
}
/**
* a_dialog_get_positive_number:
*
* Dialog to return a positive number via a spinbox within the supplied limits
*
* Returns: A value of zero indicates the dialog was cancelled
*/
guint a_dialog_get_positive_number ( GtkWindow *parent, gchar *title_text, gchar *label_text, guint default_num, guint min, guint max, guint step )
{
GtkWidget *dialog = gtk_dialog_new_with_buttons (title_text,
parent,
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CANCEL,
GTK_RESPONSE_REJECT,
GTK_STOCK_OK,
GTK_RESPONSE_ACCEPT,
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 *table, *spin, *label;
guint result = default_num;
table = gtk_table_new ( 2, 1, FALSE );
gtk_box_pack_start ( GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), table, TRUE, TRUE, 0 );
label = gtk_label_new (label_text);
spin = gtk_spin_button_new ( (GtkAdjustment *) gtk_adjustment_new ( default_num, min, max, step, 5, 0 ), 1, 0 );
gtk_table_attach_defaults ( GTK_TABLE(table), label, 0, 1, 0, 1 );
gtk_table_attach_defaults ( GTK_TABLE(table), spin, 0, 1, 1, 2 );
if ( response_w )
gtk_widget_grab_focus ( response_w );
gtk_widget_show_all ( table );
if ( gtk_dialog_run ( GTK_DIALOG(dialog) ) == GTK_RESPONSE_ACCEPT )
{
result = gtk_spin_button_get_value ( GTK_SPIN_BUTTON(spin) );
gtk_widget_destroy ( dialog );
return result;
}
// Dialog cancelled
gtk_widget_destroy ( dialog );
return 0;
}
static void dir_changed(GtkWidget * UNUSED(widget), gpointer data)
{
char * dir;
//log_info("current-folder-changed signal");
dir = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(data));
if (dir == NULL)
{
return;
}
//log_info("dir changed: '%s'", dir);
if (is_project_dir(dir))
{
gtk_widget_activate(gtk_dialog_get_widget_for_response(GTK_DIALOG(data), GTK_RESPONSE_ACCEPT));
}
}
static void xmi_msim_compound_dialog_set_property(GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) {
XmiMsimGuiCompoundDialog *dialog = XMI_MSIM_GUI_COMPOUND_DIALOG(object);
switch (prop_id) {
case PROP_COMPOUND_DIALOG_TYPE:
dialog->compound_dialog_type = g_value_get_enum(value);
if (dialog->compound_dialog_type == XMI_MSIM_GUI_COMPOUND_DIALOG_ADD) {
gtk_window_set_title(GTK_WINDOW(dialog), "Enter a compound");
gtk_widget_set_sensitive(gtk_dialog_get_widget_for_response(GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT), FALSE);
gtk_editable_set_editable(GTK_EDITABLE(dialog->compoundEntry), TRUE);
}
else if (dialog->compound_dialog_type == XMI_MSIM_GUI_COMPOUND_DIALOG_EDIT) {
gtk_window_set_title(GTK_WINDOW(dialog), "Modify a compound");
gtk_editable_set_editable(GTK_EDITABLE(dialog->compoundEntry), FALSE);
gtk_widget_set_sensitive(dialog->compoundEntry, FALSE);
}
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
}
}
GtkWidget*
gtr_torrent_open_from_url_dialog_new( GtkWindow * parent, TrCore * core )
{
guint row;
GtkWidget * e;
GtkWidget * t;
GtkWidget * w;
w = gtk_dialog_new_with_buttons( _( "Open URL" ), parent,
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
NULL );
gtk_dialog_set_alternative_button_order( GTK_DIALOG( w ),
GTK_RESPONSE_ACCEPT,
GTK_RESPONSE_CANCEL,
-1 );
g_signal_connect( w, "response", G_CALLBACK( onOpenURLResponse ), core );
row = 0;
t = hig_workarea_create( );
hig_workarea_add_section_title( t, &row, _( "Open torrent from URL" ) );
e = gtk_entry_new( );
gtk_widget_set_size_request( e, 400, -1 );
gtr_paste_clipboard_url_into_entry( e );
g_object_set_data( G_OBJECT( w ), "url-entry", e );
hig_workarea_add_row( t, &row, _( "_URL" ), e, NULL );
gtr_dialog_set_content( GTK_DIALOG( w ), t );
if( gtk_entry_get_text_length( GTK_ENTRY( e ) ) == 0 )
gtk_widget_grab_focus( e );
else
gtk_widget_grab_focus( gtk_dialog_get_widget_for_response( GTK_DIALOG( w ), GTK_RESPONSE_ACCEPT ) );
return w;
}
/* pop up the PIN entry window. */
static char *query_pin(GtkBuilder *builder)
{
GtkEntry *pin_entry = GTK_ENTRY(ui_object(builder, "login_pin_entry"));
gtk_entry_set_text(pin_entry, "");
struct pin_ctx *pin_ctx = g_new(struct pin_ctx, 1);
pin_ctx->done = false;
pin_ctx->response = 0;
GtkButton *complete_btn = GTK_BUTTON(ui_object(builder, "login_pin_ok_btn")),
*cancel_btn = GTK_BUTTON(ui_object(builder, "login_pin_cancel_btn"));
GtkDialog *pin_wnd = GTK_DIALOG(ui_object(builder, "login_pin_dialog"));
gtk_dialog_set_default_response(pin_wnd,
gtk_dialog_get_response_for_widget(pin_wnd, GTK_WIDGET(cancel_btn)));
gulong resp = g_signal_connect(G_OBJECT(pin_wnd), "response",
G_CALLBACK(&on_login_pin_response), pin_ctx);
gtk_widget_show_all(GTK_WIDGET(pin_wnd));
gtk_dialog_run(pin_wnd);
gtk_widget_hide(GTK_WIDGET(pin_wnd));
char *ret;
if(pin_ctx->done
&& gtk_dialog_get_widget_for_response(pin_wnd, pin_ctx->response)
== GTK_WIDGET(complete_btn))
{
ret = g_strdup(gtk_entry_get_text(pin_entry));
} else {
ret = NULL;
}
g_free(pin_ctx);
g_signal_handler_disconnect(G_OBJECT(pin_wnd), resp);
return ret;
}
GtkWidget*
gtr_torrent_options_dialog_new( GtkWindow * parent, TrCore * core, tr_ctor * ctor )
{
guint row;
guint col;
const char * str;
GtkWidget * w;
GtkWidget * d;
GtkWidget * t;
GtkWidget * l;
GtkWidget * source_chooser;
struct OpenData * data;
bool flag;
GSList * list;
GSList * walk;
/* make the dialog */
d = gtk_dialog_new_with_buttons( _( "Torrent Options" ), parent,
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
NULL );
gtk_dialog_set_default_response( GTK_DIALOG( d ),
GTK_RESPONSE_ACCEPT );
gtk_dialog_set_alternative_button_order( GTK_DIALOG( d ),
GTK_RESPONSE_ACCEPT,
GTK_RESPONSE_CANCEL,
-1 );
if( tr_ctorGetDownloadDir( ctor, TR_FORCE, &str ) )
g_assert_not_reached( );
g_assert( str );
data = g_new0( struct OpenData, 1 );
data->core = core;
data->ctor = ctor;
data->filename = g_strdup( tr_ctorGetSourceFile( ctor ) );
data->downloadDir = g_strdup( str );
data->file_list = gtr_file_list_new( core, 0 );
str = _( "Mo_ve .torrent file to the trash" );
data->trash_check = gtk_check_button_new_with_mnemonic( str );
str = _( "_Start when added" );
data->run_check = gtk_check_button_new_with_mnemonic( str );
w = data->priority_combo = gtr_priority_combo_new( );
gtr_priority_combo_set_value( GTK_COMBO_BOX( w ), TR_PRI_NORMAL );
g_signal_connect( G_OBJECT( d ), "response",
G_CALLBACK( addResponseCB ), data );
t = gtk_table_new( 6, 2, FALSE );
gtk_container_set_border_width( GTK_CONTAINER( t ), GUI_PAD_BIG );
gtk_table_set_row_spacings( GTK_TABLE( t ), GUI_PAD );
gtk_table_set_col_spacings( GTK_TABLE( t ), GUI_PAD_BIG );
row = col = 0;
l = gtk_label_new_with_mnemonic( _( "_Torrent file:" ) );
gtk_misc_set_alignment( GTK_MISC( l ), 0.0f, 0.5f );
gtk_table_attach( GTK_TABLE( t ), l, col, col + 1, row, row + 1, GTK_FILL, 0, 0, 0 );
++col;
w = gtk_file_chooser_button_new( _( "Select Source File" ),
GTK_FILE_CHOOSER_ACTION_OPEN );
source_chooser = w;
gtk_table_attach( GTK_TABLE( t ), w, col, col + 1, row, row + 1, ~0, 0, 0, 0 );
gtk_label_set_mnemonic_widget( GTK_LABEL( l ), w );
addTorrentFilters( GTK_FILE_CHOOSER( w ) );
g_signal_connect( w, "selection-changed",
G_CALLBACK( sourceChanged ), data );
++row;
col = 0;
l = gtk_label_new_with_mnemonic( _( "_Destination folder:" ) );
gtk_misc_set_alignment( GTK_MISC( l ), 0.0f, 0.5f );
gtk_table_attach( GTK_TABLE( t ), l, col, col + 1, row, row + 1, GTK_FILL, 0, 0, 0 );
++col;
w = gtk_file_chooser_button_new( _( "Select Destination Folder" ),
GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER );
if( !gtk_file_chooser_set_current_folder( GTK_FILE_CHOOSER( w ),
data->downloadDir ) )
g_warning( "couldn't select '%s'", data->downloadDir );
list = get_recent_destinations( );
for( walk = list; walk; walk = walk->next )
gtk_file_chooser_add_shortcut_folder( GTK_FILE_CHOOSER( w ), walk->data, NULL );
g_slist_free( list );
gtk_table_attach( GTK_TABLE( t ), w, col, col + 1, row, row + 1, ~0, 0, 0, 0 );
gtk_label_set_mnemonic_widget( GTK_LABEL( l ), w );
g_signal_connect( w, "selection-changed",
G_CALLBACK( downloadDirChanged ), data );
++row;
col = 0;
w = data->file_list;
gtk_widget_set_size_request ( w, 466u, 300u );
gtk_table_attach_defaults( GTK_TABLE( t ), w, col, col + 2, row, row + 1 );
++row;
col = 0;
w = gtk_label_new_with_mnemonic( _( "Torrent _priority:" ) );
gtk_misc_set_alignment( GTK_MISC( w ), 0.0f, 0.5f );
gtk_table_attach( GTK_TABLE( t ), w, col, col + 1, row, row + 1, ~0, 0, 0, 0 );
++col;
gtk_table_attach( GTK_TABLE( t ), data->priority_combo, col, col + 1, row, row + 1, ~0, 0, 0, 0 );
gtk_label_set_mnemonic_widget( GTK_LABEL( w ), data->priority_combo );
++row;
col = 0;
w = data->run_check;
if( tr_ctorGetPaused( ctor, TR_FORCE, &flag ) )
g_assert_not_reached( );
gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( w ), !flag );
gtk_table_attach( GTK_TABLE( t ), w, col, col + 2, row, row + 1, GTK_FILL, 0, 0, 0 );
++row;
col = 0;
w = data->trash_check;
if( tr_ctorGetDeleteSource( ctor, &flag ) )
g_assert_not_reached( );
gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( w ), flag );
gtk_table_attach( GTK_TABLE( t ), w, col, col + 2, row, row + 1, GTK_FILL, 0, 0, 0 );
/* trigger sourceChanged, either directly or indirectly,
* so that it creates the tor/gtor objects */
w = source_chooser;
if( data->filename )
gtk_file_chooser_set_filename( GTK_FILE_CHOOSER( w ), data->filename );
else
sourceChanged( GTK_FILE_CHOOSER_BUTTON( w ), data );
gtr_dialog_set_content( GTK_DIALOG( d ), t );
w = gtk_dialog_get_widget_for_response( GTK_DIALOG( d ), GTK_RESPONSE_ACCEPT );
gtk_widget_grab_focus( w );
return d;
}
void
dlg_password (GtkWidget *widget,
gpointer callback_data)
{
FrWindow *window = callback_data;
DialogData *data;
GtkWidget *content_area;
char *basename;
char *title;
data = g_new0 (DialogData, 1);
data->window = window;
data->builder = _gtk_builder_new_from_resource ("password.ui");
if (data->builder == NULL) {
g_free (data);
return;
}
/* Set widgets data. */
data->dialog = g_object_new (GTK_TYPE_DIALOG,
"transient-for", GTK_WINDOW (window),
"modal", TRUE,
"use-header-bar", _gtk_settings_get_dialogs_use_header (),
NULL);
content_area = gtk_dialog_get_content_area (GTK_DIALOG (data->dialog));
gtk_container_add (GTK_CONTAINER (content_area),
GET_WIDGET ("password_vbox"));
gtk_dialog_add_buttons (GTK_DIALOG (data->dialog),
_GTK_LABEL_CANCEL, GTK_RESPONSE_CANCEL,
_GTK_LABEL_SAVE, GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_default_response (GTK_DIALOG (data->dialog), GTK_RESPONSE_OK);
gtk_style_context_add_class (gtk_widget_get_style_context (gtk_dialog_get_widget_for_response (GTK_DIALOG (data->dialog), GTK_RESPONSE_OK)),
GTK_STYLE_CLASS_SUGGESTED_ACTION);
basename = _g_file_get_display_basename (fr_archive_get_file (window->archive));
title = g_strdup_printf (_("Enter a password for “%s”"), basename);
gtk_label_set_text (GTK_LABEL (GET_WIDGET ("title_label")), title);
g_free (title);
g_free (basename);
_gtk_entry_use_as_password_entry (GTK_ENTRY (GET_WIDGET ("password_entry")));
_gtk_entry_set_locale_text (GTK_ENTRY (GET_WIDGET ("password_entry")),
fr_window_get_password (window));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (GET_WIDGET ("encrypt_header_checkbutton")),
fr_window_get_encrypt_header (window));
if (! fr_archive_is_capable_of (window->archive, FR_ARCHIVE_CAN_ENCRYPT_HEADER)) {
gtk_toggle_button_set_inconsistent (GTK_TOGGLE_BUTTON (GET_WIDGET ("encrypt_header_checkbutton")), TRUE);
gtk_widget_set_sensitive (GET_WIDGET ("encrypt_header_checkbutton"), FALSE);
}
/* Set the signals handlers. */
g_signal_connect ((data->dialog),
"destroy",
G_CALLBACK (destroy_cb),
data);
g_signal_connect ((data->dialog),
"response",
G_CALLBACK (response_cb),
data);
/* Run dialog. */
gtk_widget_grab_focus (GET_WIDGET ("password_entry"));
gtk_widget_show (data->dialog);
}
void
dlg_sort_order (GthBrowser *browser)
{
DialogData *data;
GtkWidget *first_button;
GthFileData *file_data;
GList *scan;
gboolean sort_inverse;
if (gth_browser_get_dialog (browser, "sort-order") != NULL) {
gtk_window_present (GTK_WINDOW (gth_browser_get_dialog (browser, "sort-order")));
return;
}
data = g_new0 (DialogData, 1);
data->browser = browser;
data->builder = _gtk_builder_new_from_file ("sort-order.ui", NULL);
/* Get the widgets. */
data->dialog = g_object_new (GTK_TYPE_DIALOG,
"title", _("Sort By"),
"transient-for", GTK_WINDOW (browser),
"modal", FALSE,
"destroy-with-parent", FALSE,
"use-header-bar", _gtk_settings_get_dialogs_use_header (),
NULL);
gtk_container_add (GTK_CONTAINER (gtk_dialog_get_content_area (GTK_DIALOG (data->dialog))),
_gtk_builder_get_widget (data->builder, "dialog_content"));
gtk_dialog_add_buttons (GTK_DIALOG (data->dialog),
_GTK_LABEL_OK, GTK_RESPONSE_CLOSE,
NULL);
gth_browser_set_dialog (browser, "sort-order", data->dialog);
g_object_set_data (G_OBJECT (data->dialog), "dialog_data", data);
/* Set widgets data. */
file_data = gth_browser_get_location_data (data->browser);
if (file_data != NULL) {
data->current_sort_type = gth_main_get_sort_type (g_file_info_get_attribute_string (file_data->info, "sort::type"));
sort_inverse = g_file_info_get_attribute_boolean (file_data->info, "sort::inverse");
}
else
gth_browser_get_sort_order (data->browser, &data->current_sort_type, &sort_inverse);
first_button = NULL;
data->sort_types = gth_main_get_all_sort_types ();
for (scan = data->sort_types; scan; scan = scan->next) {
GthFileDataSort *sort_type = scan->data;
GtkWidget *button;
ButtonData *button_data;
button = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (first_button), _(sort_type->display_name));
if (scan == data->sort_types)
first_button = button;
gtk_widget_show (button);
gtk_box_pack_start (GTK_BOX (GET_WIDGET ("sort_order_box")), button, FALSE, FALSE, 0);
if (strcmp (sort_type->name, data->current_sort_type->name) == 0)
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
button_data = g_new0 (ButtonData, 1);
button_data->data = data;
button_data->sort_type = sort_type;
g_signal_connect_data (button,
"toggled",
G_CALLBACK (order_button_toggled_cb),
button_data,
(GClosureNotify) button_data_free,
0);
}
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (GET_WIDGET ("inverse_checkbutton")), sort_inverse);
/* Set the signals handlers. */
g_signal_connect (G_OBJECT (data->dialog),
"destroy",
G_CALLBACK (destroy_cb),
data);
g_signal_connect_swapped (gtk_dialog_get_widget_for_response (GTK_DIALOG (data->dialog), GTK_RESPONSE_CLOSE),
"clicked",
G_CALLBACK (gtk_widget_destroy),
G_OBJECT (data->dialog));
g_signal_connect (GET_WIDGET ("inverse_checkbutton"),
"toggled",
G_CALLBACK (apply_sort_order),
data);
/* run dialog. */
gtk_window_set_transient_for (GTK_WINDOW (data->dialog),
GTK_WINDOW (browser));
gtk_window_set_modal (GTK_WINDOW (data->dialog), FALSE);
gtk_widget_show (data->dialog);
}
GList *a_dialog_select_from_list ( GtkWindow *parent, GList *names, gboolean multiple_selection_allowed, const gchar *title, const gchar *msg )
{
GtkTreeIter iter;
GtkCellRenderer *renderer;
GtkWidget *view;
GtkWidget *dialog = gtk_dialog_new_with_buttons (title,
parent,
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CANCEL,
GTK_RESPONSE_REJECT,
GTK_STOCK_OK,
GTK_RESPONSE_ACCEPT,
NULL);
/* When something is selected then OK */
gtk_dialog_set_default_response ( GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT );
GtkWidget *response_w = NULL;
#if GTK_CHECK_VERSION (2, 20, 0)
/* Default to not apply - as initially nothing is selected! */
response_w = gtk_dialog_get_widget_for_response ( GTK_DIALOG(dialog), GTK_RESPONSE_REJECT );
#endif
GtkListStore *store = gtk_list_store_new(1, G_TYPE_STRING);
GtkWidget *scrolledwindow;
GList *runner = names;
while (runner)
{
gtk_list_store_append(store, &iter);
gtk_list_store_set(store, &iter, 0, runner->data, -1);
runner = g_list_next(runner);
}
view = gtk_tree_view_new();
renderer = gtk_cell_renderer_text_new();
// Use the column header to display the message text,
// this makes the overall widget allocation simple as treeview takes up all the space
GtkTreeViewColumn *column;
column = gtk_tree_view_column_new_with_attributes (msg, renderer, "text", 0, NULL );
gtk_tree_view_column_set_sort_column_id (column, 0);
gtk_tree_view_append_column (GTK_TREE_VIEW (view), column);
gtk_tree_view_set_model(GTK_TREE_VIEW(view), GTK_TREE_MODEL(store));
gtk_tree_selection_set_mode( gtk_tree_view_get_selection(GTK_TREE_VIEW(view)),
multiple_selection_allowed ? GTK_SELECTION_MULTIPLE : GTK_SELECTION_BROWSE );
g_object_unref(store);
scrolledwindow = gtk_scrolled_window_new ( NULL, NULL );
gtk_scrolled_window_set_policy ( GTK_SCROLLED_WINDOW(scrolledwindow), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC );
gtk_container_add ( GTK_CONTAINER(scrolledwindow), view );
gtk_box_pack_start ( GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), scrolledwindow, TRUE, TRUE, 0 );
// Ensure a reasonable number of items are shown, but let the width be automatically sized
gtk_widget_set_size_request ( dialog, -1, 400) ;
gtk_widget_show_all ( dialog );
if ( response_w )
gtk_widget_grab_focus ( response_w );
while ( gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT )
{
GList *names_selected = NULL;
GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
gtk_tree_selection_selected_foreach(selection, get_selected_foreach_func, &names_selected);
if (names_selected)
{
gtk_widget_destroy ( dialog );
return names_selected;
}
a_dialog_error_msg(parent, _("Nothing was selected"));
}
gtk_widget_destroy ( dialog );
return NULL;
}
GList *a_select_geoname_from_list(GtkWindow *parent, GList *geonames, gboolean multiple_selection_allowed, const gchar *title, const gchar *msg)
{
GtkTreeIter iter;
GtkCellRenderer *renderer;
GtkCellRenderer *toggle_render;
GtkWidget *view;
found_geoname *geoname;
gchar *latlon_string;
int column_runner;
gboolean checked;
gboolean to_copy;
GtkWidget *dialog = gtk_dialog_new_with_buttons (title,
parent,
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CANCEL,
GTK_RESPONSE_REJECT,
GTK_STOCK_OK,
GTK_RESPONSE_ACCEPT,
NULL);
/* When something is selected then OK */
gtk_dialog_set_default_response ( GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT );
GtkWidget *response_w = NULL;
#if GTK_CHECK_VERSION (2, 20, 0)
/* Default to not apply - as initially nothing is selected! */
response_w = gtk_dialog_get_widget_for_response ( GTK_DIALOG(dialog), GTK_RESPONSE_REJECT );
#endif
GtkWidget *label = gtk_label_new ( msg );
GtkTreeStore *store;
if (multiple_selection_allowed)
{
store = gtk_tree_store_new(4, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
}
else
{
store = gtk_tree_store_new(3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
}
GList *geoname_runner = geonames;
while (geoname_runner)
{
geoname = (found_geoname *)geoname_runner->data;
latlon_string = g_strdup_printf("(%f,%f)", geoname->ll.lat, geoname->ll.lon);
gtk_tree_store_append(store, &iter, NULL);
if (multiple_selection_allowed)
{
gtk_tree_store_set(store, &iter, 0, FALSE, 1, geoname->name, 2, geoname->country, 3, latlon_string, -1);
}
else
{
gtk_tree_store_set(store, &iter, 0, geoname->name, 1, geoname->country, 2, latlon_string, -1);
}
geoname_runner = g_list_next(geoname_runner);
g_free(latlon_string);
}
view = gtk_tree_view_new();
renderer = gtk_cell_renderer_text_new();
column_runner = 0;
if (multiple_selection_allowed)
{
toggle_render = gtk_cell_renderer_toggle_new();
g_object_set(toggle_render, "activatable", TRUE, NULL);
g_signal_connect(toggle_render, "toggled", (GCallback) buttonToggled, GTK_TREE_MODEL(store));
gtk_tree_view_insert_column_with_attributes( GTK_TREE_VIEW(view), -1, "Select", toggle_render, "active", column_runner, NULL);
column_runner++;
}
gtk_tree_view_insert_column_with_attributes( GTK_TREE_VIEW(view), -1, "Name", renderer, "text", column_runner, NULL);
column_runner++;
gtk_tree_view_insert_column_with_attributes( GTK_TREE_VIEW(view), -1, "Country", renderer, "text", column_runner, NULL);
column_runner++;
gtk_tree_view_insert_column_with_attributes( GTK_TREE_VIEW(view), -1, "Lat/Lon", renderer, "text", column_runner, NULL);
gtk_tree_view_set_headers_visible( GTK_TREE_VIEW(view), TRUE);
gtk_tree_view_set_model(GTK_TREE_VIEW(view), GTK_TREE_MODEL(store));
gtk_tree_selection_set_mode( gtk_tree_view_get_selection(GTK_TREE_VIEW(view)),
multiple_selection_allowed ? GTK_SELECTION_MULTIPLE : GTK_SELECTION_BROWSE );
g_object_unref(store);
gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), label, FALSE, FALSE, 0);
gtk_widget_show ( label );
gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), view, FALSE, FALSE, 0);
gtk_widget_show ( view );
if ( response_w )
gtk_widget_grab_focus ( response_w );
while ( gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT )
{
GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
GList *selected_geonames = NULL;
gtk_tree_model_get_iter_first( GTK_TREE_MODEL(store), &iter);
geoname_runner = geonames;
while (geoname_runner)
{
to_copy = FALSE;
if (multiple_selection_allowed)
{
gtk_tree_model_get(GTK_TREE_MODEL(store), &iter, 0, &checked, -1);
if (checked) {
to_copy = TRUE;
}
}
else
{
if (gtk_tree_selection_iter_is_selected(selection, &iter))
{
to_copy = TRUE;
}
}
if (to_copy) {
found_geoname *copied = copy_found_geoname(geoname_runner->data);
selected_geonames = g_list_prepend(selected_geonames, copied);
}
geoname_runner = g_list_next(geoname_runner);
gtk_tree_model_iter_next(GTK_TREE_MODEL(store), &iter);
}
if (selected_geonames)
{
gtk_widget_destroy ( dialog );
return (selected_geonames);
}
a_dialog_error_msg(parent, _("Nothing was selected"));
}
gtk_widget_destroy ( dialog );
return NULL;
}
static void
dlg_delete__common (FrWindow *window,
GList *selected_files)
{
DialogData *data;
GtkWidget *content_area;
GtkWidget *delete_box;
GtkWidget *ok_button;
data = g_new (DialogData, 1);
data->window = window;
data->selected_files = selected_files;
data->builder = _gtk_builder_new_from_resource ("delete.ui");
if (data->builder == NULL) {
g_free (data);
return;
}
/* Get the widgets. */
data->dialog = g_object_new (GTK_TYPE_DIALOG,
"transient-for", GTK_WINDOW (window),
"modal", TRUE,
"use-header-bar", _gtk_settings_get_dialogs_use_header (),
NULL);
gtk_dialog_add_buttons (GTK_DIALOG (data->dialog),
_GTK_LABEL_CANCEL, GTK_RESPONSE_CANCEL,
_("_Delete"), GTK_RESPONSE_OK,
NULL);
ok_button = gtk_dialog_get_widget_for_response (GTK_DIALOG (data->dialog), GTK_RESPONSE_OK);
gtk_style_context_add_class (gtk_widget_get_style_context (ok_button), GTK_STYLE_CLASS_DESTRUCTIVE_ACTION);
delete_box = _gtk_builder_get_widget (data->builder, "delete_box");
data->d_all_files_radio = _gtk_builder_get_widget (data->builder, "d_all_files_radio");
data->d_selected_files_radio = _gtk_builder_get_widget (data->builder, "d_selected_files_radio");
data->d_files_radio = _gtk_builder_get_widget (data->builder, "d_files_radio");
data->d_files_entry = _gtk_builder_get_widget (data->builder, "d_files_entry");
content_area = gtk_dialog_get_content_area (GTK_DIALOG (data->dialog));
gtk_container_add (GTK_CONTAINER (content_area), delete_box);
/* Set widgets data. */
if (data->selected_files != NULL)
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (data->d_selected_files_radio), TRUE);
else {
gtk_widget_set_sensitive (data->d_selected_files_radio, FALSE);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (data->d_all_files_radio), TRUE);
}
/* Set the signals handlers. */
g_signal_connect (G_OBJECT (data->dialog),
"destroy",
G_CALLBACK (destroy_cb),
data);
g_signal_connect (G_OBJECT (data->dialog),
"response",
G_CALLBACK (response_cb),
data);
// g_signal_connect_swapped (G_OBJECT (cancel_button),
// "clicked",
// G_CALLBACK (gtk_widget_destroy),
// G_OBJECT (data->dialog));
// g_signal_connect (G_OBJECT (ok_button),
// "clicked",
// G_CALLBACK (ok_clicked_cb),
// data);
g_signal_connect (G_OBJECT (data->d_files_entry),
"changed",
G_CALLBACK (entry_changed_cb),
data);
/* Run dialog. */
gtk_widget_show (data->dialog);
}
void buildFindReplace(void)
{
GtkWidget* content_area;
GtkWidget* replace;
GtkWidget* image;
GtkWidget* label;
GtkWidget* vbox;
GtkWidget* hbox;
GtkWidget* item;
#ifdef _USEGTK3_
findReplaceDialog=gtk_dialog_new_with_buttons("Find/Replace",(GtkWindow*)window, GTK_DIALOG_DESTROY_WITH_PARENT,"Forward",FINDNEXT,"Back",FINDPREV,"Replace",REPLACE,NULL);
#else
findReplaceDialog=gtk_dialog_new_with_buttons("Find/Replace",(GtkWindow*)window, GTK_DIALOG_DESTROY_WITH_PARENT,GTK_STOCK_GO_FORWARD,FINDNEXT,GTK_STOCK_GO_BACK,FINDPREV,"Replace",REPLACE,NULL);
#endif
gtk_dialog_set_default_response((GtkDialog*)findReplaceDialog,GTK_RESPONSE_OK);
g_signal_connect(G_OBJECT(findReplaceDialog),"response",G_CALLBACK(doFindReplace),NULL);
content_area=gtk_dialog_get_content_area(GTK_DIALOG(findReplaceDialog));
vbox=creatNewBox(NEWVBOX,false,0);
hbox=creatNewBox(NEWVBOX,false,0);
label=gtk_label_new("Find");
gtk_container_add(GTK_CONTAINER(content_area),label);
gtk_widget_show(label);
findBox=gtk_entry_new();
gtk_entry_set_text((GtkEntry*)findBox,"");
gtk_entry_set_activates_default((GtkEntry*)findBox,true);
gtk_container_add(GTK_CONTAINER(content_area),findBox);
label=gtk_label_new("Replace With");
gtk_container_add(GTK_CONTAINER(content_area),label);
gtk_widget_show(label);
replaceBox=gtk_entry_new();
gtk_entry_set_text((GtkEntry*)replaceBox,"");
gtk_entry_set_activates_default((GtkEntry*)replaceBox,true);
gtk_container_add(GTK_CONTAINER(content_area),replaceBox);
item=gtk_check_button_new_with_label("Case insensitive");
gtk_toggle_button_set_active((GtkToggleButton*)item,insensitiveSearch);
gtk_box_pack_start(GTK_BOX(hbox),item,true,true,0);
gtk_widget_show(item);
g_signal_connect(G_OBJECT(item),"toggled",G_CALLBACK(doSearchPrefs),(void*)1);
item=gtk_check_button_new_with_label("Wrap");
gtk_toggle_button_set_active((GtkToggleButton*)item,wrapSearch);
gtk_box_pack_start(GTK_BOX(hbox),item,true,true,0);
gtk_widget_show(item);
g_signal_connect(G_OBJECT(item),"toggled",G_CALLBACK(doSearchPrefs),(void*)2);
item=gtk_check_button_new_with_label("Replace All");
gtk_toggle_button_set_active((GtkToggleButton*)item,replaceAll);
gtk_box_pack_start(GTK_BOX(hbox),item,true,true,0);
gtk_widget_show(item);
g_signal_connect(G_OBJECT(item),"toggled",G_CALLBACK(doSearchPrefs),(void*)3);
gtk_box_pack_start(GTK_BOX(vbox),hbox,true,true,0);
gtk_box_pack_start(GTK_BOX(content_area),vbox,true,true,0);
replace=gtk_dialog_get_widget_for_response((GtkDialog*)findReplaceDialog,100);
#ifndef _USEGTK3_
image=gtk_image_new_from_stock(GTK_STOCK_FIND_AND_REPLACE,GTK_ICON_SIZE_BUTTON);
gtk_button_set_image((GtkButton*)replace,image);
#endif
gtk_widget_show(findBox);
gtk_widget_show(replaceBox);
gtk_widget_show(vbox);
gtk_widget_show(hbox);
//TODO
// gtk_signal_connect_object(GTK_OBJECT(findReplaceDialog),"delete_event",GTK_SIGNAL_FUNC(gtk_widget_hide),GTK_OBJECT(findReplaceDialog));
// g_signal_connect(G_OBJECT(findReplaceDialog),"delete_event",GTK_SIGNAL_FUNC(gtk_true),NULL);
}
static void
ide_editor_view_actions_save (GSimpleAction *action,
GVariant *param,
gpointer user_data)
{
IdeEditorView *self = user_data;
IdeContext *context;
IdeBufferManager *buffer_manager;
IdeFile *file;
IdeProgress *progress = NULL;
IdeVcs *vcs;
GFile *workdir;
g_assert (IDE_IS_EDITOR_VIEW (self));
file = ide_buffer_get_file (IDE_BUFFER (self->document));
context = ide_buffer_get_context (IDE_BUFFER (self->document));
buffer_manager = ide_context_get_buffer_manager (context);
vcs = ide_context_get_vcs (context);
workdir = ide_vcs_get_working_directory (vcs);
if (ide_file_get_is_temporary (file))
{
GtkDialog *dialog;
GtkWidget *toplevel;
GtkWidget *suggested;
toplevel = gtk_widget_get_toplevel (GTK_WIDGET (self));
dialog = g_object_new (GTK_TYPE_FILE_CHOOSER_DIALOG,
"action", GTK_FILE_CHOOSER_ACTION_SAVE,
"do-overwrite-confirmation", TRUE,
"local-only", FALSE,
"modal", TRUE,
"select-multiple", FALSE,
"show-hidden", FALSE,
"transient-for", toplevel,
"title", _("Save Document"),
NULL);
gtk_file_chooser_set_current_folder_file (GTK_FILE_CHOOSER (dialog), workdir, NULL);
gtk_dialog_add_buttons (GTK_DIALOG (dialog),
_("Cancel"), GTK_RESPONSE_CANCEL,
_("Save"), GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
suggested = gtk_dialog_get_widget_for_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
gtk_style_context_add_class (gtk_widget_get_style_context (suggested),
GTK_STYLE_CLASS_SUGGESTED_ACTION);
g_signal_connect (dialog, "response", G_CALLBACK (save_temp_response), g_object_ref (self));
gtk_window_present (GTK_WINDOW (dialog));
return;
}
ide_buffer_manager_save_file_async (buffer_manager,
IDE_BUFFER (self->document),
file,
&progress,
NULL,
save_file_cb,
g_object_ref (self));
g_object_bind_property (progress, "fraction", self->progress_bar, "fraction",
G_BINDING_SYNC_CREATE);
gtk_widget_show (GTK_WIDGET (self->progress_bar));
g_clear_object (&progress);
}
gint a_uibuilder_properties_factory ( const gchar *dialog_name, GtkWindow *parent, VikLayerParam *params,
guint16 params_count, gchar **groups, guint8 groups_count,
gboolean (*setparam) (gpointer,guint16,VikLayerParamData,gpointer,gboolean),
gpointer pass_along1, gpointer pass_along2,
VikLayerParamData (*getparam) (gpointer,guint16,gboolean),
gpointer pass_along_getparam )
/* pass_along1 and pass_along2 are for set_param first and last params */
{
guint16 i, j, widget_count = 0;
gboolean must_redraw = FALSE;
if ( ! params )
return 1; /* no params == no options, so all is good */
for ( i = 0; i < params_count; i++ )
if ( params[i].group != VIK_LAYER_NOT_IN_PROPERTIES )
widget_count++;
if ( widget_count == 0)
return 0; /* TODO -- should be one? */
else
{
/* create widgets and titles; place in table */
GtkWidget *dialog = gtk_dialog_new_with_buttons ( dialog_name,
parent,
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT,
GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, 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
gint resp;
GtkWidget *table = NULL;
GtkWidget **tables = NULL; /* for more than one group */
GtkWidget *notebook = NULL;
GtkWidget **widgets = g_malloc ( sizeof(GtkWidget *) * widget_count );
if ( groups && groups_count > 1 )
{
guint8 current_group;
guint16 tab_widget_count;
notebook = gtk_notebook_new ();
// Switch to vertical notebook mode when many groups
if ( groups_count > 4 )
gtk_notebook_set_tab_pos ( GTK_NOTEBOOK(notebook), GTK_POS_LEFT );
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), notebook, FALSE, FALSE, 0);
tables = g_malloc ( sizeof(GtkWidget *) * groups_count );
for ( current_group = 0; current_group < groups_count; current_group++ )
{
tab_widget_count = 0;
for ( j = 0; j < params_count; j ++ )
if ( params[j].group == current_group )
tab_widget_count++;
if ( tab_widget_count )
{
tables[current_group] = gtk_table_new ( tab_widget_count, 1, FALSE );
gtk_notebook_append_page ( GTK_NOTEBOOK(notebook), tables[current_group], gtk_label_new(groups[current_group]) );
}
}
}
else
{
table = gtk_table_new( widget_count, 1, FALSE );
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), table, FALSE, FALSE, 0);
}
for ( i = 0, j = 0; i < params_count; i++ )
{
if ( params[i].group != VIK_LAYER_NOT_IN_PROPERTIES )
{
if ( tables )
table = tables[MAX(0, params[i].group)]; /* round up NOT_IN_GROUP, that's not reasonable here */
widgets[j] = a_uibuilder_new_widget ( &(params[i]), getparam ( pass_along_getparam, i, FALSE ) );
if ( widgets[j] ) {
gtk_table_attach ( GTK_TABLE(table), gtk_label_new(_(params[i].title)), 0, 1, j, j+1, 0, 0, 0, 0 );
gtk_table_attach ( GTK_TABLE(table), widgets[j], 1, 2, j, j+1, GTK_EXPAND | GTK_FILL, 0, 2, 2 );
}
j++;
}
}
if ( response_w )
gtk_widget_grab_focus ( response_w );
gtk_widget_show_all ( dialog );
resp = gtk_dialog_run (GTK_DIALOG (dialog));
if ( resp == GTK_RESPONSE_ACCEPT )
{
for ( i = 0, j = 0; i < params_count; i++ )
{
if ( params[i].group != VIK_LAYER_NOT_IN_PROPERTIES )
{
if ( setparam ( pass_along1,
i,
a_uibuilder_widget_get_value ( widgets[j], &(params[i]) ),
pass_along2,
FALSE ) )
must_redraw = TRUE;
j++;
}
}
gtk_widget_destroy ( dialog ); /* hide before redrawing. */
g_free ( widgets );
if ( tables )
g_free ( tables );
return must_redraw ? 2 : 3; /* user clicked OK */
}
if ( tables )
g_free ( tables );
gtk_widget_destroy ( dialog );
g_free ( widgets );
return 0;
}
}
/**
* vik_datetime_edit_dialog:
* @parent: The parent window
* @title: The title to use for the dialog
* @initial_time: The inital date/time to be shown
* @tz: The #GTimeZone this dialog will operate in
*
* Returns: A time selected by the user via this dialog
* Even though a time of zero is notionally valid - consider it unlikely to be actually wanted!
* Thus if the time is zero then the dialog was cancelled or somehow an invalid date was encountered.
*/
time_t vik_datetime_edit_dialog ( GtkWindow *parent, const gchar *title, time_t initial_time, GTimeZone *tz )
{
g_return_val_if_fail ( tz, 0 );
GtkWidget *dialog = gtk_dialog_new_with_buttons ( title,
parent,
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT,
GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
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 *label;
GtkWidget *cal = gtk_calendar_new ();
// Set according to the given date/time + timezone for display
GDateTime *gdt_in = g_date_time_new_from_unix_utc ( (gint64)initial_time );
GDateTime *gdt_tz = g_date_time_to_timezone ( gdt_in, tz );
g_date_time_unref ( gdt_in );
gtk_calendar_select_month ( GTK_CALENDAR(cal), g_date_time_get_month(gdt_tz)-1, g_date_time_get_year (gdt_tz) );
gtk_calendar_select_day ( GTK_CALENDAR(cal), g_date_time_get_day_of_month(gdt_tz) );
GtkWidget *hbox_time = gtk_hbox_new ( FALSE, 1 );
label = gtk_label_new ( g_date_time_get_timezone_abbreviation(gdt_tz) );
gtk_box_pack_start ( GTK_BOX(hbox_time), label, FALSE, FALSE, 5 );
GtkWidget *sb_hours = gtk_spin_button_new_with_range ( 0.0, 23.0, 1.0 );
gtk_box_pack_start ( GTK_BOX(hbox_time), sb_hours, FALSE, FALSE, 0 );
gtk_spin_button_set_value ( GTK_SPIN_BUTTON(sb_hours), g_date_time_get_hour(gdt_tz) );
g_signal_connect ( sb_hours, "output", G_CALLBACK(on_output), NULL );
label = gtk_label_new ( ":" );
gtk_box_pack_start ( GTK_BOX(hbox_time), label, FALSE, FALSE, 0 );
GtkWidget *sb_minutes = gtk_spin_button_new_with_range ( 0.0, 59.0, 1.0 );
gtk_box_pack_start ( GTK_BOX(hbox_time), sb_minutes, FALSE, FALSE, 0);
gtk_spin_button_set_value ( GTK_SPIN_BUTTON(sb_minutes), g_date_time_get_minute(gdt_tz) );
g_signal_connect ( sb_minutes, "output", G_CALLBACK(on_output), NULL );
label = gtk_label_new ( ":" );
gtk_box_pack_start(GTK_BOX(hbox_time), label, FALSE, FALSE, 0);
GtkWidget *sb_seconds = gtk_spin_button_new_with_range ( 0.0, 59.0, 1.0 );
gtk_box_pack_start ( GTK_BOX(hbox_time), sb_seconds, FALSE, FALSE, 0 );
gtk_spin_button_set_value ( GTK_SPIN_BUTTON(sb_seconds), g_date_time_get_second(gdt_tz) );
g_signal_connect ( sb_seconds, "output", G_CALLBACK(on_output), NULL );
gtk_box_pack_start ( GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), cal, FALSE, FALSE, 0 );
gtk_box_pack_start ( GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), hbox_time, FALSE, FALSE, 5 );
if ( response_w )
gtk_widget_grab_focus ( response_w );
g_date_time_unref ( gdt_tz );
gtk_widget_show_all ( dialog );
if ( gtk_dialog_run ( GTK_DIALOG(dialog) ) != GTK_RESPONSE_ACCEPT ) {
gtk_widget_destroy ( dialog );
return 0;
}
// Read values
guint year = 0;
guint month = 0;
guint day = 0;
guint hours = 0;
guint minutes = 0;
guint seconds = 0;
gtk_calendar_get_date ( GTK_CALENDAR(cal), &year, &month, &day );
hours = gtk_spin_button_get_value_as_int ( GTK_SPIN_BUTTON(sb_hours) );
minutes = gtk_spin_button_get_value_as_int ( GTK_SPIN_BUTTON(sb_minutes) );
seconds = gtk_spin_button_get_value_as_int ( GTK_SPIN_BUTTON(sb_seconds) );
gtk_widget_destroy(dialog);
time_t ans = initial_time;
GDateTime *gdt_ans = g_date_time_new ( tz, year, month+1, day, hours, minutes, (gdouble)seconds );
if ( gdt_ans ) {
ans = g_date_time_to_unix ( gdt_ans );
g_date_time_unref ( gdt_ans );
}
return ans;
}
int
DialogExecute(GtkWidget *parent, void *dialog)
{
GtkWidget *dlg, *win_ptr, *btn;
struct DialogType *data;
gint res_id, lockstate;
lockstate = DnDLock;
DnDLock = TRUE;
data = (struct DialogType *) dialog;
if (data->widget && (data->parent != parent)) {
#if 1
gtk_window_set_transient_for(GTK_WINDOW(data->widget), GTK_WINDOW(parent));
data->parent = parent;
#else
gtk_widget_destroy(data->widget);
reset_event();
data->widget = NULL;
#endif
}
if (data->widget == NULL) {
dlg = gtk_dialog_new_with_buttons(_(data->resource),
GTK_WINDOW(parent),
#if GTK_CHECK_VERSION(3, 12, 0) && USE_HEADER_BAR
GTK_DIALOG_USE_HEADER_BAR |
#endif
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
_("_Cancel"), GTK_RESPONSE_CANCEL,
NULL);
gtk_window_set_resizable(GTK_WINDOW(dlg), TRUE);
g_signal_connect(dlg, "delete-event", G_CALLBACK(dialog_delete_cb), data);
g_signal_connect(dlg, "destroy", G_CALLBACK(dialog_destroyed_cb), data);
g_signal_connect(dlg, "key-press-event", G_CALLBACK(dialog_key_down_cb), NULL);
data->parent = parent;
data->widget = dlg;
data->vbox = GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dlg)));
data->show_cancel = TRUE;
data->ok_button = _("_OK");
gtk_window_set_title(GTK_WINDOW(dlg), _(data->resource));
data->SetupWindow(dlg, data, TRUE);
gtk_dialog_add_button(GTK_DIALOG(dlg), data->ok_button, GTK_RESPONSE_OK);
if (! data->show_cancel) {
btn = gtk_dialog_get_widget_for_response(GTK_DIALOG(dlg), GTK_RESPONSE_CANCEL);
gtk_widget_hide(btn);
}
gtk_dialog_set_default_response(GTK_DIALOG(dlg), GTK_RESPONSE_OK);
} else {
dlg = data->widget;
data->SetupWindow(dlg, data, FALSE);
}
gtk_widget_hide(dlg);
gtk_dialog_set_default_response(GTK_DIALOG(dlg), GTK_RESPONSE_OK);
data->widget = dlg;
data->ret = IDLOOP;
gtk_widget_show(dlg);
win_ptr = get_current_window();
set_current_window(dlg);
if (data->focus)
gtk_widget_grab_focus(data->focus);
while (data->ret == IDLOOP) {
res_id = ndialog_run(dlg);
if (res_id < 0) {
switch (res_id) {
case GTK_RESPONSE_OK:
data->ret = IDOK;
break;
default:
data->ret = IDCANCEL;
break;
}
} else {
data->ret = res_id;
}
if (data->CloseWindow) {
data->CloseWindow(dlg, data);
}
}
// gtk_widget_destroy(dlg);
// data->widget = NULL;
set_current_window(win_ptr);
gtk_widget_hide(dlg);
reset_event();
DnDLock = lockstate;
return data->ret;
}
static GList *select_from_list (GtkWindow *parent, GList *list, const gchar *title, const gchar *msg )
{
GtkTreeIter iter;
GtkCellRenderer *renderer;
GtkWidget *view;
gchar *latlon_string;
int column_runner;
GtkWidget *dialog = gtk_dialog_new_with_buttons (title,
parent,
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CANCEL,
GTK_RESPONSE_REJECT,
GTK_STOCK_OK,
GTK_RESPONSE_ACCEPT,
NULL);
/* When something is selected then OK */
gtk_dialog_set_default_response ( GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT );
GtkWidget *response_w = NULL;
#if GTK_CHECK_VERSION (2, 20, 0)
/* Default to not apply - as initially nothing is selected! */
response_w = gtk_dialog_get_widget_for_response ( GTK_DIALOG(dialog), GTK_RESPONSE_REJECT );
#endif
GtkWidget *label = gtk_label_new ( msg );
GtkTreeStore *store = gtk_tree_store_new ( 6, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_BOOLEAN );
GList *list_runner = list;
while (list_runner) {
gpx_meta_data_t *gpx_meta_data = (gpx_meta_data_t *)list_runner->data;
// To keep display compact three digits of precision for lat/lon should be plenty
latlon_string = g_strdup_printf("(%.3f,%.3f)", gpx_meta_data->ll.lat, gpx_meta_data->ll.lon);
gtk_tree_store_append(store, &iter, NULL);
gtk_tree_store_set ( store, &iter,
0, gpx_meta_data->name,
1, gpx_meta_data->desc,
2, gpx_meta_data->timestamp,
3, latlon_string,
4, gpx_meta_data->vis,
5, gpx_meta_data->in_current_view,
-1 );
list_runner = g_list_next ( list_runner );
g_free ( latlon_string );
}
view = gtk_tree_view_new();
renderer = gtk_cell_renderer_text_new();
column_runner = 0;
GtkTreeViewColumn *column;
column = gtk_tree_view_column_new_with_attributes ( _("Name"), renderer, "text", column_runner, NULL);
gtk_tree_view_column_set_sort_column_id (column, column_runner);
gtk_tree_view_append_column (GTK_TREE_VIEW (view), column);
column_runner++;
column = gtk_tree_view_column_new_with_attributes ( _("Description"), renderer, "text", column_runner, NULL);
gtk_tree_view_column_set_sort_column_id (column, column_runner);
gtk_tree_view_append_column (GTK_TREE_VIEW (view), column);
column_runner++;
column = gtk_tree_view_column_new_with_attributes ( _("Time"), renderer, "text", column_runner, NULL);
gtk_tree_view_column_set_sort_column_id (column, column_runner);
gtk_tree_view_append_column (GTK_TREE_VIEW (view), column);
column_runner++;
column = gtk_tree_view_column_new_with_attributes ( _("Lat/Lon"), renderer, "text", column_runner, NULL);
gtk_tree_view_column_set_sort_column_id (column, column_runner);
gtk_tree_view_append_column (GTK_TREE_VIEW (view), column);
column_runner++;
column = gtk_tree_view_column_new_with_attributes ( _("Privacy"), renderer, "text", column_runner, NULL); // AKA Visibility
gtk_tree_view_column_set_sort_column_id (column, column_runner);
gtk_tree_view_append_column (GTK_TREE_VIEW (view), column);
GtkCellRenderer *renderer_toggle = gtk_cell_renderer_toggle_new ();
g_object_set (G_OBJECT (renderer_toggle), "activatable", FALSE, NULL); // No user action - value is just for display
column_runner++;
column = gtk_tree_view_column_new_with_attributes ( _("Within Current View"), renderer_toggle, "active", column_runner, NULL);
gtk_tree_view_column_set_sort_column_id (column, column_runner);
gtk_tree_view_append_column (GTK_TREE_VIEW (view), column);
gtk_tree_view_set_model(GTK_TREE_VIEW(view), GTK_TREE_MODEL(store));
gtk_tree_selection_set_mode( gtk_tree_view_get_selection(GTK_TREE_VIEW(view)), GTK_SELECTION_MULTIPLE );
g_object_unref(store);
GtkWidget *scrolledwindow = gtk_scrolled_window_new ( NULL, NULL );
gtk_scrolled_window_set_policy ( GTK_SCROLLED_WINDOW(scrolledwindow), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC );
gtk_container_add ( GTK_CONTAINER(scrolledwindow), view );
gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), label, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), scrolledwindow, TRUE, TRUE, 0);
// Ensure a reasonable number of items are shown, but let the width be automatically sized
gtk_widget_set_size_request ( dialog, -1, 400) ;
gtk_widget_show_all ( dialog );
if ( response_w )
gtk_widget_grab_focus ( response_w );
while ( gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT ) {
// Possibily not the fastest method but we don't have thousands of entries to process...
GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
GList *selected = NULL;
// because we don't store the full data in the gtk model, we have to scan & look it up
if ( gtk_tree_model_get_iter_first( GTK_TREE_MODEL(store), &iter) ) {
do {
if ( gtk_tree_selection_iter_is_selected ( selection, &iter ) ) {
// For every selected item,
// compare the name from the displayed view to every gpx entry to find the gpx this selection represents
gchar* name;
gtk_tree_model_get (GTK_TREE_MODEL(store), &iter, 0, &name, -1 );
// I believe the name of these items to be always unique
list_runner = list;
while (list_runner) {
if ( !strcmp ( ((gpx_meta_data_t*)list_runner->data)->name, name ) ) {
gpx_meta_data_t *copied = copy_gpx_meta_data_t (list_runner->data);
selected = g_list_prepend (selected, copied);
break;
}
list_runner = g_list_next ( list_runner );
}
}
}
while ( gtk_tree_model_iter_next ( GTK_TREE_MODEL(store), &iter ) );
}
if ( selected ) {
gtk_widget_destroy ( dialog );
return selected;
}
a_dialog_error_msg(parent, _("Nothing was selected"));
}
gtk_widget_destroy ( dialog );
return NULL;
}
VikTrwLayerTpwin *vik_trw_layer_tpwin_new ( GtkWindow *parent )
{
static gchar *left_label_texts[] = { N_("<b>Name:</b>"),
N_("<b>Latitude:</b>"),
N_("<b>Longitude:</b>"),
N_("<b>Altitude:</b>"),
N_("<b>Course:</b>"),
N_("<b>Timestamp:</b>"),
N_("<b>Time:</b>") };
static gchar *right_label_texts[] = { N_("<b>Distance Difference:</b>"),
N_("<b>Time Difference:</b>"),
N_("<b>\"Speed\" Between:</b>"),
N_("<b>Speed:</b>"),
N_("<b>VDOP:</b>"),
N_("<b>HDOP:</b>"),
N_("<b>PDOP:</b>"),
N_("<b>SAT/FIX:</b>") };
VikTrwLayerTpwin *tpwin = VIK_TRW_LAYER_TPWIN ( g_object_new ( VIK_TRW_LAYER_TPWIN_TYPE, NULL ) );
GtkWidget *main_hbox, *left_vbox, *right_vbox;
GtkWidget *diff_left_vbox, *diff_right_vbox;
gtk_window_set_transient_for ( GTK_WINDOW(tpwin), parent );
gtk_window_set_title ( GTK_WINDOW(tpwin), _("Trackpoint") );
tpwin->button_close = gtk_dialog_add_button ( GTK_DIALOG(tpwin), GTK_STOCK_CLOSE, VIK_TRW_LAYER_TPWIN_CLOSE);
tpwin->button_insert = gtk_dialog_add_button ( GTK_DIALOG(tpwin), _("_Insert After"), VIK_TRW_LAYER_TPWIN_INSERT);
tpwin->button_delete = gtk_dialog_add_button ( GTK_DIALOG(tpwin), GTK_STOCK_DELETE, VIK_TRW_LAYER_TPWIN_DELETE);
tpwin->button_split = gtk_dialog_add_button ( GTK_DIALOG(tpwin), _("Split Here"), VIK_TRW_LAYER_TPWIN_SPLIT);
tpwin->button_back = gtk_dialog_add_button ( GTK_DIALOG(tpwin), GTK_STOCK_GO_BACK, VIK_TRW_LAYER_TPWIN_BACK);
tpwin->button_forward = gtk_dialog_add_button ( GTK_DIALOG(tpwin), GTK_STOCK_GO_FORWARD, VIK_TRW_LAYER_TPWIN_FORWARD);
/*
gtk_dialog_add_buttons ( GTK_DIALOG(tpwin),
GTK_STOCK_CLOSE, VIK_TRW_LAYER_TPWIN_CLOSE,
_("_Insert After"), VIK_TRW_LAYER_TPWIN_INSERT,
GTK_STOCK_DELETE, VIK_TRW_LAYER_TPWIN_DELETE,
_("Split Here"), VIK_TRW_LAYER_TPWIN_SPLIT,
GTK_STOCK_GO_BACK, VIK_TRW_LAYER_TPWIN_BACK,
GTK_STOCK_GO_FORWARD, VIK_TRW_LAYER_TPWIN_FORWARD,
NULL );
tpwin->buttons = gtk_container_get_children(GTK_CONTAINER(GTK_DIALOG(tpwin)->action_area));
*/
/* main track info */
left_vbox = a_dialog_create_label_vbox ( left_label_texts, G_N_ELEMENTS(left_label_texts), 1, 3 );
tpwin->trkpt_name = gtk_entry_new();
g_signal_connect_swapped ( G_OBJECT(tpwin->trkpt_name), "focus-out-event", G_CALLBACK(tpwin_set_name), tpwin );
tpwin->course = GTK_LABEL(ui_label_new_selectable(NULL));
tpwin->time = gtk_button_new();
gtk_button_set_relief ( GTK_BUTTON(tpwin->time), GTK_RELIEF_NONE );
g_signal_connect ( G_OBJECT(tpwin->time), "button-release-event", G_CALLBACK(tpwin_sync_time_to_tp), tpwin );
tpwin->lat = GTK_SPIN_BUTTON(gtk_spin_button_new( GTK_ADJUSTMENT(gtk_adjustment_new (
0, -90, 90, 0.00005, 0.01, 0 )), 0.00005, 6));
tpwin->lon = GTK_SPIN_BUTTON(gtk_spin_button_new( GTK_ADJUSTMENT(gtk_adjustment_new (
0, -180, 180, 0.00005, 0.01, 0 )), 0.00005, 6));
g_signal_connect_swapped ( G_OBJECT(tpwin->lat), "value-changed", G_CALLBACK(tpwin_sync_ll_to_tp), tpwin );
g_signal_connect_swapped ( G_OBJECT(tpwin->lon), "value-changed", G_CALLBACK(tpwin_sync_ll_to_tp), tpwin );
tpwin->alt = GTK_SPIN_BUTTON(gtk_spin_button_new( GTK_ADJUSTMENT(gtk_adjustment_new (
0, -1000, 25000, 10, 100, 0 )), 10, 2));
g_signal_connect_swapped ( G_OBJECT(tpwin->alt), "value-changed", G_CALLBACK(tpwin_sync_alt_to_tp), tpwin );
tpwin->ts = GTK_SPIN_BUTTON(gtk_spin_button_new_with_range(0,2147483647,1)); //pow(2,31)-1 limit input to ~2038 for now
g_signal_connect_swapped ( G_OBJECT(tpwin->ts), "value-changed", G_CALLBACK(tpwin_sync_ts_to_tp), tpwin );
gtk_spin_button_set_digits ( tpwin->ts, 0 );
right_vbox = gtk_vbox_new ( TRUE, 1 );
gtk_box_pack_start ( GTK_BOX(right_vbox), GTK_WIDGET(tpwin->trkpt_name), FALSE, FALSE, 3 );
gtk_box_pack_start ( GTK_BOX(right_vbox), GTK_WIDGET(tpwin->lat), FALSE, FALSE, 3 );
gtk_box_pack_start ( GTK_BOX(right_vbox), GTK_WIDGET(tpwin->lon), FALSE, FALSE, 3 );
gtk_box_pack_start ( GTK_BOX(right_vbox), GTK_WIDGET(tpwin->alt), FALSE, FALSE, 3 );
gtk_box_pack_start ( GTK_BOX(right_vbox), GTK_WIDGET(tpwin->course), FALSE, FALSE, 3 );
gtk_box_pack_start ( GTK_BOX(right_vbox), GTK_WIDGET(tpwin->ts), FALSE, FALSE, 3 );
gtk_box_pack_start ( GTK_BOX(right_vbox), GTK_WIDGET(tpwin->time), FALSE, FALSE, 3 );
/* diff info */
diff_left_vbox = a_dialog_create_label_vbox ( right_label_texts, G_N_ELEMENTS(right_label_texts), 1, 3 );
tpwin->diff_dist = GTK_LABEL(ui_label_new_selectable(NULL));
tpwin->diff_time = GTK_LABEL(ui_label_new_selectable(NULL));
tpwin->diff_speed = GTK_LABEL(ui_label_new_selectable(NULL));
tpwin->speed = GTK_LABEL(ui_label_new_selectable(NULL));
tpwin->vdop = GTK_LABEL(ui_label_new_selectable(NULL));
tpwin->hdop = GTK_LABEL(ui_label_new_selectable(NULL));
tpwin->pdop = GTK_LABEL(ui_label_new_selectable(NULL));
tpwin->sat = GTK_LABEL(ui_label_new_selectable(NULL));
diff_right_vbox = gtk_vbox_new ( TRUE, 1 );
gtk_box_pack_start ( GTK_BOX(diff_right_vbox), GTK_WIDGET(tpwin->diff_dist), FALSE, FALSE, 3 );
gtk_box_pack_start ( GTK_BOX(diff_right_vbox), GTK_WIDGET(tpwin->diff_time), FALSE, FALSE, 3 );
gtk_box_pack_start ( GTK_BOX(diff_right_vbox), GTK_WIDGET(tpwin->diff_speed), FALSE, FALSE, 3 );
gtk_box_pack_start ( GTK_BOX(diff_right_vbox), GTK_WIDGET(tpwin->speed), FALSE, FALSE, 3 );
gtk_box_pack_start ( GTK_BOX(diff_right_vbox), GTK_WIDGET(tpwin->vdop), FALSE, FALSE, 3 );
gtk_box_pack_start ( GTK_BOX(diff_right_vbox), GTK_WIDGET(tpwin->hdop), FALSE, FALSE, 3 );
gtk_box_pack_start ( GTK_BOX(diff_right_vbox), GTK_WIDGET(tpwin->pdop), FALSE, FALSE, 3 );
gtk_box_pack_start ( GTK_BOX(diff_right_vbox), GTK_WIDGET(tpwin->sat), FALSE, FALSE, 3 );
main_hbox = gtk_hbox_new( FALSE, 0 );
gtk_box_pack_start ( GTK_BOX(main_hbox), left_vbox, TRUE, TRUE, 3 );
gtk_box_pack_start ( GTK_BOX(main_hbox), right_vbox, TRUE, TRUE, 0 );
gtk_box_pack_start ( GTK_BOX(main_hbox), diff_left_vbox, TRUE, TRUE, 0 );
gtk_box_pack_start ( GTK_BOX(main_hbox), diff_right_vbox, TRUE, TRUE, 0 );
gtk_box_pack_start ( GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(tpwin))), main_hbox, FALSE, FALSE, 0 );
tpwin->cur_tp = NULL;
GtkWidget *response_w = NULL;
#if GTK_CHECK_VERSION (2, 20, 0)
response_w = gtk_dialog_get_widget_for_response ( GTK_DIALOG(tpwin), VIK_TRW_LAYER_TPWIN_CLOSE );
#endif
if ( response_w )
gtk_widget_grab_focus ( response_w );
return tpwin;
}
