void DisplayDialog()
{
GtkWidget *dialog;
int return_value;
GtkWidget *msg_box, *log_box, *dump_box, *main_box;
GtkWidget *msg_frame, *log_frame, *dump_frame, *main_frame;
GtkWidget *msg_console_check, *msg_key_check, *msg_voice_check, *msg_dma_check;
GtkWidget *msg_autodma_check, *msg_overrun_check, *msg_cache_check;
GtkWidget *log_access_check, *log_dma_check, *log_wave_check;
GtkWidget *dump_core_check, *dump_mem_check, *dump_reg_check;
ReadSettings();
// Create the widgets
dialog = gtk_dialog_new_with_buttons (
"Spu2-X Config",
NULL, // parent window
(GtkDialogFlags)(GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT),
"OK", GTK_RESPONSE_ACCEPT,
"Cancel", GTK_RESPONSE_REJECT,
NULL);
main_box = gtk_hbox_new(false, 5);
main_frame = gtk_frame_new ("Spu2-X Config");
gtk_container_add (GTK_CONTAINER(main_frame), main_box);
// Message Section
msg_box = gtk_vbox_new(false, 5);
msg_console_check = gtk_check_button_new_with_label("Show In Console");
msg_key_check = gtk_check_button_new_with_label("KeyOn/Off Events");
msg_voice_check = gtk_check_button_new_with_label("Voice Stop Events");
msg_dma_check = gtk_check_button_new_with_label("DMA Operations");
msg_autodma_check = gtk_check_button_new_with_label("AutoDMA Operations");
msg_overrun_check = gtk_check_button_new_with_label("Buffer Over/Underruns");
msg_cache_check = gtk_check_button_new_with_label("ADPCM Cache Statistics");
gtk_container_add(GTK_CONTAINER(msg_box), msg_console_check);
gtk_container_add(GTK_CONTAINER(msg_box), msg_key_check);
gtk_container_add(GTK_CONTAINER(msg_box), msg_voice_check);
gtk_container_add(GTK_CONTAINER(msg_box), msg_dma_check);
gtk_container_add(GTK_CONTAINER(msg_box), msg_autodma_check);
gtk_container_add(GTK_CONTAINER(msg_box), msg_overrun_check);
gtk_container_add(GTK_CONTAINER(msg_box), msg_cache_check);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(msg_console_check), _MsgToConsole);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(msg_key_check), _MsgKeyOnOff);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(msg_voice_check), _MsgVoiceOff);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(msg_dma_check), _MsgDMA);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(msg_autodma_check), _MsgAutoDMA);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(msg_overrun_check), _MsgOverruns);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(msg_cache_check), _MsgCache);
msg_frame = gtk_frame_new ("Message/Log Options");
gtk_container_add (GTK_CONTAINER(msg_frame), msg_box);
// Log Section
log_box = gtk_vbox_new(false, 5);
log_access_check = gtk_check_button_new_with_label("Log Register/DMA Actions");
log_dma_check = gtk_check_button_new_with_label("Log DMA Writes");
log_wave_check = gtk_check_button_new_with_label("Log Audio Output");
gtk_container_add(GTK_CONTAINER(log_box), log_access_check);
gtk_container_add(GTK_CONTAINER(log_box), log_dma_check);
gtk_container_add(GTK_CONTAINER(log_box), log_wave_check);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(log_access_check), _AccessLog);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(log_dma_check), _DMALog);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(log_wave_check), _WaveLog);
log_frame = gtk_frame_new ("Log Options");
gtk_container_add (GTK_CONTAINER(log_frame), log_box);
// Dump Section
dump_box = gtk_vbox_new(false, 5);
dump_core_check = gtk_check_button_new_with_label("Dump Core and Voice State");
dump_mem_check = gtk_check_button_new_with_label("Dump Memory Contents");
dump_reg_check = gtk_check_button_new_with_label("Dump Register Data");
gtk_container_add(GTK_CONTAINER(dump_box), dump_core_check);
gtk_container_add(GTK_CONTAINER(dump_box), dump_mem_check);
gtk_container_add(GTK_CONTAINER(dump_box), dump_reg_check);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dump_core_check), _CoresDump);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dump_mem_check), _MemDump);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dump_reg_check), _RegDump);
dump_frame = gtk_frame_new ("Dumps (on close)");
gtk_container_add (GTK_CONTAINER(dump_frame), dump_box);
// Add everything
gtk_container_add (GTK_CONTAINER(main_box), msg_frame);
gtk_container_add (GTK_CONTAINER(main_box), log_frame);
gtk_container_add (GTK_CONTAINER(main_box), dump_frame);
// Add all our widgets, and show everything we've added to the dialog.
gtk_container_add (GTK_CONTAINER(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), main_frame);
gtk_widget_show_all (dialog);
return_value = gtk_dialog_run (GTK_DIALOG (dialog));
if (return_value == GTK_RESPONSE_ACCEPT)
{
_MsgToConsole = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(msg_console_check));
_MsgKeyOnOff = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(msg_key_check));
_MsgVoiceOff = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(msg_voice_check));
_MsgDMA = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(msg_dma_check));
_MsgAutoDMA = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(msg_autodma_check));
_MsgOverruns = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(msg_overrun_check));
_MsgCache = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(msg_cache_check));
_AccessLog = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(log_access_check));
_DMALog = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(log_dma_check));
_WaveLog = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(log_wave_check));
_CoresDump = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dump_core_check));
_MemDump = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dump_mem_check));
_RegDump = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dump_reg_check));
}
gtk_widget_destroy (dialog);
WriteSettings();
}
gboolean kanji_list_view (GArray *arr)
{
GtkWidget *dialog;
GtkWidget *treeview;
GtkWidget *scrolled_win;
GtkWidget *hbox;
GtkListStore *store;
GtkTreeIter iter;
guint i, result;
Kanji *tmp;
Data p;
dialog = gtk_dialog_new_with_buttons ("Kanji List", NULL, GTK_DIALOG_MODAL, NULL);
gtk_container_set_border_width (GTK_CONTAINER (dialog), 5);
gtk_widget_set_size_request (GTK_WIDGET (dialog), 500, 500);
treeview = gtk_tree_view_new ();
setup_tree_view (treeview, &p);
store = gtk_list_store_new (COLUMNS, G_TYPE_INT, G_TYPE_STRING, G_TYPE_INT, G_TYPE_STRING, G_TYPE_INT, G_TYPE_INT, G_TYPE_INT);
tmp = &g_array_index (arr, Kanji, i = 0);
while (i < arr->len)
{
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter, NUMBER, i + 1,
KANJI, tmp->kanji,
KANJI_STROKE, tmp->kanji_stroke,
RADICAL, tmp->radical,
RADICAL_STROKE, tmp->radical_stroke,
JLPT_LEVEL, tmp->jlpt_level,
SCHOOL_GRADE, tmp->grade, -1);
tmp = &g_array_index (arr, Kanji, ++i);
}
gtk_tree_view_set_model (GTK_TREE_VIEW (treeview), GTK_TREE_MODEL (store));
g_object_unref (store);
g_signal_connect (G_OBJECT (treeview), "row-activated", G_CALLBACK (row_activated), (gpointer)arr);
scrolled_win = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_container_add (GTK_CONTAINER (scrolled_win), treeview);
p.arr = arr;
p.tview = treeview;
p.changed = FALSE;
GtkWidget *add_button = gtk_button_new_from_stock (GTK_STOCK_ADD);
GtkWidget *remove_button = gtk_button_new_from_stock (GTK_STOCK_REMOVE);
GtkWidget *edit_button = gtk_button_new_from_stock (GTK_STOCK_EDIT);
GtkWidget *save_button = gtk_button_new_from_stock (GTK_STOCK_SAVE);
GtkWidget *close_button = gtk_button_new_from_stock (GTK_STOCK_CLOSE);
g_signal_connect (G_OBJECT (add_button), "clicked", G_CALLBACK (row_add), (gpointer) &p);
g_signal_connect (G_OBJECT (remove_button), "clicked", G_CALLBACK (row_remove), (gpointer) &p);
g_signal_connect (G_OBJECT (edit_button), "clicked", G_CALLBACK (row_edit), (gpointer) &p);
g_signal_connect (G_OBJECT (save_button), "clicked", G_CALLBACK (save_dict), (gpointer) &p);
g_signal_connect (G_OBJECT (close_button), "clicked", G_CALLBACK (close_dialog), (gpointer) dialog);
hbox = gtk_hbox_new (FALSE, 5);
gtk_box_pack_start (GTK_BOX (hbox), add_button, FALSE, FALSE, 5);
gtk_box_pack_start (GTK_BOX (hbox), remove_button, FALSE, FALSE, 5);
gtk_box_pack_start (GTK_BOX (hbox), edit_button, FALSE, FALSE, 5);
gtk_box_pack_start (GTK_BOX (hbox), save_button, FALSE, FALSE, 5);
gtk_box_pack_start (GTK_BOX (hbox), close_button, FALSE, FALSE, 5);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), scrolled_win, TRUE, TRUE, 5);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), hbox, FALSE, FALSE, 5);
gtk_tree_view_set_enable_search (GTK_TREE_VIEW (treeview), FALSE);
gtk_dialog_set_has_separator (GTK_DIALOG (dialog), FALSE);
gtk_widget_show_all (dialog);
result = gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_destroy (dialog);
return p.changed;
}
static GtkWidget *
create_add_emblems_dialog (CajaEmblemSidebar *emblem_sidebar,
GSList *emblems)
{
GtkWidget *dialog, *label, *table, *image;
GtkWidget *first_entry, *entry, *scroller, *hbox;
Emblem *emblem;
GSList *list;
int num_emblems;
first_entry = NULL;
dialog = gtk_dialog_new_with_buttons (_("Add Emblems..."),
NULL,
0,
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL,
GTK_STOCK_OK,
GTK_RESPONSE_OK,
GTK_STOCK_HELP,
GTK_RESPONSE_HELP,
NULL);
gtk_dialog_set_default_response (GTK_DIALOG (dialog),
GTK_RESPONSE_OK);
/* FIXME: make a better message */
if (g_slist_length (emblems) > 1)
{
label = gtk_label_new (_("Enter a descriptive name next to each emblem. This name will be used in other places to identify the emblem."));
}
else
{
label = gtk_label_new (_("Enter a descriptive name next to the emblem. This name will be used in other places to identify the emblem."));
}
gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),
label, FALSE, FALSE, 8);
gtk_widget_show (label);
scroller = eel_scrolled_wrap_table_new (TRUE, GTK_SHADOW_NONE, &table);
eel_wrap_table_set_x_spacing (EEL_WRAP_TABLE (table), 8);
eel_wrap_table_set_y_spacing (EEL_WRAP_TABLE (table), 8);
num_emblems=0;
list = emblems;
while (list != NULL)
{
/* walk through the list of emblems, and create an image
* and entry for each one
*/
emblem = (Emblem *)list->data;
list = list->next;
image = gtk_image_new_from_pixbuf (emblem->pixbuf);
hbox = gtk_hbox_new (TRUE, 0);
gtk_box_pack_start (GTK_BOX (hbox), image, FALSE, FALSE, 0);
entry = gtk_entry_new ();
gtk_entry_set_activates_default (GTK_ENTRY (entry), TRUE);
g_signal_connect (entry, "changed",
G_CALLBACK (emblem_name_entry_changed_cb),
emblem);
gtk_box_pack_start (GTK_BOX (hbox), entry, FALSE, FALSE, 0);
gtk_container_add (GTK_CONTAINER (table), hbox);
if (num_emblems == 0)
{
first_entry = entry;
}
num_emblems++;
}
gtk_container_set_border_width (GTK_CONTAINER (dialog), 8);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),
scroller, TRUE, TRUE, 8);
gtk_widget_show_all (scroller);
gtk_widget_grab_focus (first_entry);
/* we expand the window to hold up to about 4 emblems, but after that
* let the scroller do its thing. Is there a better way to do this?
*/
gtk_window_set_default_size (GTK_WINDOW (dialog), 400,
MIN (120+(60*num_emblems), 350));
g_object_set_data_full (G_OBJECT (dialog), "emblems-to-add",
emblems, (GDestroyNotify)destroy_emblem_list);
return dialog;
}
int
DialogSpinEntry(GtkWidget *parent, const char *title, const char *caption, double min, double max, double inc, double *r, int *x, int *y)
{
GtkWidget *dlg, *spin;
GtkBox *vbox;
int data, n;
gint res_id;
double prec;
dlg = gtk_dialog_new_with_buttons(title,
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,
_("_OK"), GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_default_response(GTK_DIALOG(dlg), GTK_RESPONSE_OK);
gtk_window_set_resizable(GTK_WINDOW(dlg), FALSE);
vbox = GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dlg)));
if (caption) {
GtkWidget *label;
label = gtk_label_new(caption);
gtk_box_pack_start(vbox, label, FALSE, FALSE, 5);
}
if (inc == 0)
inc = 1;
spin = gtk_spin_button_new_with_range(min, max, inc);
gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(spin), TRUE);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(spin), *r);
gtk_box_pack_start(vbox, spin, FALSE, FALSE, 2);
gtk_entry_set_activates_default(GTK_ENTRY(spin), TRUE);
prec = log10(fabs(inc));
if (prec < 0) {
n = ceil(- prec);
} else {
n = 0;
}
gtk_spin_button_set_digits(GTK_SPIN_BUTTON(spin), n);
set_dialog_position(dlg, x, y);
gtk_widget_show_all(dlg);
res_id = ndialog_run(dlg);
switch (res_id) {
case GTK_RESPONSE_OK:
*r = gtk_spin_button_get_value(GTK_SPIN_BUTTON(spin));
data = IDOK;
break;
default:
data = IDCANCEL;
break;
}
get_dialog_position(dlg, x, y);
gtk_widget_destroy(dlg);
reset_event();
return data;
}
gchar *cclass_dialog(gint pos_type, gint system) {
GtkWidget *dialog;
GtkWidget *scrollwin_pos;
GtkWidget *treeview_pos;
GtkTreeViewColumn *column;
GtkListStore *store;
GtkTreeSelection *selection;
GtkCellRenderer *renderer;
GtkTreeIter iter;
gint id, result;
gchar *pos_utf8 = NULL;
category_code *code = NULL;
gint narrow_size = 0, i;
/* construct dialog */
dialog = gtk_dialog_new_with_buttons(_("Part of Speech"), NULL,
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CANCEL,
GTK_RESPONSE_REJECT,
GTK_STOCK_OK,
GTK_RESPONSE_ACCEPT,
NULL);
gtk_widget_set_size_request(GTK_WIDGET(dialog), 400, 350);
gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER);
scrollwin_pos = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollwin_pos),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrollwin_pos),
GTK_SHADOW_IN);
gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))),
scrollwin_pos,
TRUE, TRUE, 10);
gtk_widget_show(scrollwin_pos);
treeview_pos = gtk_tree_view_new();
gtk_container_add(GTK_CONTAINER(scrollwin_pos),
treeview_pos);
gtk_widget_show(treeview_pos);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("ID",
renderer,
"text", COLUMN_ID,
NULL);
gtk_tree_view_column_set_visible(column, FALSE);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview_pos), column);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeview_pos),
FALSE);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(_("Part of Speech"),
renderer,
"text", COLUMN_POS,
NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview_pos), column);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeview_pos),
TRUE);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(_("Example"),
renderer,
"text", COLUMN_EXAMPLE,
NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview_pos), column);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeview_pos),
TRUE);
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview_pos));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE);
store = gtk_list_store_new(N_COLUMNS_POS,
G_TYPE_INT, /* ID */
G_TYPE_STRING, /* POS */
G_TYPE_STRING); /* EXAMPLE */
gtk_tree_view_set_model(GTK_TREE_VIEW(treeview_pos),
GTK_TREE_MODEL(store));
switch (pos_type) {
case POS_SUBSTANTIVE:
narrow_size = nr_substantive_code;
code = substantive_code;
break;
case POS_ADVERB:
narrow_size = nr_adverb_code;
code = adverb_code;
break;
case POS_VERB:
narrow_size = nr_verb_code;
code = verb_code;
break;
case POS_ADJECTIVE:
narrow_size = nr_adjective_code;
code = adjective_code;
break;
case POS_ETC:
narrow_size = nr_etc_code;
code = etc_code;
break;
}
for (i = 0; i < narrow_size; i++) {
if (code[i].type & system) {
gtk_list_store_append(store, &iter);
gtk_list_store_set(store, &iter,
COLUMN_ID, i,
COLUMN_POS, eucjp_to_utf8(code[i].desc),
COLUMN_EXAMPLE, eucjp_to_utf8(code[i].example),
-1);
}
}
result = gtk_dialog_run(GTK_DIALOG(dialog));
switch (result) {
case GTK_RESPONSE_ACCEPT:
if (gtk_tree_selection_get_selected(selection, NULL, &iter)) {
gtk_tree_model_get(GTK_TREE_MODEL(store), &iter,
COLUMN_ID, &id, -1);
pos_utf8 = g_strdup(code[id].code);
}
break;
default:
break;
}
gtk_widget_destroy(dialog);
return pos_utf8;
}
static void configure (void)
{
if (config_win)
{
gtk_window_present ((GtkWindow *) config_win);
return;
}
config_win = gtk_dialog_new_with_buttons (_("LADSPA Host Settings"), NULL,
0, _("_Close"), GTK_RESPONSE_CLOSE, NULL);
gtk_window_set_default_size ((GtkWindow *) config_win, 480, 360);
GtkWidget * vbox = gtk_dialog_get_content_area ((GtkDialog *) config_win);
GtkWidget * hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start ((GtkBox *) vbox, hbox, 0, 0, 0);
GtkWidget * label = gtk_label_new (_("Module paths:"));
gtk_box_pack_start ((GtkBox *) hbox, label, 0, 0, 0);
label = gtk_label_new (0);
gtk_label_set_markup ((GtkLabel *) label,
_("<small>Separate multiple paths with a colon.\n"
"These paths are searched in addition to LADSPA_PATH.\n"
"After adding new paths, press Enter to scan for new plugins.</small>"));
gtk_misc_set_padding ((GtkMisc *) label, 12, 6);
gtk_misc_set_alignment ((GtkMisc *) label, 0, 0);
gtk_box_pack_start ((GtkBox *) vbox, label, 0, 0, 0);
GtkWidget * entry = gtk_entry_new ();
gtk_box_pack_start ((GtkBox *) hbox, entry, 1, 1, 0);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start ((GtkBox *) vbox, hbox, 1, 1, 0);
GtkWidget * vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_box_pack_start ((GtkBox *) hbox, vbox2, 1, 1, 0);
label = gtk_label_new (_("Available plugins:"));
gtk_box_pack_start ((GtkBox *) vbox2, label, 0, 0, 0);
GtkWidget * scrolled = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type ((GtkScrolledWindow *) scrolled, GTK_SHADOW_IN);
gtk_box_pack_start ((GtkBox *) vbox2, scrolled, 1, 1, 0);
plugin_list = create_plugin_list ();
gtk_container_add ((GtkContainer *) scrolled, plugin_list);
GtkWidget * hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start ((GtkBox *) vbox2, hbox2, 0, 0, 0);
GtkWidget * enable_button = gtk_button_new_with_label (_("Enable"));
gtk_box_pack_end ((GtkBox *) hbox2, enable_button, 0, 0, 0);
vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_box_pack_start ((GtkBox *) hbox, vbox2, 1, 1, 0);
label = gtk_label_new (_("Enabled plugins:"));
gtk_box_pack_start ((GtkBox *) vbox2, label, 0, 0, 0);
scrolled = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type ((GtkScrolledWindow *) scrolled, GTK_SHADOW_IN);
gtk_box_pack_start ((GtkBox *) vbox2, scrolled, 1, 1, 0);
loaded_list = create_loaded_list ();
gtk_container_add ((GtkContainer *) scrolled, loaded_list);
hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start ((GtkBox *) vbox2, hbox2, 0, 0, 0);
GtkWidget * disable_button = gtk_button_new_with_label (_("Disable"));
gtk_box_pack_end ((GtkBox *) hbox2, disable_button, 0, 0, 0);
GtkWidget * settings_button = gtk_button_new_with_label (_("Settings"));
gtk_box_pack_end ((GtkBox *) hbox2, settings_button, 0, 0, 0);
if (module_path)
gtk_entry_set_text ((GtkEntry *) entry, module_path);
g_signal_connect (config_win, "response", (GCallback) gtk_widget_destroy, NULL);
g_signal_connect (config_win, "destroy", (GCallback) gtk_widget_destroyed, & config_win);
g_signal_connect (entry, "activate", (GCallback) set_module_path, NULL);
g_signal_connect (plugin_list, "destroy", (GCallback) gtk_widget_destroyed, & plugin_list);
g_signal_connect (enable_button, "clicked", (GCallback) enable_selected, NULL);
g_signal_connect (loaded_list, "destroy", (GCallback) gtk_widget_destroyed, & loaded_list);
g_signal_connect (disable_button, "clicked", (GCallback) disable_selected, NULL);
g_signal_connect (settings_button, "clicked", (GCallback) configure_selected, NULL);
gtk_widget_show_all (config_win);
}
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;
}
void nsgtk_about_dialog_init(GtkWindow *parent,
struct browser_window *bw,
const char *version)
{
GtkWidget *dialog, *vbox, *button, *image, *label;
gchar *name_string;
GList *pixbufs = gtk_window_get_default_icon_list();
name_string = g_markup_printf_escaped ("<span size=\"xx-large\" weight=\"bold\">NetSurf %s</span>", version);
/* Create the widgets */
dialog = gtk_dialog_new_with_buttons("About NetSurf",
parent,
GTK_DIALOG_DESTROY_WITH_PARENT,
NULL);
vbox = gtk_vbox_new (FALSE, 8);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), vbox, TRUE, TRUE, 0);
if (pixbufs != NULL) {
GtkIconSet *icon_set = gtk_icon_set_new_from_pixbuf(GDK_PIXBUF(g_list_nth_data(pixbufs, 0)));
image = gtk_image_new();
gtk_image_set_from_icon_set (GTK_IMAGE (image),
icon_set, GTK_ICON_SIZE_DIALOG);
gtk_icon_set_unref (icon_set);
g_list_free (pixbufs);
gtk_box_pack_start(GTK_BOX (vbox), image, FALSE, FALSE, 0);
}
label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (label), name_string);
g_free (name_string);
gtk_label_set_selectable (GTK_LABEL (label), TRUE);
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_CENTER);
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
label = gtk_label_new("NetSurf is a small fast web browser");
gtk_label_set_selectable(GTK_LABEL (label), TRUE);
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_CENTER);
gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
label = gtk_label_new("Copyright © 2003 - 2012 The NetSurf Developers");
gtk_label_set_selectable(GTK_LABEL(label), TRUE);
gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_CENTER);
gtk_box_pack_start(GTK_BOX (vbox), label, FALSE, FALSE, 0);
nsgtk_dialog_set_has_separator (GTK_DIALOG (dialog), FALSE);
/* Add the OK button */
gtk_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE);
gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_CLOSE);
/* Add the credits button */
button = gtk_button_new_from_stock ("Credits");
gtk_box_pack_end(GTK_BOX (GTK_DIALOG (dialog)->action_area),
button, FALSE, TRUE, 0);
gtk_button_box_set_child_secondary (GTK_BUTTON_BOX (GTK_DIALOG (dialog)->action_area), button, TRUE);
g_signal_connect(button, "clicked", G_CALLBACK(nsgtk_about_dialog_credits), (gpointer)bw);
/* Add the Licence button */
button = gtk_button_new_from_stock ("Licence");
gtk_box_pack_end(GTK_BOX (GTK_DIALOG (dialog)->action_area),
button, FALSE, TRUE, 0);
gtk_button_box_set_child_secondary (GTK_BUTTON_BOX (GTK_DIALOG (dialog)->action_area), button, TRUE);
g_signal_connect(button, "clicked", G_CALLBACK(nsgtk_about_dialog_licence), (gpointer)bw);
/* 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_widget_show_all(dialog);
}
static gboolean
rawxyz_dialog(RawXYZArgs *args,
GwySurface *surface)
{
GtkWidget *dialog, *label;
GtkTable *table;
RawXYZControls controls;
gint row, response;
gchar *s;
controls.args = args;
controls.surface = surface;
dialog = gtk_dialog_new_with_buttons(_("Import XYZ Data"), NULL, 0,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK);
gwy_help_add_to_file_dialog(GTK_DIALOG(dialog), GWY_HELP_DEFAULT);
controls.dialog = dialog;
table = GTK_TABLE(gtk_table_new(6, 5, FALSE));
gtk_table_set_row_spacings(table, 2);
gtk_table_set_col_spacings(table, 6);
gtk_container_set_border_width(GTK_CONTAINER(table), 4);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), GTK_WIDGET(table),
TRUE, TRUE, 0);
row = 0;
label = gtk_label_new(_("Number of points:"));
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach(table, label, 0, 1, row, row+1, GTK_FILL, 0, 0, 0);
s = g_strdup_printf("%u", surface->n);
label = gtk_label_new(s);
g_free(s);
gtk_misc_set_alignment(GTK_MISC(label), 1.0, 0.5);
gtk_table_attach(table, label, 1, 2, row, row+1, GTK_FILL, 0, 0, 0);
row++;
construct_range(table, _("X-range:"), row++,
&controls.xmin, &controls.xmax, &controls.xunit);
construct_range(table, _("Y-range:"), row++,
&controls.ymin, &controls.ymax, &controls.yunit);
construct_range(table, _("Z-range:"), row++,
&controls.zmin, &controls.zmax, &controls.zunit);
gtk_table_set_row_spacing(table, row-1, 8);
row = construct_units(&controls, table, row);
g_signal_connect_swapped(controls.xy_units, "changed",
G_CALLBACK(xyunits_changed), &controls);
g_signal_connect_swapped(controls.z_units, "changed",
G_CALLBACK(zunits_changed), &controls);
gtk_entry_set_text(GTK_ENTRY(controls.xy_units), args->xy_units);
gtk_entry_set_text(GTK_ENTRY(controls.z_units), args->z_units);
xyunits_changed(&controls, GTK_ENTRY(controls.xy_units));
zunits_changed(&controls, GTK_ENTRY(controls.z_units));
gtk_widget_show_all(dialog);
do {
response = gtk_dialog_run(GTK_DIALOG(dialog));
switch (response) {
case GTK_RESPONSE_CANCEL:
case GTK_RESPONSE_DELETE_EVENT:
gtk_widget_destroy(dialog);
case GTK_RESPONSE_NONE:
return FALSE;
break;
case GTK_RESPONSE_OK:
break;
default:
g_assert_not_reached();
break;
}
} while (response != GTK_RESPONSE_OK);
gtk_widget_destroy(dialog);
return TRUE;
}
/* create the toolbar-customization dialog
*/
void
customize_dialog_cb(GtkWidget * widget, gpointer data)
{
GtkWidget *notebook;
GtkWidget *child;
GtkWidget *option_frame;
GtkWidget *option_box;
GtkWidget *wrap_button;
GtkWidget *active_window = data;
BalsaToolbarType type;
BalsaToolbarModel *model;
GSimpleActionGroup *group;
GtkWidget *content_area;
/* There can only be one */
if (customize_widget) {
gtk_window_present(GTK_WINDOW(customize_widget));
return;
}
customize_widget =
gtk_dialog_new_with_buttons(_("Customize Toolbars"),
GTK_WINDOW(active_window),
GTK_DIALOG_DESTROY_WITH_PARENT |
libbalsa_dialog_flags(),
_("_Close"), GTK_RESPONSE_CLOSE,
_("_Help"), GTK_RESPONSE_HELP,
NULL);
#if HAVE_MACOSX_DESKTOP
libbalsa_macosx_menu_for_parent(customize_widget, GTK_WINDOW(active_window));
#endif
g_object_add_weak_pointer(G_OBJECT(customize_widget),
(gpointer) & customize_widget);
g_signal_connect(G_OBJECT(customize_widget), "response",
G_CALLBACK(tp_dialog_response_cb), NULL);
notebook = gtk_notebook_new();
content_area =
gtk_dialog_get_content_area(GTK_DIALOG(customize_widget));
gtk_box_pack_start(GTK_BOX(content_area), notebook, TRUE, TRUE, 0);
gtk_window_set_role(GTK_WINDOW(customize_widget), "customize");
gtk_window_set_default_size(GTK_WINDOW(customize_widget), 600, 440);
/* The order of pages must be consistent with the BalsaToolbarType
* enum. */
model = balsa_window_get_toolbar_model();
group = g_simple_action_group_new();
balsa_window_add_action_entries(G_ACTION_MAP(group));
#ifdef BALSA_TOOLBAR_DEBUG_ACTIONS
g_print("main window\n");
#endif /* BALSA_TOOLBAR_DEBUG_ACTIONS */
child = create_toolbar_page(model, G_ACTION_MAP(group));
g_object_unref(group);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), child,
gtk_label_new(_("Main window")));
model = sendmsg_window_get_toolbar_model();
group = g_simple_action_group_new();
sendmsg_window_add_action_entries(G_ACTION_MAP(group));
#ifdef BALSA_TOOLBAR_DEBUG_ACTIONS
g_print("compose window\n");
#endif /* BALSA_TOOLBAR_DEBUG_ACTIONS */
child = create_toolbar_page(model, G_ACTION_MAP(group));
g_object_unref(group);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), child,
gtk_label_new(_("Compose window")));
model = message_window_get_toolbar_model();
group = g_simple_action_group_new();
message_window_add_action_entries(G_ACTION_MAP(group));
#ifdef BALSA_TOOLBAR_DEBUG_ACTIONS
g_print("message window\n");
#endif /* BALSA_TOOLBAR_DEBUG_ACTIONS */
child = create_toolbar_page(model, G_ACTION_MAP(group));
g_object_unref(group);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), child,
gtk_label_new(_("Message window")));
option_frame = gtk_frame_new(_("Toolbar options"));
gtk_container_set_border_width(GTK_CONTAINER(option_frame), 6);
gtk_box_pack_start(GTK_BOX(content_area), option_frame, FALSE, FALSE, 0);
option_box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 6);
gtk_container_set_border_width(GTK_CONTAINER(option_box), 6);
gtk_container_add(GTK_CONTAINER(option_frame), option_box);
wrap_button =
gtk_check_button_new_with_mnemonic(_("_Wrap button labels"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(wrap_button),
balsa_app.toolbar_wrap_button_text);
g_signal_connect(G_OBJECT(wrap_button), "toggled",
G_CALLBACK(wrap_toggled_cb), notebook);
gtk_box_pack_start(GTK_BOX(option_box), wrap_button, FALSE, FALSE, 0);
gtk_widget_show_all(customize_widget);
/* Now that the pages are shown, we can switch to the page
* corresponding to the toolbar that the user clicked on. */
type =
GPOINTER_TO_INT(g_object_get_data
(G_OBJECT(widget), BALSA_TOOLBAR_MODEL_TYPE));
gtk_notebook_set_current_page(GTK_NOTEBOOK(notebook), type);
}
/*
* The following function is taken almost directly from
* ghid_attribte_dialog() from pcb. It is a generic attribute editor
* gui where the dialog is built on the fly based on a passed in
* attribute list.
*
* Written by Dan McMahill
*/
int
attribute_interface_dialog (gerbv_HID_Attribute * attrs,
int n_attrs, gerbv_HID_Attr_Val * results,
const char * title,
const char * descr)
{
GtkWidget *dialog, *main_vbox, *vbox, *vbox1, *hbox, *entry;
GtkWidget *combo;
GtkWidget *widget;
int i, j;
GtkTooltips *tips;
int rc = 0;
int set_auto_uncheck = 0;
int sen = TRUE;
/*
* Store how many widgets we'll have in our dialog and keep track of
* them. Be sure to free up our list if one existed already.
*/
n_widgets = n_attrs;
if (all_widgets != NULL)
free (all_widgets);
all_widgets = (GtkWidget **) malloc (n_widgets * sizeof(GtkWidget *));
if (all_widgets == NULL) {
fprintf (stderr, _("%s(): malloc failed for an array of size %d\n"), __FUNCTION__, n_widgets);
exit (1);
}
dprintf ("%s(%p, %d, %p, \"%s\", \"%s\")\n", __FUNCTION__, attrs, n_attrs, results, title, descr);
auto_uncheck_needed = 0;
auto_uncheck_widget = NULL;
auto_uncheck_attr = NULL;
tips = gtk_tooltips_new ();
dialog = gtk_dialog_new_with_buttons (title,
GTK_WINDOW (screen.win.topLevelWindow),
GTK_DIALOG_MODAL
| GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CANCEL, GTK_RESPONSE_NONE,
GTK_STOCK_OK, GTK_RESPONSE_OK, NULL);
gtk_window_set_wmclass (GTK_WINDOW (dialog), "gerbv_attribute_editor", _("gerbv"));
main_vbox = gtk_vbox_new (FALSE, 6);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 6);
gtk_container_add (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox), main_vbox);
vbox = ghid_category_vbox (main_vbox, descr != NULL ? descr : "",
4, 2, TRUE, TRUE);
/*
* Iterate over all the attributes and build up a dialog box
* that lets us control all of the options. By doing things this
* way, any changes to the attributes or if there is a new list of
* attributes, everything will automatically be reflected in this
* dialog box.
*/
for (j = 0; j < n_attrs; j++)
{
dprintf ("%s(): adding attribute #%d\n", __func__, j);
switch (attrs[j].type)
{
case HID_Label:
widget = gtk_label_new (_(attrs[j].name));
gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE, 0);
gtk_tooltips_set_tip (tips, widget, _(attrs[j].help_text), NULL);
break;
case HID_Integer:
hbox = gtk_hbox_new (FALSE, 4);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
/*
* FIXME
* need to pick the "digits" argument based on min/max
* values
*/
ghid_spin_button (hbox, &widget, attrs[j].default_val.int_value,
attrs[j].min_val, attrs[j].max_val, 1.0, 1.0, 0, 0,
intspinner_changed_cb,
&(attrs[j].default_val.int_value), FALSE, NULL);
gtk_tooltips_set_tip (tips, widget, _(attrs[j].help_text), NULL);
all_widgets[j] = widget;
widget = gtk_label_new (_(attrs[j].name));
gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 0);
break;
case HID_Real:
hbox = gtk_hbox_new (FALSE, 4);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
/*
* FIXME
* need to pick the "digits" and step size argument more
* intelligently
*/
ghid_spin_button (hbox, &widget, attrs[j].default_val.real_value,
attrs[j].min_val, attrs[j].max_val, 0.01, 0.01, 3,
0,
dblspinner_changed_cb,
&(attrs[j].default_val.real_value), FALSE, NULL);
gtk_tooltips_set_tip (tips, widget, _(attrs[j].help_text), NULL);
all_widgets[j] = widget;
widget = gtk_label_new (_(attrs[j].name));
gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 0);
break;
case HID_String:
hbox = gtk_hbox_new (FALSE, 4);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
entry = gtk_entry_new ();
gtk_box_pack_start (GTK_BOX (hbox), entry, FALSE, FALSE, 0);
gtk_entry_set_text (GTK_ENTRY (entry),
attrs[j].default_val.str_value);
gtk_tooltips_set_tip (tips, entry, _(attrs[j].help_text), NULL);
g_signal_connect (G_OBJECT (entry), "changed",
G_CALLBACK (entry_changed_cb),
&(attrs[j].default_val.str_value));
all_widgets[j] = entry;
widget = gtk_label_new (_(attrs[j].name));
gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 0);
break;
case HID_Boolean:
/* put this in a check button */
ghid_check_button_connected (vbox, &widget,
attrs[j].default_val.int_value,
TRUE, FALSE, FALSE, 0, set_flag_cb,
&(attrs[j].default_val.int_value),
_(attrs[j].name));
gtk_tooltips_set_tip (tips, widget, _(attrs[j].help_text), NULL);
/*
* This is an ugly ugly ugly hack.... If this is
* the first in our list of attributes *and* it has a
* magic name of "autodetect" then we'll remember it and
* all of the other callbacks will cause this button to
* come unchecked. Among the other nastiness
* involved here, this dialog is now *required* to
* be modal since we are using a static variable.
* To avoid that, we need a new data type that can hold
* more state information. Ideally we need a better
* way to capture dependencies between attributes to
* allow arbitrary relationships instead of just this
* one single "magic" one.
*/
if (j == 0 && strcmp(attrs[j].name, "autodetect") == 0) {
set_auto_uncheck = 1;
auto_uncheck_widget = widget;
auto_uncheck_attr = &(attrs[j].default_val.int_value);
/* if the "auto" button in checked then don't let
* anything else be sensitive.
*/
if (attrs[j].default_val.int_value)
sen = FALSE;
}
all_widgets[j] = widget;
break;
case HID_Enum:
hbox = gtk_hbox_new (FALSE, 4);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
/*
* We have to put the combo_box inside of an event_box in
* order for tooltips to work.
*/
widget = gtk_event_box_new ();
gtk_tooltips_set_tip (tips, widget, _(attrs[j].help_text), NULL);
gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 0);
combo = gtk_combo_box_new_text ();
gtk_container_add (GTK_CONTAINER (widget), combo);
g_signal_connect (G_OBJECT (combo), "changed",
G_CALLBACK (enum_changed_cb),
&(attrs[j].default_val.int_value));
/*
* Iterate through each value and add them to the
* combo box
*/
i = 0;
while (attrs[j].enumerations[i])
{
gtk_combo_box_append_text (GTK_COMBO_BOX (combo),
_(attrs[j].enumerations[i]));
i++;
}
gtk_combo_box_set_active (GTK_COMBO_BOX (combo),
attrs[j].default_val.int_value);
all_widgets[j] = combo;
widget = gtk_label_new (_(attrs[j].name));
gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 0);
break;
case HID_Mixed:
dprintf ("HID_Mixed\n");
break;
case HID_Path:
vbox1 = ghid_category_vbox (vbox, _(attrs[j].name), 4, 2, TRUE, TRUE);
entry = gtk_entry_new ();
gtk_box_pack_start (GTK_BOX (vbox1), entry, FALSE, FALSE, 0);
gtk_entry_set_text (GTK_ENTRY (entry),
attrs[j].default_val.str_value);
g_signal_connect (G_OBJECT (entry), "changed",
G_CALLBACK (entry_changed_cb),
&(attrs[j].default_val.str_value));
gtk_tooltips_set_tip (tips, entry, _(attrs[j].help_text), NULL);
all_widgets[j] = entry;
break;
default:
fprintf (stderr, _("%s: unknown type of HID attribute\n"), __FUNCTION__);
break;
}
}
gtk_widget_show_all (dialog);
auto_uncheck_needed = set_auto_uncheck;
/*
* part of the "auto" hack. Make everything sensitive or
* insensitive based on the state of the "auto" toggle button (if it
* exists)
*/
for (j = 1; j < n_widgets ; j++) {
gtk_widget_set_sensitive (all_widgets[j], sen);
}
if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_OK)
{
/* copy over the results */
for (i = 0; i < n_attrs; i++)
{
results[i] = attrs[i].default_val;
if (results[i].str_value)
results[i].str_value = strdup (results[i].str_value);
}
rc = 0;
}
else
rc = 1;
gtk_widget_destroy (dialog);
return rc;
}
static void _camera_import_dialog_new(_camera_import_dialog_t *data)
{
data->dialog = gtk_dialog_new_with_buttons(_("import images from camera"), NULL, GTK_DIALOG_MODAL,
_("cancel"), GTK_RESPONSE_NONE, C_("camera import", "import"),
GTK_RESPONSE_ACCEPT, NULL);
gtk_window_set_default_size(GTK_WINDOW(data->dialog), 100, 600);
gtk_window_set_transient_for(GTK_WINDOW(data->dialog), GTK_WINDOW(dt_ui_main_window(darktable.gui->ui)));
GtkWidget *content = gtk_dialog_get_content_area(GTK_DIALOG(data->dialog));
// List - setup store
data->store = gtk_list_store_new(2, GDK_TYPE_PIXBUF, G_TYPE_STRING);
// IMPORT PAGE
data->import.page = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);
gtk_container_set_border_width(GTK_CONTAINER(data->import.page), 5);
// Top info
data->import.info = gtk_label_new(_("please wait while prefetching thumbnails of images from camera..."));
gtk_label_set_single_line_mode(GTK_LABEL(data->import.info), FALSE);
gtk_widget_set_halign(data->import.info, GTK_ALIGN_START);
gtk_box_pack_start(GTK_BOX(data->import.page), data->import.info, FALSE, FALSE, 0);
// jobcode
data->import.jobname
= _camera_import_gconf_widget(data, _("jobcode"), "plugins/capture/camera/import/jobcode");
gtk_box_pack_start(GTK_BOX(data->import.page), GTK_WIDGET(data->import.jobname->widget), FALSE, FALSE, 0);
// Create the treview with list model data store
data->import.treeview = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(data->import.treeview), GTK_POLICY_NEVER,
GTK_POLICY_ALWAYS);
gtk_container_add(GTK_CONTAINER(data->import.treeview), gtk_tree_view_new());
GtkTreeView *treeview = GTK_TREE_VIEW(gtk_bin_get_child(GTK_BIN(data->import.treeview)));
GtkCellRenderer *renderer = gtk_cell_renderer_pixbuf_new();
GtkTreeViewColumn *column
= gtk_tree_view_column_new_with_attributes(_("thumbnail"), renderer, "pixbuf", 0, (char *)NULL);
gtk_tree_view_append_column(treeview, column);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(_("storage file"), renderer, "text", 1, (char *)NULL);
gtk_tree_view_append_column(treeview, column);
gtk_tree_view_column_set_expand(column, TRUE);
GtkTreeSelection *selection = gtk_tree_view_get_selection(treeview);
gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE);
gtk_tree_view_set_model(treeview, GTK_TREE_MODEL(data->store));
gtk_tree_view_set_headers_visible(treeview, FALSE);
gtk_box_pack_start(GTK_BOX(data->import.page), data->import.treeview, TRUE, TRUE, 0);
// SETTINGS PAGE
data->settings.page = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);
gtk_container_set_border_width(GTK_CONTAINER(data->settings.page), 5);
// general settings
gtk_box_pack_start(GTK_BOX(data->settings.page), gtk_label_new(_("general")), FALSE, FALSE, 0);
// ignoring of jpegs. hack while we don't handle raw+jpeg in the same directories.
data->settings.general.ignore_jpeg = gtk_check_button_new_with_label(_("ignore JPEG files"));
gtk_widget_set_tooltip_text(data->settings.general.ignore_jpeg,
_("do not load files with an extension of .jpg or .jpeg. this can be useful when there are "
"raw+JPEG in a directory."));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(data->settings.general.ignore_jpeg),
dt_conf_get_bool("ui_last/import_ignore_jpegs"));
gtk_box_pack_start(GTK_BOX(data->settings.page), data->settings.general.ignore_jpeg, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(data->settings.general.ignore_jpeg), "clicked",
G_CALLBACK(_check_button_callback), data);
GtkWidget *hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
data->settings.general.date_override = gtk_check_button_new_with_label(_("override today's date"));
gtk_box_pack_start(GTK_BOX(hbox), data->settings.general.date_override, FALSE, FALSE, 0);
gtk_widget_set_tooltip_text(data->settings.general.date_override,
_("check this, if you want to override the timestamp used when expanding variables:\n$(YEAR), "
"$(MONTH), $(DAY),\n$(HOUR), $(MINUTE), $(SECONDS)"));
data->settings.general.date_entry = gtk_entry_new();
gtk_widget_set_sensitive(data->settings.general.date_entry, gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(
data->settings.general.date_override)));
gtk_box_pack_start(GTK_BOX(hbox), data->settings.general.date_entry, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(data->settings.general.date_override), "clicked",
G_CALLBACK(_check_button_callback), data);
gtk_box_pack_start(GTK_BOX(data->settings.page), hbox, FALSE, FALSE, 0);
// THE NOTEBOOK
data->notebook = gtk_notebook_new();
gtk_notebook_append_page(GTK_NOTEBOOK(data->notebook), data->import.page, gtk_label_new(_("images")));
gtk_notebook_append_page(GTK_NOTEBOOK(data->notebook), data->settings.page, gtk_label_new(_("settings")));
// end
gtk_box_pack_start(GTK_BOX(content), data->notebook, TRUE, TRUE, 0);
// gtk_widget_set_size_request(content, DT_PIXEL_APPLY_DPI(400), DT_PIXEL_APPLY_DPI(400));
}
static void
button_clicked (GtkButton *button, GNCSearchAccount *fi)
{
GNCSearchAccountPrivate *priv;
GtkDialog *dialog;
GtkWidget *account_tree;
GtkWidget *accounts_scroller;
GtkWidget *label;
char *desc;
GtkTreeSelection *selection;
/* Create the account tree */
account_tree = GTK_WIDGET(gnc_tree_view_account_new (FALSE));
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW(account_tree), FALSE);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(account_tree));
gtk_tree_selection_set_mode (selection, GTK_SELECTION_MULTIPLE);
/* Select the currently-selected accounts */
priv = _PRIVATE(fi);
if (priv->selected_accounts)
gnc_tree_view_account_set_selected_accounts (GNC_TREE_VIEW_ACCOUNT(account_tree),
priv->selected_accounts, FALSE);
/* Create the account scroller and put the tree in it */
accounts_scroller = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW(accounts_scroller),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_container_add(GTK_CONTAINER(accounts_scroller), account_tree);
gtk_widget_set_size_request(GTK_WIDGET(accounts_scroller), 300, 300);
/* Create the label */
label = gtk_label_new (_("Select Accounts to Match"));
/* Create the dialog */
dialog =
GTK_DIALOG(gtk_dialog_new_with_buttons(_("Select the Accounts to Compare"),
NULL,
0,
_("_Cancel"), GTK_RESPONSE_CANCEL,
_("_OK"), GTK_RESPONSE_OK,
NULL));
/* Put the dialog together */
gtk_box_pack_start ((GtkBox *) gtk_dialog_get_content_area (dialog), label,
FALSE, FALSE, 3);
gtk_box_pack_start ((GtkBox *) gtk_dialog_get_content_area (dialog), accounts_scroller,
TRUE, TRUE, 3);
gtk_widget_show_all (GTK_WIDGET (dialog));
/* Now run the dialog */
if (gtk_dialog_run (dialog) == GTK_RESPONSE_OK)
{
if (priv->selected_accounts)
g_list_free (priv->selected_accounts);
priv->selected_accounts =
gnc_tree_view_account_get_selected_accounts (GNC_TREE_VIEW_ACCOUNT (account_tree));
desc = describe_button (fi);
gtk_label_set_text (GTK_LABEL (gtk_bin_get_child (GTK_BIN (button))), desc);
}
gtk_widget_destroy (GTK_WIDGET (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);
}
bool request_auth(gpointer parent)
{
bool ret;
GtkWidget* dialog = gtk_dialog_new_with_buttons ("Enter Password",
GTK_WINDOW(parent),
(GtkDialogFlags) (GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT),
GTK_STOCK_OK,
GTK_RESPONSE_ACCEPT,
GTK_STOCK_CANCEL,
GTK_RESPONSE_REJECT,
NULL);
GtkWidget *content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog));
GtkWidget *entry_name = gtk_entry_new();
GtkWidget *entry_pwd = gtk_entry_new();
GtkWidget *label_name = gtk_label_new("username");
GtkWidget *label_pwd = gtk_label_new("password");
GtkWidget *image;
GdkPixbuf *pixbuf = reduce_pixbuf(create_pixbuf(GUI_ICON), 48, 48);
if(pixbuf)
{
image = gtk_image_new_from_pixbuf(pixbuf);
gtk_container_add (GTK_CONTAINER (content_area), image);
}
gtk_entry_set_invisible_char (GTK_ENTRY(entry_pwd), '*');
gtk_entry_set_visibility (GTK_ENTRY(entry_pwd), FALSE);
gtk_container_set_border_width(GTK_CONTAINER (content_area), 5);
gtk_entry_set_text(GTK_ENTRY(entry_name), (gchar*) c_core->GetSession()->GetUsername()->c_str());
gtk_container_add (GTK_CONTAINER (content_area), label_name);
gtk_container_add (GTK_CONTAINER (content_area), entry_name);
gtk_container_add (GTK_CONTAINER (content_area), label_pwd);
gtk_container_add (GTK_CONTAINER (content_area), entry_pwd);
if(c_core->GetSession()->GetUsername()->length())
gtk_widget_grab_focus (GTK_WIDGET(entry_pwd));
else
gtk_widget_grab_focus (GTK_WIDGET(entry_name));
gtk_widget_show_all (dialog);
g_signal_connect(G_OBJECT(entry_pwd), "activate", G_CALLBACK(entry_pwd_response), dialog);
gint result = gtk_dialog_run(GTK_DIALOG (dialog));
gchar *text_name = (gchar*) gtk_entry_get_text(GTK_ENTRY(entry_name));
gchar *text_pwd = (gchar*) gtk_entry_get_text(GTK_ENTRY(entry_pwd));
switch (result)
{
case GTK_RESPONSE_ACCEPT:
INFO("debug" "GUI: login dialog -> %s\n", text_name);
if (strlen(text_name) && strlen(text_pwd))
{
c_core->GetSession()->SetUsername(text_name);
c_core->GetSession()->SetPassword(text_pwd);
gtk_label_set_text(GTK_LABEL(gres.label_nick), text_name);
if(!(ret = c_core->GetSession()->TestRsa()))
{
add_message_to_chat(gres.tbuf_chat,
(gchar*) "Wrong Password! (RSA test failed)\n", 'e');
}
}
else
{
add_message_to_chat(gres.tbuf_chat,
(gchar*) "Invalid User/Password insertion\n", 'e');
ret = false;
}
break;
default:
ret = false;
break;
}
if(pixbuf)
g_object_unref (G_OBJECT(pixbuf));
gtk_widget_destroy(dialog);
return ret;
}
static void
mdm_lang_setup_treeview (void)
{
if (dialog == NULL)
{
GtkWidget *main_vbox;
GtkWidget *button;
GtkWidget **tmp_p;
GtkWidget *swindow;
GtkWidget *label;
char *s;
dialog = gtk_dialog_new_with_buttons (_("Select a Language"),
#ifdef TODO
GTK_WINDOW (parent_window),
#endif
NULL,
0,
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL,
NULL);
button = gtk_button_new_with_mnemonic (_("Change _Language"));
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_widget_show (button);
gtk_dialog_add_action_widget (GTK_DIALOG (dialog), button,
GTK_RESPONSE_OK);
gtk_dialog_set_has_separator (GTK_DIALOG (dialog), FALSE);
gtk_container_set_border_width (GTK_CONTAINER (dialog), 5);
gtk_box_set_spacing (GTK_BOX (GTK_DIALOG (dialog)->vbox), 2);
main_vbox = gtk_vbox_new (FALSE, 6);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 5);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox),
main_vbox, TRUE, TRUE, 0);
gtk_dialog_set_default_response (GTK_DIALOG (dialog),
GTK_RESPONSE_OK);
/* evil gcc warnings */
tmp_p = &dialog;
g_object_add_weak_pointer (G_OBJECT (dialog), (gpointer *)tmp_p);
s = g_strdup (_("_Select the language for your session to use:"));
label = gtk_label_new_with_mnemonic (s);
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
g_free (s);
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
gtk_box_pack_start (GTK_BOX (main_vbox),
label, FALSE, FALSE, 0);
tv = gtk_tree_view_new ();
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (tv), TRUE);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), tv);
/* FIXME: we should handle this better, but things really look
* bad if we aren't always LTR */
gtk_widget_set_direction (tv, GTK_TEXT_DIR_LTR);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (tv), FALSE);
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (tv),
GTK_DIALOG_MODAL,
NULL,
gtk_cell_renderer_text_new (),
"text", TRANSLATED_NAME_COLUMN,
NULL);
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (tv),
GTK_DIALOG_MODAL,
NULL,
gtk_cell_renderer_text_new (),
"markup",
UNTRANSLATED_NAME_COLUMN,
NULL);
swindow = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (swindow), GTK_SHADOW_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swindow),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_container_add (GTK_CONTAINER (swindow), tv);
gtk_box_pack_start (GTK_BOX (main_vbox),
swindow, TRUE, TRUE, 0);
gtk_window_set_default_size (GTK_WINDOW (dialog),
MIN (400, mdm_wm_screen.width),
MIN (600, mdm_wm_screen.height));
g_signal_connect (G_OBJECT (gtk_tree_view_get_selection (GTK_TREE_VIEW (tv))),
"changed",
(GCallback) selection_changed,
NULL);
g_signal_connect (G_OBJECT (tv),
"row_activated",
(GCallback) tree_row_activated,
NULL);
gtk_tree_view_set_model (GTK_TREE_VIEW (tv),
GTK_TREE_MODEL (lang_model));
}
}
/*
* Rename entry
* Signal handler for "activate" rename entry
*/
gboolean rename_entry()
{
FILE *fp = NULL;
GtkWidget *name_dialog = NULL;
GtkWidget *msg_dialog = NULL;
GtkWidget *vbox = NULL;
GtkWidget *hbox = NULL;
GtkWidget *label = NULL;
GtkWidget *name_entry = NULL;
const gchar *entry_text = NULL;
gchar old_entry_display_name[MAX_NAME_LEN];
gchar new_entry_display_name[MAX_NAME_LEN];
gchar new_entry_name[MAX_PATH_LEN];
gchar old_entry_name[MAX_PATH_LEN];
book_data *book = NULL;
section_data *section = NULL;
entry_data *entry = NULL;
gchar *temp_string;
gint result;
// Assert master exists
g_assert_nonnull(master);
// Get currently selected
book = get_current_book_or_return_with_warning();
section = get_current_section_or_return_with_warning();
entry = get_current_entry_or_return_with_warning();
// Write current entry
write_current_entry();
// Create name dialog
name_dialog = gtk_dialog_new_with_buttons(app_name, GTK_WINDOW(main_window),
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, NULL);
gtk_widget_set_size_request(name_dialog, SM_DLG_WIDTH, SM_DLG_HEIGHT);
gtk_window_set_type_hint(GTK_WINDOW(name_dialog), GDK_WINDOW_TYPE_HINT_MENU);
gtk_window_set_resizable(GTK_WINDOW(name_dialog), FALSE);
label = gtk_label_new("Enter new entry name...");
name_entry = gtk_entry_new();
gtk_entry_set_max_length(GTK_ENTRY(name_entry), MAX_NAME_LEN-5);
// Get auto name
if(options.auto_name_entry == TRUE) {
temp_string = g_malloc0(MAX_NAME_LEN);
strdelchr(temp_string, get_auto_entry_name(get_text_view(book)), ILLEGAL_CHARS);
temp_string[MAX_NAME_LEN-5] = 0;
if(strcmp(temp_string, "") == 0)
gtk_entry_set_text(GTK_ENTRY(name_entry), entry->name);
else
gtk_entry_set_text(GTK_ENTRY(name_entry), temp_string);
g_free(temp_string);
} else {
gtk_entry_set_text(GTK_ENTRY(name_entry), entry->name);
}
vbox = gtk_dialog_get_content_area(GTK_DIALOG(name_dialog));
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 5);
gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 5);
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), name_entry, TRUE, TRUE, 5);
gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 5);
gtk_entry_set_activates_default(GTK_ENTRY(name_entry), TRUE);
gtk_dialog_set_default_response (GTK_DIALOG(name_dialog),GTK_RESPONSE_ACCEPT);
gtk_widget_show_all(name_dialog);
// Run dialog
result = gtk_dialog_run(GTK_DIALOG(name_dialog));
switch (result) {
case GTK_RESPONSE_ACCEPT:
entry_text = gtk_entry_get_text(GTK_ENTRY(name_entry));
// Scan name for illegal characters
temp_string = g_malloc0(MAX_NAME_LEN);
strdelchr(temp_string, entry_text, ILLEGAL_CHARS);
gtk_entry_set_text(GTK_ENTRY(name_entry), temp_string);
g_free(temp_string);
entry_text = gtk_entry_get_text(GTK_ENTRY(name_entry));
// Old entry file
g_snprintf(old_entry_name, sizeof(old_entry_name),
"%s%s%s%s%s%s%s.txt",
note_dir, G_DIR_SEPARATOR_S,
book->name, G_DIR_SEPARATOR_S,
section->name, G_DIR_SEPARATOR_S,
entry->name);
// New entry file
g_snprintf(new_entry_name, sizeof(new_entry_name),
"%s%s%s%s%s%s%s.txt",
note_dir, G_DIR_SEPARATOR_S,
book->name, G_DIR_SEPARATOR_S,
section->name, G_DIR_SEPARATOR_S,
entry_text);
// Ignore rename if names match
if(strcmp(entry->name, entry_text) == 0) {
gtk_widget_destroy(name_dialog);
return TRUE;
}
// Set display name
strncpy(old_entry_display_name, entry->name, MAX_NAME_LEN-5);
if(strlen(old_entry_display_name) > 25)
strcpy(old_entry_display_name+25, "...\0");
strncpy(new_entry_display_name, entry_text, MAX_NAME_LEN-5);
if(strlen(new_entry_display_name) > 25)
strcpy(new_entry_display_name+25, "...\0");
// Check that new entry name is valid
if(strlen(entry_text) < 1) {
sn_warning("Unable to rename entry [%s] to [%s].",
entry->name, entry_text);
msg_dialog = gtk_message_dialog_new(GTK_WINDOW(main_window),
GTK_DIALOG_MODAL, GTK_MESSAGE_WARNING, GTK_BUTTONS_OK,
"Unable to rename entry \"%s\" to \"%s\".",
old_entry_display_name, new_entry_display_name);
gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(msg_dialog),
"Please ensure the entry name contains a valid character.");
gtk_window_set_title(GTK_WINDOW(msg_dialog), app_name);
gtk_window_set_type_hint(GTK_WINDOW(msg_dialog), GDK_WINDOW_TYPE_HINT_MENU);
gtk_window_set_resizable(GTK_WINDOW(msg_dialog), FALSE);
result = gtk_dialog_run(GTK_DIALOG(msg_dialog));
gtk_widget_destroy(name_dialog);
gtk_widget_destroy(msg_dialog);
return FALSE;
}
// Check that new entry name is valid
fp = fopen(new_entry_name, "wx");
if (fp == NULL) {
sn_warning("Unable to rename entry [%s] to [%s].",
entry->name, entry_text);
msg_dialog = gtk_message_dialog_new(GTK_WINDOW(main_window), GTK_DIALOG_MODAL,
GTK_MESSAGE_WARNING, GTK_BUTTONS_OK,
"Unable to rename entry \"%s\" to \"%s\".",
old_entry_display_name, new_entry_display_name);
gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(msg_dialog),
"Please ensure the entry name doesn't aleady exist.");
gtk_window_set_title(GTK_WINDOW(msg_dialog), app_name);
gtk_window_set_type_hint(GTK_WINDOW(msg_dialog), GDK_WINDOW_TYPE_HINT_MENU);
gtk_window_set_resizable(GTK_WINDOW(msg_dialog), FALSE);
result = gtk_dialog_run(GTK_DIALOG(msg_dialog));
gtk_widget_destroy(name_dialog);
gtk_widget_destroy(msg_dialog);
return FALSE;
}
fclose(fp);
sn_trace("Renaming entry [%s] to [%s].", entry->name, entry_text);
// Rename entry file
result = rename(old_entry_name, new_entry_name);
if(result == 0) {
// Remove history
remove_history();
// Update entry
strcpy(entry->name, entry_text);
// Update book
write_book(book, note_dir);
// Update view
populate_entries(book, section);
on_entry_change(get_entry_view(book), book);
gtk_widget_destroy(name_dialog);
return TRUE;
} else {
sn_warning("Unable to rename entry [%s].", entry->name);
gtk_widget_destroy(name_dialog);
return FALSE;
}
default:
gtk_widget_destroy(name_dialog);
return FALSE;
} // End switch
return FALSE;
} // Rename entry
static void
facets_dialog(FacetsArgs *args,
GwyContainer *data,
GwyContainer *fdata,
GwyDataField *dfield,
GwyDataField *mfield,
gint id,
GQuark mquark)
{
GtkWidget *dialog, *table, *hbox, *hbox2, *vbox, *label, *scale, *button;
GtkWidget *spin;
FacetsControls controls;
gint response;
GwySelection *selection;
gint row;
gwy_clear(&controls, 1);
controls.args = args;
dialog = gtk_dialog_new_with_buttons(_("Mark Facets"),
NULL,
GTK_DIALOG_DESTROY_WITH_PARENT,
gwy_sgettext("verb|_Mark"),
RESPONSE_PREVIEW,
_("_Reset"), RESPONSE_RESET,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK);
gwy_help_add_to_proc_dialog(GTK_DIALOG(dialog), GWY_HELP_DEFAULT);
controls.dialog = dialog;
/* Shallow-copy stuff to temporary container */
controls.fdata = fdata;
controls.mydata = gwy_container_new();
gwy_container_set_object_by_name(controls.mydata, "/0/data", dfield);
gwy_app_sync_data_items(data, controls.mydata, id, 0, FALSE,
GWY_DATA_ITEM_PALETTE,
GWY_DATA_ITEM_RANGE,
GWY_DATA_ITEM_MASK_COLOR,
GWY_DATA_ITEM_REAL_SQUARE,
0);
hbox = gtk_hbox_new(FALSE, 2);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), hbox,
FALSE, FALSE, 4);
controls.view = create_preview(controls.mydata, 0, PREVIEW_SIZE, TRUE);
gtk_box_pack_start(GTK_BOX(hbox), controls.view, FALSE, FALSE, 4);
selection = create_vector_layer(GWY_DATA_VIEW(controls.view), 0, "Point",
TRUE);
g_signal_connect(selection, "changed",
G_CALLBACK(preview_selection_updated), &controls);
vbox = gtk_vbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, TRUE, 0);
hbox2 = gtk_hbox_new(FALSE, 4);
gtk_box_pack_start(GTK_BOX(vbox), hbox2, FALSE, FALSE, 0);
/* Slope view */
controls.fview = create_preview(controls.fdata, 0, FDATA_RES, TRUE);
gtk_box_pack_start(GTK_BOX(hbox2), controls.fview, FALSE, FALSE, 0);
selection = create_vector_layer(GWY_DATA_VIEW(controls.fview), 0, "Point",
TRUE);
g_signal_connect(selection, "changed",
G_CALLBACK(facet_view_selection_updated), &controls);
/* Info table */
table = gtk_table_new(7, 2, FALSE);
gtk_table_set_row_spacings(GTK_TABLE(table), 2);
gtk_table_set_col_spacings(GTK_TABLE(table), 6);
gtk_container_set_border_width(GTK_CONTAINER(table), 4);
gtk_box_pack_start(GTK_BOX(hbox2), table, TRUE, TRUE, 4);
row = 0;
/* TRANSLATORS: The direction or line orthogonal to something. */
label = gwy_label_new_header(_("Normal"));
gtk_table_attach(GTK_TABLE(table), label,
0, 2, row, row+1, GTK_FILL, 0, 0, 0);
row++;
controls.theta_label = add_angle_label(table, _("θ:"), &row);
controls.phi_label = add_angle_label(table, _("φ:"), &row);
button = gtk_button_new_with_mnemonic(_("_Find Maximum"));
gtk_table_attach(GTK_TABLE(table), button,
0, 2, row, row+1, GTK_FILL, 0, 0, 0);
g_signal_connect_swapped(button, "clicked",
G_CALLBACK(facet_view_reset_maximum), &controls);
gtk_table_set_row_spacing(GTK_TABLE(table), row, 8);
row++;
label = gwy_label_new_header(_("Mean Normal"));
gtk_table_attach(GTK_TABLE(table), label,
0, 2, row, row+1, GTK_FILL, 0, 0, 0);
row++;
controls.mtheta_label = add_angle_label(table, _("θ:"), &row);
controls.mphi_label = add_angle_label(table, _("φ:"), &row);
gtk_table_set_row_spacing(GTK_TABLE(table), row-1, 8);
label = gtk_label_new_with_mnemonic(_("Facet plane size:"));
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), label,
0, 2, row, row+1, GTK_FILL, 0, 0, 0);
row++;
controls.kernel_size = gtk_adjustment_new(args->kernel_size,
0.0, MAX_PLANE_SIZE, 1.0, 1.0, 0);
spin = gtk_spin_button_new(GTK_ADJUSTMENT(controls.kernel_size), 0.0, 0);
gtk_label_set_mnemonic_widget(GTK_LABEL(label), spin);
gtk_table_attach(GTK_TABLE(table), spin,
0, 1, row, row+1, 0, 0, 0, 0);
g_signal_connect(controls.kernel_size, "value-changed",
G_CALLBACK(facet_view_recompute), &controls);
row++;
table = gtk_table_new(4 + 2*(!!mfield), 4, FALSE);
gtk_table_set_row_spacings(GTK_TABLE(table), 2);
gtk_table_set_col_spacings(GTK_TABLE(table), 6);
gtk_container_set_border_width(GTK_CONTAINER(table), 4);
gtk_box_pack_start(GTK_BOX(vbox), table, TRUE, TRUE, 4);
row = 0;
controls.tolerance = gtk_adjustment_new(args->tolerance*180.0/G_PI,
0.0, 15.0, 0.01, 0.1, 0);
scale = gwy_table_attach_hscale(table, row++, _("_Tolerance:"), _("deg"),
controls.tolerance, 0);
gtk_spin_button_set_digits(GTK_SPIN_BUTTON(scale), 3);
g_signal_connect(controls.tolerance, "value-changed",
G_CALLBACK(facets_tolerance_changed), &controls);
if (mfield) {
gwy_container_set_object_by_name(controls.fdata, "/1/mask", mfield);
controls.combine
= gtk_check_button_new_with_mnemonic(_("Com_bine with "
"existing mask"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(controls.combine),
args->combine);
gtk_table_attach(GTK_TABLE(table), controls.combine,
0, 3, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
g_signal_connect(controls.combine, "toggled",
G_CALLBACK(combine_changed), &controls);
row++;
controls.combine_type
= gwy_enum_combo_box_new(gwy_merge_type_get_enum(), -1,
G_CALLBACK(combine_type_changed), &controls,
args->combine_type, TRUE);
gwy_table_attach_hscale(table, row, _("Operation:"), NULL,
GTK_OBJECT(controls.combine_type),
GWY_HSCALE_WIDGET);
gtk_table_set_row_spacing(GTK_TABLE(table), row, 8);
row++;
}
controls.color_button = create_mask_color_button(controls.mydata, dialog,
0);
gwy_table_attach_hscale(table, row, _("_Mask color:"), NULL,
GTK_OBJECT(controls.color_button),
GWY_HSCALE_WIDGET_NO_EXPAND);
row++;
if (!gwy_si_unit_equal(gwy_data_field_get_si_unit_xy(dfield),
gwy_data_field_get_si_unit_z(dfield))) {
gtk_table_set_row_spacing(GTK_TABLE(table), row-1, 8);
label = gtk_label_new(_("Warning: Lateral and value units differ. "
"Angles are not physically meaningful."));
gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), label,
0, 4, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
row++;
}
gtk_widget_show_all(dialog);
facet_view_select_angle(&controls, args->theta0, args->phi0);
do {
response = gtk_dialog_run(GTK_DIALOG(dialog));
switch (response) {
case GTK_RESPONSE_CANCEL:
case GTK_RESPONSE_DELETE_EVENT:
gtk_widget_destroy(dialog);
case GTK_RESPONSE_NONE:
g_object_unref(controls.mydata);
facets_save_args(gwy_app_settings_get(), args);
return;
break;
case GTK_RESPONSE_OK:
break;
case RESPONSE_RESET:
args->tolerance = facets_defaults.tolerance;
args->kernel_size = facets_defaults.kernel_size;
facets_dialog_update_controls(&controls, args);
break;
case RESPONSE_PREVIEW:
preview(&controls, args);
update_average_angle(&controls, args);
break;
default:
g_assert_not_reached();
break;
}
} while (response != GTK_RESPONSE_OK);
gwy_app_sync_data_items(controls.mydata, data, 0, id, FALSE,
GWY_DATA_ITEM_MASK_COLOR,
0);
gtk_widget_destroy(dialog);
g_object_unref(controls.mydata);
run_noninteractive(args, data, fdata, dfield, mfield, mquark);
facets_save_args(gwy_app_settings_get(), args);
gwy_app_channel_log_add_proc(data, id, id);
}
static gboolean
grain_cross_dialog(GrainCrossArgs *args,
GwyDataField *dfield)
{
GrainCrossControls controls;
GtkWidget *dialog, *hbox2, *label;
GwyDataChooser *chooser;
GtkTable *table;
GwyGraphModel *gmodel;
gint response;
controls.args = args;
controls.dfield = dfield;
dialog = gtk_dialog_new_with_buttons(_("Grain Correlations"), NULL, 0,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
controls.dialog = GTK_DIALOG(dialog);
gtk_dialog_set_default_response(controls.dialog, GTK_RESPONSE_OK);
gwy_help_add_to_proc_dialog(GTK_DIALOG(dialog), GWY_HELP_DEFAULT);
gtk_window_set_default_size(GTK_WINDOW(dialog), 720, 480);
table = GTK_TABLE(gtk_table_new(3, 3, FALSE));
gtk_table_set_row_spacings(table, 2);
gtk_table_set_col_spacings(table, 6);
gtk_container_set_border_width(GTK_CONTAINER(table), 4);
gtk_box_pack_start(GTK_BOX(controls.dialog->vbox), GTK_WIDGET(table),
TRUE, TRUE, 0);
gmodel = create_corr_graph(args, dfield);
controls.graph = gwy_graph_new(gmodel);
gtk_widget_set_size_request(controls.graph, 320, -1);
g_object_unref(gmodel);
gtk_table_attach(GTK_TABLE(table), controls.graph, 0, 1, 0, 3,
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
controls.abscissa = attach_axis_list(table, _("_Abscissa"), 1,
args->abscissa,
args->abscissa_expanded,
&controls);
controls.ordinate = attach_axis_list(table, _("O_rdinate"), 2,
args->ordinate,
args->ordinate_expanded,
&controls);
hbox2 = gtk_hbox_new(FALSE, 6);
gtk_table_attach(GTK_TABLE(table), hbox2,
1, 3, 2, 3, GTK_EXPAND | GTK_FILL, 0, 0, 0);
label = gtk_label_new_with_mnemonic(_("Target _graph:"));
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_box_pack_start(GTK_BOX(hbox2), label, FALSE, FALSE, 0);
controls.target_graph = gwy_data_chooser_new_graphs();
chooser = GWY_DATA_CHOOSER(controls.target_graph);
gwy_data_chooser_set_none(chooser, _("New graph"));
gwy_data_chooser_set_active(chooser, NULL, -1);
gwy_data_chooser_set_filter(chooser, filter_target_graphs, &controls, NULL);
gwy_data_chooser_set_active_id(chooser, &args->target_graph);
gwy_data_chooser_get_active_id(chooser, &args->target_graph);
gtk_label_set_mnemonic_widget(GTK_LABEL(label), controls.target_graph);
gtk_box_pack_end(GTK_BOX(hbox2), controls.target_graph, TRUE, TRUE, 0);
g_signal_connect_swapped(controls.target_graph, "changed",
G_CALLBACK(target_graph_changed), &controls);
axis_quantity_changed(&controls);
gtk_widget_show_all(dialog);
do {
response = gtk_dialog_run(controls.dialog);
switch (response) {
case GTK_RESPONSE_CANCEL:
case GTK_RESPONSE_DELETE_EVENT:
gtk_widget_destroy(dialog);
case GTK_RESPONSE_NONE:
return FALSE;
break;
case GTK_RESPONSE_OK:
break;
default:
g_assert_not_reached();
break;
}
} while (response != GTK_RESPONSE_OK);
gtk_widget_destroy(dialog);
return TRUE;
}
/** \brief Clone module.
*
* This function is called when the user selects the clone
* menu item in the GtkSatModule popup menu. the function creates
* a dialog in which the user is asked for a new module name.
* When a valid module name is available and the user clicks on OK,
* an exact copy of the currwent module is created.
* By default, the nes module will be opened but the user has the
* possibility to override this in the dialog window.
*
*/
static void clone_cb (GtkWidget *menuitem, gpointer data)
{
GtkWidget *dialog;
GtkWidget *entry;
GtkWidget *label;
GtkWidget *toggle;
GtkWidget *vbox;
GtkAllocation aloc;
guint response;
GtkSatModule *module = GTK_SAT_MODULE (data);
GtkSatModule *newmod;
gchar *source,*target;
gchar *icon; /* icon file name */
gchar *title; /* window title */
(void) menuitem; /* avoid unused parameter compiler warning */
dialog = gtk_dialog_new_with_buttons (_("Clone Module"),
GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (module))),
GTK_DIALOG_MODAL |
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL,
GTK_STOCK_OK,
GTK_RESPONSE_OK,
NULL);
gtk_container_set_border_width (GTK_CONTAINER (dialog), 5);
/* label */
label = gtk_label_new (_("Name of new module:"));
vbox = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
gtk_box_pack_start (GTK_BOX(vbox), label, FALSE, FALSE, 0);
/* name entry */
entry = gtk_entry_new ();
gtk_entry_set_max_length (GTK_ENTRY (entry), 25);
gtk_entry_set_text (GTK_ENTRY (entry), module->name);
gtk_widget_set_tooltip_text (entry,
_("Enter a short name for this module.\n"\
"Allowed characters: 0..9, a..z, A..Z, - and _"));
/*not sure what to do with the old private tip the new api does not like them
_("The name will be used to identify the module " \
"and it is also used a file name for saving the data."\
"Max length is 25 characters."));
*/
/* attach changed signal so that we can enable OK button when
a proper name has been entered
oh, btw. disable OK button to begin with....
*/
gtk_dialog_set_response_sensitive (GTK_DIALOG (dialog),
GTK_RESPONSE_OK,
FALSE);
g_signal_connect (entry, "changed", G_CALLBACK (name_changed), dialog);
gtk_box_pack_start (GTK_BOX( vbox ), entry, FALSE, FALSE, 0);
/* check button */
toggle = gtk_check_button_new_with_label (_("Open module when created"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), TRUE);
gtk_widget_set_tooltip_text ( toggle,
_("If checked, the new module will be opened "\
"after it has been created"));
gtk_box_pack_start (GTK_BOX (vbox),
toggle, FALSE, FALSE, 20);
gtk_widget_show_all (vbox);
/* run dialog */
response = gtk_dialog_run (GTK_DIALOG (dialog));
switch (response) {
case GTK_RESPONSE_OK:
sat_log_log (SAT_LOG_LEVEL_INFO,
_("%s:%d: Cloning %s => %s"),
__FILE__, __LINE__, module->name,
gtk_entry_get_text (GTK_ENTRY (entry)));
/* build full file names */
gchar *moddir = get_modules_dir ();
source = g_strconcat (moddir, G_DIR_SEPARATOR_S,
module->name, ".mod", NULL);
target = g_strconcat (moddir, G_DIR_SEPARATOR_S,
gtk_entry_get_text (GTK_ENTRY (entry)), ".mod", NULL);
g_free (moddir);
/* copy file */
if (gpredict_file_copy (source, target)) {
sat_log_log (SAT_LOG_LEVEL_ERROR,
_("%s:%d: Failed to clone %s."),
__FILE__, __LINE__, module->name);
}
else {
sat_log_log (SAT_LOG_LEVEL_INFO,
_("%s:%d: Successfully cloned %s."),
__FILE__, __LINE__, module->name);
/* open module if requested */
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (toggle))) {
newmod = GTK_SAT_MODULE (gtk_sat_module_new (target));
newmod->state = module->state;
if (newmod->state == GTK_SAT_MOD_STATE_DOCKED) {
/* add to module manager */
mod_mgr_add_module (GTK_WIDGET (newmod), TRUE);
}
else {
/* add to module manager */
mod_mgr_add_module (GTK_WIDGET (newmod), FALSE);
/* create window */
newmod->win = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (newmod->win),
newmod->name);
title = g_strconcat (_("GPREDICT: "),
newmod->name,
" (", newmod->qth->name, ")",
NULL);
gtk_window_set_title (GTK_WINDOW (newmod->win), title);
g_free (title);
/* use size of source module */
gtk_widget_get_allocation(GTK_WIDGET (module), &aloc);
gtk_window_set_default_size (GTK_WINDOW (newmod->win),
aloc.width,
aloc.height);
g_signal_connect (G_OBJECT (newmod->win), "configure_event",
G_CALLBACK (module_window_config_cb), newmod);
/* add module to window */
gtk_container_add (GTK_CONTAINER (newmod->win),
GTK_WIDGET (newmod));
/* window icon */
icon = icon_file_name ("gpredict-icon.png");
if (g_file_test (icon, G_FILE_TEST_EXISTS)) {
gtk_window_set_icon_from_file (GTK_WINDOW (newmod->win), icon, NULL);
}
g_free (icon);
/* show window */
gtk_widget_show_all (newmod->win);
}
}
}
/* clean up */
g_free (source);
g_free (target);
break;
case GTK_RESPONSE_CANCEL:
sat_log_log (SAT_LOG_LEVEL_INFO,
_("%s:%d: Cloning cancelled by user."),
__FILE__, __LINE__);
break;
default:
sat_log_log (SAT_LOG_LEVEL_INFO,
_("%s:%d: Cloning interrupted."),
__FILE__, __LINE__);
break;
}
gtk_widget_destroy (dialog);
}
int
DialogComboEntry(GtkWidget *parent, const char *title, const char *caption, struct narray *array, int sel, char **r, int *x, int *y)
{
GtkWidget *dlg, *combo;
GtkBox *vbox;
int data;
gint res_id;
char **d;
const char *s;
int i, anum;
d = arraydata(array);
anum = arraynum(array);
*r = NULL;
dlg = gtk_dialog_new_with_buttons(title,
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,
_("_OK"), GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_default_response(GTK_DIALOG(dlg), GTK_RESPONSE_OK);
gtk_window_set_resizable(GTK_WINDOW(dlg), FALSE);
vbox = GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dlg)));
if (caption) {
GtkWidget *label;
label = gtk_label_new(caption);
gtk_box_pack_start(vbox, label, FALSE, FALSE, 5);
}
combo = combo_box_entry_create();
for (i = 0; i < anum; i++) {
combo_box_append_text(combo, d[i]);
}
if (sel >= 0 && sel < anum) {
combo_box_set_active(combo, sel);
}
gtk_box_pack_start(vbox, combo, FALSE, FALSE, 2);
set_dialog_position(dlg, x, y);
gtk_widget_show_all(dlg);
res_id = ndialog_run(dlg);
switch (res_id) {
case GTK_RESPONSE_OK:
s = combo_box_entry_get_text(combo);
if (s) {
*r = g_strdup(s);
} else {
*r = NULL;
}
data = IDOK;
break;
default:
data = IDCANCEL;
break;
}
get_dialog_position(dlg, x, y);
gtk_widget_destroy(dlg);
reset_event();
return data;
}
CEmoticonDlg::CEmoticonDlg(CWidget* parent) : m_IsModified(false)
// : CDialog( parent, _("Emoticons"), true )
{
m_Widget = gtk_dialog_new_with_buttons(_("Emoticons"),
GTK_WINDOW(parent->m_Widget),
GtkDialogFlags(GTK_DIALOG_MODAL|GTK_DIALOG_DESTROY_WITH_PARENT), _("Send"), GTK_RESPONSE_OK, GTK_STOCK_CLOSE, GTK_RESPONSE_CANCEL, NULL);
gtk_dialog_set_default_response(GTK_DIALOG(m_Widget), GTK_RESPONSE_OK );
gtk_window_set_type_hint (GTK_WINDOW (m_Widget), GDK_WINDOW_TYPE_HINT_DIALOG);
PostCreate();
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *emoticon_list_scrl;
GtkWidget *emoticon_list;
GtkWidget *vbtn_box;
GtkWidget *add_btn;
GtkWidget *edit_btn;
GtkWidget *remove_btn;
GtkWidget *up_btn;
GtkWidget *down_btn;
vbox = GTK_DIALOG (m_Widget)->vbox;
gtk_widget_show (vbox);
hbox = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox);
gtk_box_pack_end (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
emoticon_list_scrl = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_show (emoticon_list_scrl);
gtk_box_pack_start (GTK_BOX (hbox), emoticon_list_scrl, TRUE, TRUE, 0);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (emoticon_list_scrl), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (emoticon_list_scrl), GTK_SHADOW_IN);
vbtn_box = gtk_vbutton_box_new ();
gtk_widget_show (vbtn_box);
gtk_box_pack_start (GTK_BOX (hbox), vbtn_box, FALSE, TRUE, 0);
gtk_button_box_set_layout (GTK_BUTTON_BOX (vbtn_box), GTK_BUTTONBOX_START);
add_btn = gtk_button_new_from_stock ("gtk-add");
gtk_widget_show (add_btn);
gtk_container_add (GTK_CONTAINER (vbtn_box), add_btn);
GTK_WIDGET_SET_FLAGS (add_btn, GTK_CAN_DEFAULT);
edit_btn = gtk_button_new_from_stock ("gtk-edit");
gtk_widget_show (edit_btn);
gtk_container_add (GTK_CONTAINER (vbtn_box), edit_btn);
GTK_WIDGET_SET_FLAGS (edit_btn, GTK_CAN_DEFAULT);
remove_btn = gtk_button_new_from_stock ("gtk-remove");
gtk_widget_show (remove_btn);
gtk_container_add (GTK_CONTAINER (vbtn_box), remove_btn);
GTK_WIDGET_SET_FLAGS (remove_btn, GTK_CAN_DEFAULT);
up_btn = gtk_button_new_from_stock ("gtk-go-up");
gtk_widget_show (up_btn);
gtk_container_add (GTK_CONTAINER (vbtn_box), up_btn);
GTK_WIDGET_SET_FLAGS (up_btn, GTK_CAN_DEFAULT);
down_btn = gtk_button_new_from_stock ("gtk-go-down");
gtk_widget_show (down_btn);
gtk_container_add (GTK_CONTAINER (vbtn_box), down_btn);
GTK_WIDGET_SET_FLAGS (down_btn, GTK_CAN_DEFAULT);
g_signal_connect ((gpointer) add_btn, "clicked",
G_CALLBACK (CEmoticonDlg::OnAdd),
this);
g_signal_connect ((gpointer) edit_btn, "clicked",
G_CALLBACK (CEmoticonDlg::OnEdit),
this);
g_signal_connect ((gpointer) remove_btn, "clicked",
G_CALLBACK (CEmoticonDlg::OnRemove),
this);
g_signal_connect ((gpointer) up_btn, "clicked",
G_CALLBACK (CEmoticonDlg::OnUp),
this);
g_signal_connect ((gpointer) down_btn, "clicked",
G_CALLBACK (CEmoticonDlg::OnDown),
this);
gtk_window_set_default_size((GtkWindow*)m_Widget, 512, 400);
m_List = new CListBox;
emoticon_list = m_List->m_Widget;
gtk_widget_show (emoticon_list);
gtk_container_add (GTK_CONTAINER (emoticon_list_scrl), emoticon_list);
g_signal_connect(G_OBJECT(m_Widget), "response", G_CALLBACK(CDialog::OnResponse), this);
g_signal_connect(G_OBJECT(m_List->m_Widget), "row-activated", G_CALLBACK(CEmoticonDlg::OnListRowActivated), this );
LoadEmoticons();
}
int
DialogCheck(GtkWidget *parent, const char *title, const char *caption, struct narray *array, int *r, int *x, int *y)
{
GtkWidget *dlg, *btn, **btn_ary;
GtkBox *vbox;
int data;
gint res_id;
char **d;
int i, anum;
d = arraydata(array);
anum = arraynum(array);
btn_ary = g_malloc(anum * sizeof(*btn_ary));
if (btn_ary == NULL)
return IDCANCEL;
dlg = gtk_dialog_new_with_buttons(title,
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,
_("_OK"), GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_default_response(GTK_DIALOG(dlg), GTK_RESPONSE_OK);
gtk_window_set_resizable(GTK_WINDOW(dlg), FALSE);
vbox = GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dlg)));
if (caption) {
GtkWidget *label;
label = gtk_label_new(caption);
gtk_box_pack_start(vbox, label, FALSE, FALSE, 5);
}
btn = NULL;
for (i = 0; i < anum; i++) {
btn = gtk_check_button_new_with_mnemonic(d[i]);
gtk_box_pack_start(vbox, btn, FALSE, FALSE, 2);
btn_ary[i] = btn;
}
for (i = 0; i < anum; i++) {
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(btn_ary[i]), r[i]);
}
set_dialog_position(dlg, x, y);
gtk_widget_show_all(dlg);
res_id = ndialog_run(dlg);
switch (res_id) {
case GTK_RESPONSE_OK:
for (i = 0; i < anum; i++) {
r[i] = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(btn_ary[i]));
}
data = IDOK;
break;
default:
data = IDCANCEL;
break;
}
g_free(btn_ary);
get_dialog_position(dlg, x, y);
gtk_widget_destroy(dlg);
reset_event();
return data;
}
bool RunLinuxDialog()
{
GtkWidget *dialog;
int return_value;
/* Create the widgets */
dialog = gtk_dialog_new_with_buttons (
"GSdx Config",
NULL, /* parent window*/
(GtkDialogFlags)(GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT),
"OK", GTK_RESPONSE_ACCEPT,
// "Cancel", GTK_RESPONSE_REJECT, // Drop because it is too annoying to support call back this way
NULL);
// The main area for the whole dialog box.
GtkWidget* main_box = gtk_vbox_new(false, 5);
GtkWidget* central_box = gtk_vbox_new(false, 5);
GtkWidget* advance_box = gtk_vbox_new(false, 5);
GtkWidget* debug_box = gtk_vbox_new(false, 5);
// Grab a logo, to make things look nice.
GdkPixbuf* logo_pixmap = gdk_pixbuf_from_pixdata(&gsdx_ogl_logo, false, NULL);
GtkWidget* logo_image = gtk_image_new_from_pixbuf(logo_pixmap);
gtk_box_pack_start(GTK_BOX(main_box), logo_image, true, true, 0);
GtkWidget* main_table = CreateTableInBox(main_box , NULL , 2 , 2);
GtkWidget* shader_table = CreateTableInBox(central_box , "Custom Shader Settings" , 9 , 2);
GtkWidget* hw_table = CreateTableInBox(central_box , "Hardware Mode Settings" , 7 , 2);
GtkWidget* sw_table = CreateTableInBox(central_box , "Software Mode Settings" , 2 , 2);
GtkWidget* hack_table = CreateTableInBox(advance_box , "Hacks" , 7 , 2);
GtkWidget* gl_table = CreateTableInBox(advance_box , "OpenGL Very Advanced Custom Settings" , 6 , 2);
GtkWidget* record_table = CreateTableInBox(debug_box , "Recording Settings" , 4 , 3);
GtkWidget* debug_table = CreateTableInBox(debug_box , "OpenGL / GSdx Debug Settings" , 6 , 3);
// Populate all the tables
populate_main_table(main_table);
populate_shader_table(shader_table);
populate_hw_table(hw_table);
populate_sw_table(sw_table);
populate_hack_table(hack_table);
populate_gl_table(gl_table);
populate_debug_table(debug_table);
populate_record_table(record_table);
// Handle some nice tab
GtkWidget* notebook = gtk_notebook_new();
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), central_box, gtk_label_new("Global Setting"));
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), advance_box, gtk_label_new("Advance Setting"));
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), debug_box , gtk_label_new("Debug/Recording Setting"));
// Put everything in the big box.
gtk_container_add(GTK_CONTAINER(main_box), notebook);
// Put the box in the dialog and show it to the world.
gtk_container_add (GTK_CONTAINER(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), main_box);
gtk_widget_show_all (dialog);
return_value = gtk_dialog_run (GTK_DIALOG (dialog));
// Compatibility & not supported option
int mode_width = theApp.GetConfig("ModeWidth", 640);
int mode_height = theApp.GetConfig("ModeHeight", 480);
theApp.SetConfig("ModeHeight", mode_height);
theApp.SetConfig("ModeWidth", mode_width);
theApp.SetConfig("msaa", 0);
theApp.SetConfig("windowed", 1);
gtk_widget_destroy (dialog);
return (return_value == GTK_RESPONSE_ACCEPT);
}
/* todo: less on this side, like add track */
gchar *a_dialog_waypoint ( GtkWindow *parent, gchar *default_name, VikTrwLayer *vtl, VikWaypoint *wp, VikCoordMode coord_mode, gboolean is_new, gboolean *updated )
{
GtkWidget *dialog = gtk_dialog_new_with_buttons (_("Waypoint Properties"),
parent,
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CANCEL,
GTK_RESPONSE_REJECT,
GTK_STOCK_OK,
GTK_RESPONSE_ACCEPT,
NULL);
struct LatLon ll;
GtkWidget *latlabel, *lonlabel, *namelabel, *latentry, *lonentry, *altentry, *altlabel, *nameentry=NULL;
GtkWidget *commentlabel, *commententry, *descriptionlabel, *descriptionentry, *imagelabel, *imageentry, *symbollabel, *symbolentry;
GtkWidget *sourcelabel = NULL, *sourceentry = NULL;
GtkWidget *typelabel = NULL, *typeentry = NULL;
GtkWidget *timelabel = NULL;
GtkWidget *timevaluebutton = NULL;
GtkWidget *hasGeotagCB = NULL;
GtkWidget *consistentGeotagCB = NULL;
GtkWidget *direction_sb = NULL;
GtkWidget *direction_hb = NULL;
GtkListStore *store;
gchar *lat, *lon, *alt;
vik_coord_to_latlon ( &(wp->coord), &ll );
lat = g_strdup_printf ( "%f", ll.lat );
lon = g_strdup_printf ( "%f", ll.lon );
vik_units_height_t height_units = a_vik_get_units_height ();
switch (height_units) {
case VIK_UNITS_HEIGHT_METRES:
alt = g_strdup_printf ( "%f", wp->altitude );
break;
case VIK_UNITS_HEIGHT_FEET:
alt = g_strdup_printf ( "%f", VIK_METERS_TO_FEET(wp->altitude) );
break;
default:
alt = g_strdup_printf ( "%f", wp->altitude );
g_critical("Houston, we've had a problem. height=%d", height_units);
}
*updated = FALSE;
namelabel = gtk_label_new (_("Name:"));
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), namelabel, FALSE, FALSE, 0);
// Name is now always changeable
nameentry = gtk_entry_new ();
if ( default_name )
gtk_entry_set_text( GTK_ENTRY(nameentry), default_name );
g_signal_connect_swapped ( nameentry, "activate", G_CALLBACK(a_dialog_response_accept), GTK_DIALOG(dialog) );
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), nameentry, FALSE, FALSE, 0);
latlabel = gtk_label_new (_("Latitude:"));
latentry = gtk_entry_new ();
gtk_entry_set_text ( GTK_ENTRY(latentry), lat );
g_free ( lat );
lonlabel = gtk_label_new (_("Longitude:"));
lonentry = gtk_entry_new ();
gtk_entry_set_text ( GTK_ENTRY(lonentry), lon );
g_free ( lon );
altlabel = gtk_label_new (_("Altitude:"));
altentry = gtk_entry_new ();
gtk_entry_set_text ( GTK_ENTRY(altentry), alt );
g_free ( alt );
if ( wp->comment && !strncmp(wp->comment, "http", 4) )
commentlabel = gtk_link_button_new_with_label (wp->comment, _("Comment:") );
else
commentlabel = gtk_label_new (_("Comment:"));
commententry = gtk_entry_new ();
gchar *cmt = NULL;
// Auto put in some kind of 'name' as a comment if one previously 'goto'ed this exact location
cmt = a_vik_goto_get_search_string_for_this_place(VIK_WINDOW(parent));
if (cmt)
gtk_entry_set_text(GTK_ENTRY(commententry), cmt);
if ( wp->description && !strncmp(wp->description, "http", 4) )
descriptionlabel = gtk_link_button_new_with_label (wp->description, _("Description:") );
else
descriptionlabel = gtk_label_new (_("Description:"));
descriptionentry = gtk_entry_new ();
sourcelabel = gtk_label_new (_("Source:"));
if ( wp->source ) {
sourceentry = gtk_entry_new ();
gtk_entry_set_text(GTK_ENTRY(sourceentry), wp->source);
}
typelabel = gtk_label_new (_("Type:"));
if ( wp->type ) {
typeentry = gtk_entry_new ();
gtk_entry_set_text(GTK_ENTRY(typeentry), wp->type);
}
imagelabel = gtk_label_new (_("Image:"));
imageentry = vik_file_entry_new (GTK_FILE_CHOOSER_ACTION_OPEN, VF_FILTER_IMAGE, NULL, NULL);
{
GtkCellRenderer *r;
symbollabel = gtk_label_new (_("Symbol:"));
GtkTreeIter iter;
store = gtk_list_store_new(3, G_TYPE_STRING, GDK_TYPE_PIXBUF, G_TYPE_STRING);
symbolentry = gtk_combo_box_new_with_model(GTK_TREE_MODEL(store));
gtk_combo_box_set_wrap_width(GTK_COMBO_BOX(symbolentry), 6);
g_signal_connect(symbolentry, "changed", G_CALLBACK(symbol_entry_changed_cb), store);
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter, 0, NULL, 1, NULL, 2, _("(none)"), -1);
a_populate_sym_list(store);
r = gtk_cell_renderer_pixbuf_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (symbolentry), r, FALSE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (symbolentry), r, "pixbuf", 1, NULL);
r = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (symbolentry), r, FALSE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (symbolentry), r, "text", 2, NULL);
if ( !is_new && wp->symbol ) {
gboolean ok;
gchar *sym;
for (ok = gtk_tree_model_get_iter_first ( GTK_TREE_MODEL(store), &iter ); ok; ok = gtk_tree_model_iter_next ( GTK_TREE_MODEL(store), &iter)) {
gtk_tree_model_get ( GTK_TREE_MODEL(store), &iter, 0, (void *)&sym, -1 );
if (sym && !strcmp(sym, wp->symbol)) {
g_free(sym);
break;
} else {
g_free(sym);
}
}
// Ensure is it a valid symbol in the given symbol set (large vs small)
// Not all symbols are available in both
// The check prevents a Gtk Critical message
if ( iter.stamp )
gtk_combo_box_set_active_iter(GTK_COMBO_BOX(symbolentry), &iter);
}
}
if ( !is_new && wp->comment )
gtk_entry_set_text ( GTK_ENTRY(commententry), wp->comment );
if ( !is_new && wp->description )
gtk_entry_set_text ( GTK_ENTRY(descriptionentry), wp->description );
if ( !edit_wp )
edit_wp = vik_waypoint_new ();
edit_wp = vik_waypoint_copy ( wp );
if ( !is_new && wp->image ) {
vik_file_entry_set_filename ( VIK_FILE_ENTRY(imageentry), wp->image );
#ifdef VIK_CONFIG_GEOTAG
// Geotag Info [readonly]
hasGeotagCB = gtk_check_button_new_with_label ( _("Has Geotag") );
gtk_widget_set_sensitive ( hasGeotagCB, FALSE );
gboolean hasGeotag;
gchar *ignore = a_geotag_get_exif_date_from_file ( wp->image, &hasGeotag );
g_free ( ignore );
gtk_toggle_button_set_active ( GTK_TOGGLE_BUTTON(hasGeotagCB), hasGeotag );
consistentGeotagCB = gtk_check_button_new_with_label ( _("Consistent Position") );
gtk_widget_set_sensitive ( consistentGeotagCB, FALSE );
if ( hasGeotag ) {
struct LatLon ll = a_geotag_get_position ( wp->image );
VikCoord coord;
vik_coord_load_from_latlon ( &coord, coord_mode, &ll );
gtk_toggle_button_set_active ( GTK_TOGGLE_BUTTON(consistentGeotagCB), vik_coord_equalish(&coord, &wp->coord) );
}
// ATM the direction value box is always shown, even when there is no information.
// It would be nice to be able to hide it until the 'Add' has been performed,
// however I've not been able to achieve this.
// Thus simply sensistizing it instead.
GtkWidget *direction_label = gtk_label_new ( _("Image Direction:") );
direction_hb = gtk_hbox_new ( FALSE, 0 );
gtk_box_pack_start (GTK_BOX(direction_hb), direction_label, FALSE, FALSE, 0);
direction_sb = gtk_spin_button_new ( (GtkAdjustment*)gtk_adjustment_new (0, 0.0, 359.9, 5.0, 1, 0 ), 1, 1 );
if ( !is_new && !isnan(wp->image_direction) ) {
GtkWidget *direction_ref = gtk_label_new ( NULL );
if ( wp->image_direction_ref == WP_IMAGE_DIRECTION_REF_MAGNETIC )
gtk_label_set_label ( GTK_LABEL(direction_ref), _("Magnetic") );
else
gtk_label_set_label ( GTK_LABEL(direction_ref), _("True") );
gtk_box_pack_start (GTK_BOX(direction_hb), direction_ref, TRUE, FALSE, 0);
gtk_spin_button_set_value ( GTK_SPIN_BUTTON(direction_sb), wp->image_direction );
}
else {
GtkWidget *direction_ref_button = gtk_button_new ();
gtk_button_set_relief ( GTK_BUTTON(direction_ref_button), GTK_RELIEF_NONE );
GtkWidget *img = gtk_image_new_from_stock ( GTK_STOCK_ADD, GTK_ICON_SIZE_MENU );
gtk_button_set_image ( GTK_BUTTON(direction_ref_button), img );
gtk_box_pack_start (GTK_BOX(direction_hb), direction_ref_button, TRUE, FALSE, 0);
gtk_widget_set_sensitive ( direction_sb, FALSE );
direction_signal_id = g_signal_connect ( G_OBJECT(direction_ref_button), "button-release-event", G_CALLBACK(direction_add_click), direction_sb );
}
#endif
}
timelabel = gtk_label_new ( _("Time:") );
timevaluebutton = gtk_button_new();
gtk_button_set_relief ( GTK_BUTTON(timevaluebutton), GTK_RELIEF_NONE );
// TODO: Consider if there should be a remove time button...
if ( !is_new && wp->has_timestamp ) {
update_time ( timevaluebutton, wp );
}
else {
GtkWidget *img = gtk_image_new_from_stock ( GTK_STOCK_ADD, GTK_ICON_SIZE_MENU );
gtk_button_set_image ( GTK_BUTTON(timevaluebutton), img );
// Initially use current time or otherwise whatever the last value used was
if ( edit_wp->timestamp == 0 ) {
time ( &edit_wp->timestamp );
}
}
g_signal_connect ( G_OBJECT(timevaluebutton), "button-release-event", G_CALLBACK(time_edit_click), edit_wp );
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), latlabel, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), latentry, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), lonlabel, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), lonentry, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), timelabel, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), timevaluebutton, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), altlabel, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), altentry, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), commentlabel, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), commententry, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), descriptionlabel, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), descriptionentry, FALSE, FALSE, 0);
if ( wp->source ) {
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), sourcelabel, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), sourceentry, FALSE, FALSE, 0);
}
if ( wp->type ) {
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), typelabel, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), typeentry, FALSE, FALSE, 0);
}
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), imagelabel, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), imageentry, FALSE, FALSE, 0);
if ( hasGeotagCB ) {
GtkWidget *hbox = gtk_hbox_new ( FALSE, 0 );
gtk_box_pack_start (GTK_BOX(hbox), hasGeotagCB, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(hbox), consistentGeotagCB, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), hbox, FALSE, FALSE, 0);
}
if ( direction_hb )
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), direction_hb, FALSE, FALSE, 0);
if ( direction_sb )
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), direction_sb, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), symbollabel, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), GTK_WIDGET(symbolentry), FALSE, FALSE, 0);
gtk_dialog_set_default_response ( GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT );
gtk_widget_show_all ( gtk_dialog_get_content_area(GTK_DIALOG(dialog)) );
if ( !is_new ) {
// Shift left<->right to try not to obscure the waypoint.
trw_layer_dialog_shift ( vtl, GTK_WINDOW(dialog), &(wp->coord), FALSE );
}
while ( gtk_dialog_run ( GTK_DIALOG(dialog) ) == GTK_RESPONSE_ACCEPT )
{
if ( strlen((gchar*)gtk_entry_get_text ( GTK_ENTRY(nameentry) )) == 0 ) /* TODO: other checks (isalpha or whatever ) */
a_dialog_info_msg ( parent, _("Please enter a name for the waypoint.") );
else {
// NB: No check for unique names - this allows generation of same named entries.
gchar *entered_name = g_strdup ( (gchar*)gtk_entry_get_text ( GTK_ENTRY(nameentry) ) );
/* Do It */
ll.lat = convert_dms_to_dec ( gtk_entry_get_text ( GTK_ENTRY(latentry) ) );
ll.lon = convert_dms_to_dec ( gtk_entry_get_text ( GTK_ENTRY(lonentry) ) );
vik_coord_load_from_latlon ( &(wp->coord), coord_mode, &ll );
// Always store in metres
switch (height_units) {
case VIK_UNITS_HEIGHT_METRES:
wp->altitude = atof ( gtk_entry_get_text ( GTK_ENTRY(altentry) ) );
break;
case VIK_UNITS_HEIGHT_FEET:
wp->altitude = VIK_FEET_TO_METERS(atof ( gtk_entry_get_text ( GTK_ENTRY(altentry) ) ));
break;
default:
wp->altitude = atof ( gtk_entry_get_text ( GTK_ENTRY(altentry) ) );
g_critical("Houston, we've had a problem. height=%d", height_units);
}
if ( g_strcmp0 ( wp->comment, gtk_entry_get_text ( GTK_ENTRY(commententry) ) ) )
vik_waypoint_set_comment ( wp, gtk_entry_get_text ( GTK_ENTRY(commententry) ) );
if ( g_strcmp0 ( wp->description, gtk_entry_get_text ( GTK_ENTRY(descriptionentry) ) ) )
vik_waypoint_set_description ( wp, gtk_entry_get_text ( GTK_ENTRY(descriptionentry) ) );
if ( g_strcmp0 ( wp->image, vik_file_entry_get_filename ( VIK_FILE_ENTRY(imageentry) ) ) )
vik_waypoint_set_image ( wp, vik_file_entry_get_filename ( VIK_FILE_ENTRY(imageentry) ) );
if ( sourceentry && g_strcmp0 ( wp->source, gtk_entry_get_text ( GTK_ENTRY(sourceentry) ) ) )
vik_waypoint_set_source ( wp, gtk_entry_get_text ( GTK_ENTRY(sourceentry) ) );
if ( typeentry && g_strcmp0 ( wp->type, gtk_entry_get_text ( GTK_ENTRY(typeentry) ) ) )
vik_waypoint_set_type ( wp, gtk_entry_get_text ( GTK_ENTRY(typeentry) ) );
if ( wp->image && *(wp->image) && (!a_thumbnails_exists(wp->image)) )
a_thumbnails_create ( wp->image );
if ( edit_wp->timestamp ) {
wp->timestamp = edit_wp->timestamp;
wp->has_timestamp = TRUE;
}
if ( direction_sb ) {
if ( gtk_widget_get_sensitive (direction_sb) ) {
wp->image_direction = gtk_spin_button_get_value ( GTK_SPIN_BUTTON(direction_sb) );
if ( wp->image_direction != edit_wp->image_direction )
a_geotag_write_exif_gps ( wp->image, wp->coord, wp->altitude, wp->image_direction, wp->image_direction_ref, TRUE );
}
}
GtkTreeIter iter, first;
gtk_tree_model_get_iter_first ( GTK_TREE_MODEL(store), &first );
if ( !gtk_combo_box_get_active_iter ( GTK_COMBO_BOX(symbolentry), &iter ) || !memcmp(&iter, &first, sizeof(GtkTreeIter)) ) {
vik_waypoint_set_symbol ( wp, NULL );
} else {
gchar *sym;
gtk_tree_model_get ( GTK_TREE_MODEL(store), &iter, 0, (void *)&sym, -1 );
vik_waypoint_set_symbol ( wp, sym );
g_free(sym);
}
gtk_widget_destroy ( dialog );
if ( is_new )
return entered_name;
else {
*updated = TRUE;
// See if name has been changed
if ( g_strcmp0 (default_name, entered_name ) )
return entered_name;
else
return NULL;
}
}
}
gtk_widget_destroy ( dialog );
return NULL;
}
void termit_preferences_dialog(struct TermitTab *pTab)
{
// store font_name, foreground, background
struct TermitDlgHelper* hlp = termit_dlg_helper_new(pTab);
GtkStockItem item = {};
gtk_stock_lookup(GTK_STOCK_PREFERENCES, &item); // may be memory leak inside
GtkWidget* dialog = gtk_dialog_new_with_buttons(item.label,
GTK_WINDOW_TOPLEVEL,
GTK_DIALOG_DESTROY_WITH_PARENT | GTK_DIALOG_MODAL,
GTK_STOCK_CANCEL, GTK_RESPONSE_NONE,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
g_signal_connect(G_OBJECT(dialog), "key-press-event", G_CALLBACK(dlg_key_press), dialog);
GtkWidget* dlg_table = gtk_table_new(5, 2, FALSE);
#define TERMIT_PREFERENCE_ROW(pref_name, widget) \
gtk_table_attach(GTK_TABLE(dlg_table), gtk_label_new(pref_name), 0, 1, row, row + 1, 0, 0, 0, 0); \
gtk_table_attach_defaults(GTK_TABLE(dlg_table), widget, 1, 2, row, row + 1); \
hlp->widget = widget; \
row++;
#define TERMIT_PREFERENCE_ROW2(pref_widget, widget) \
gtk_table_attach(GTK_TABLE(dlg_table), pref_widget, 0, 1, row, row + 1, 0, 0, 0, 0); \
gtk_table_attach_defaults(GTK_TABLE(dlg_table), widget, 1, 2, row, row + 1); \
hlp->widget = widget; \
row++;
gboolean apply_to_all_tabs_flag = FALSE;
GtkWidget* entry_title = gtk_entry_new();
guint row = 0;
{ // tab title
gtk_entry_set_text(GTK_ENTRY(entry_title), hlp->tab_title);
TERMIT_PREFERENCE_ROW(_("Title"), entry_title);
}
// font selection
GtkWidget* btn_font = gtk_font_button_new_with_font(pTab->style.font_name);
g_signal_connect(btn_font, "font-set", G_CALLBACK(dlg_set_font), pTab);
TERMIT_PREFERENCE_ROW(_("Font"), btn_font);
// foreground
GtkWidget* btn_foreground = (pTab->style.foreground_color)
? gtk_color_button_new_with_color(pTab->style.foreground_color)
: gtk_color_button_new();
g_signal_connect(btn_foreground, "color-set", G_CALLBACK(dlg_set_foreground), pTab);
TERMIT_PREFERENCE_ROW(_("Foreground"), btn_foreground);
// background
GtkWidget* btn_background = (pTab->style.background_color)
? gtk_color_button_new_with_color(pTab->style.background_color)
: gtk_color_button_new();
g_signal_connect(btn_background, "color-set", G_CALLBACK(dlg_set_background), pTab);
TERMIT_PREFERENCE_ROW(_("Background"), btn_background);
// background image
GtkWidget* btn_image_file = gtk_file_chooser_button_new(pTab->style.image_file,
GTK_FILE_CHOOSER_ACTION_OPEN);
GtkFileFilter* filter = gtk_file_filter_new();
gtk_file_filter_set_name(filter, _("images"));
gtk_file_filter_add_mime_type(filter, "image/*");
if (pTab->style.image_file) {
gtk_file_chooser_select_filename(GTK_FILE_CHOOSER(btn_image_file), pTab->style.image_file);
}
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(btn_image_file), filter);
g_signal_connect(btn_image_file, "file-set", G_CALLBACK(dlg_set_image_file), pTab);
g_signal_connect(btn_image_file, "key-press-event", G_CALLBACK(dlg_clear_image_file), pTab);
GtkWidget* btn_switch_image_file = gtk_check_button_new_with_label(_("Background image"));
if (pTab->style.image_file) {
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(btn_switch_image_file), TRUE);
}
/*g_signal_connect(btn_switch_image_file, "toggled", G_CALLBACK(dlg_switch_image_file), btn_image_file);*/
/*TERMIT_PREFERENCE_ROW2(btn_switch_image_file, btn_image_file);*/
TERMIT_PREFERENCE_ROW(_("Image"), btn_image_file);
// transparency
GtkWidget* scale_transparency = gtk_spin_button_new_with_range(0, 1, 0.05);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(scale_transparency), pTab->style.transparency);
g_signal_connect(scale_transparency, "value-changed", G_CALLBACK(dlg_set_transparency), pTab);
TERMIT_PREFERENCE_ROW(_("Transparency"), scale_transparency);
// audible_bell
GtkWidget* audible_bell = gtk_check_button_new();
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(audible_bell), pTab->audible_bell);
g_signal_connect(audible_bell, "toggled", G_CALLBACK(dlg_set_audible_bell), pTab);
TERMIT_PREFERENCE_ROW(_("Audible bell"), audible_bell);
// visible_bell
GtkWidget* visible_bell = gtk_check_button_new();
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(visible_bell), pTab->visible_bell);
g_signal_connect(visible_bell, "toggled", G_CALLBACK(dlg_set_visible_bell), pTab);
TERMIT_PREFERENCE_ROW(_("Visible bell"), visible_bell);
// apply to al tabs
GtkWidget* btn_apply_to_all_tabs = gtk_check_button_new();
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(btn_apply_to_all_tabs), FALSE);
g_signal_connect(btn_apply_to_all_tabs, "toggled", G_CALLBACK(dlg_set_apply_to_all_tabs), &apply_to_all_tabs_flag);
TERMIT_PREFERENCE_ROW(_("Apply to all tabs"), btn_apply_to_all_tabs);
GtkWidget* btn_restore = gtk_button_new_from_stock(GTK_STOCK_REVERT_TO_SAVED);
g_signal_connect(G_OBJECT(btn_restore), "clicked", G_CALLBACK(dlg_restore_defaults), hlp);
gtk_table_attach(GTK_TABLE(dlg_table), btn_restore, 1, 2, row, row + 1, 0, 0, 0, 0);
gtk_container_add(GTK_CONTAINER(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), dlg_table);
gtk_widget_show_all(dialog);
if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_OK) {
dlg_set_tab_default_values(pTab, hlp);
} else {
if (apply_to_all_tabs_flag) {
gint page_num = gtk_notebook_get_n_pages(GTK_NOTEBOOK(termit.notebook));
gint i=0;
for (; i<page_num; ++i) {
TERMIT_GET_TAB_BY_INDEX(pTab, i, continue);
dlg_set_font(GTK_FONT_BUTTON(btn_font), pTab);
dlg_set_foreground(GTK_COLOR_BUTTON(btn_foreground), pTab);
dlg_set_background(GTK_COLOR_BUTTON(btn_background), pTab);
dlg_set_transparency(GTK_SPIN_BUTTON(scale_transparency), pTab);
dlg_set_image_file(GTK_FILE_CHOOSER_BUTTON(btn_image_file), pTab);
dlg_set_audible_bell(GTK_TOGGLE_BUTTON(audible_bell), pTab);
dlg_set_visible_bell(GTK_TOGGLE_BUTTON(visible_bell), pTab);
}
}
// insane title flag
if (pTab->title ||
(!pTab->title &&
strcmp(gtk_label_get_text(GTK_LABEL(pTab->tab_name)),
gtk_entry_get_text(GTK_ENTRY(entry_title))) != 0)) {
termit_tab_set_title(pTab, gtk_entry_get_text(GTK_ENTRY(entry_title)));
}
}
termit_dlg_helper_free(hlp);
gtk_widget_destroy(dialog);
}
static void _admin_resv(GtkTreeModel *model, GtkTreeIter *iter, char *type)
{
resv_desc_msg_t *resv_msg = xmalloc(sizeof(resv_desc_msg_t));
reservation_name_msg_t resv_name_msg;
char *resvid = NULL;
char tmp_char[100];
char *temp = NULL;
int edit_type = 0;
int response = 0;
GtkWidget *label = NULL;
GtkWidget *entry = NULL;
GtkWidget *popup = gtk_dialog_new_with_buttons(
type,
GTK_WINDOW(main_window),
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
NULL);
gtk_window_set_transient_for(GTK_WINDOW(popup), NULL);
gtk_tree_model_get(model, iter, SORTID_NAME, &resvid, -1);
slurm_init_resv_desc_msg(resv_msg);
memset(&resv_name_msg, 0, sizeof(reservation_name_msg_t));
resv_msg->name = xstrdup(resvid);
if (!strcasecmp("Remove Reservation", type)) {
resv_name_msg.name = resvid;
label = gtk_dialog_add_button(GTK_DIALOG(popup),
GTK_STOCK_YES, GTK_RESPONSE_OK);
gtk_window_set_default(GTK_WINDOW(popup), label);
gtk_dialog_add_button(GTK_DIALOG(popup),
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL);
snprintf(tmp_char, sizeof(tmp_char),
"Are you sure you want to remove "
"reservation %s?",
resvid);
label = gtk_label_new(tmp_char);
edit_type = EDIT_REMOVE;
} else {
label = gtk_dialog_add_button(GTK_DIALOG(popup),
GTK_STOCK_OK, GTK_RESPONSE_OK);
gtk_window_set_default(GTK_WINDOW(popup), label);
gtk_dialog_add_button(GTK_DIALOG(popup),
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL);
gtk_window_set_default_size(GTK_WINDOW(popup), 200, 400);
snprintf(tmp_char, sizeof(tmp_char),
"Editing reservation %s think before you type",
resvid);
label = gtk_label_new(tmp_char);
edit_type = EDIT_EDIT;
entry = _admin_full_edit_resv(resv_msg, model, iter);
}
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(popup)->vbox),
label, FALSE, FALSE, 0);
if (entry)
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(popup)->vbox),
entry, TRUE, TRUE, 0);
gtk_widget_show_all(popup);
response = gtk_dialog_run (GTK_DIALOG(popup));
if (response == GTK_RESPONSE_OK) {
switch(edit_type) {
case EDIT_REMOVE:
if (slurm_delete_reservation(&resv_name_msg)
== SLURM_SUCCESS) {
temp = g_strdup_printf(
"Reservation %s removed successfully",
resvid);
} else {
temp = g_strdup_printf(
"Problem removing reservation %s.",
resvid);
}
display_edit_note(temp);
g_free(temp);
break;
case EDIT_EDIT:
if (got_edit_signal)
goto end_it;
if (!global_send_update_msg) {
temp = g_strdup_printf("No change detected.");
} else if (slurm_update_reservation(resv_msg)
== SLURM_SUCCESS) {
temp = g_strdup_printf(
"Reservation %s updated successfully",
resvid);
} else {
temp = g_strdup_printf(
"Problem updating reservation %s.",
resvid);
}
display_edit_note(temp);
g_free(temp);
break;
default:
break;
}
}
end_it:
g_free(resvid);
global_entry_changed = 0;
slurm_free_resv_desc_msg(resv_msg);
gtk_widget_destroy(popup);
if (got_edit_signal) {
type = got_edit_signal;
got_edit_signal = NULL;
_admin_resv(model, iter, type);
xfree(type);
}
return;
}
void project_new(void)
{
GtkWidget *vbox;
GtkWidget *table;
GtkWidget *image;
GtkWidget *button;
GtkWidget *bbox;
GtkWidget *label;
PropertyDialogElements *e;
if (! project_ask_close())
return;
g_return_if_fail(app->project == NULL);
e = g_new0(PropertyDialogElements, 1);
e->dialog = gtk_dialog_new_with_buttons(_("New Project"), GTK_WINDOW(main_widgets.window),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NULL);
gtk_widget_set_name(e->dialog, "GeanyDialogProject");
bbox = gtk_hbox_new(FALSE, 0);
button = gtk_button_new();
image = gtk_image_new_from_stock("gtk-new", GTK_ICON_SIZE_BUTTON);
label = gtk_label_new_with_mnemonic(_("C_reate"));
gtk_box_pack_start(GTK_BOX(bbox), image, FALSE, FALSE, 3);
gtk_box_pack_start(GTK_BOX(bbox), label, FALSE, FALSE, 3);
gtk_container_add(GTK_CONTAINER(button), bbox);
gtk_dialog_add_action_widget(GTK_DIALOG(e->dialog), button, GTK_RESPONSE_OK);
vbox = ui_dialog_vbox_new(GTK_DIALOG(e->dialog));
entries_modified = FALSE;
table = gtk_table_new(3, 2, FALSE);
gtk_table_set_row_spacings(GTK_TABLE(table), 5);
gtk_table_set_col_spacings(GTK_TABLE(table), 10);
label = gtk_label_new(_("Name:"));
gtk_misc_set_alignment(GTK_MISC(label), 1, 0);
e->name = gtk_entry_new();
ui_entry_add_clear_icon(GTK_ENTRY(e->name));
gtk_entry_set_max_length(GTK_ENTRY(e->name), MAX_NAME_LEN);
ui_table_add_row(GTK_TABLE(table), 0, label, e->name, NULL);
label = gtk_label_new(_("Filename:"));
gtk_misc_set_alignment(GTK_MISC(label), 1, 0);
e->file_name = gtk_entry_new();
ui_entry_add_clear_icon(GTK_ENTRY(e->file_name));
gtk_entry_set_width_chars(GTK_ENTRY(e->file_name), 30);
button = gtk_button_new();
g_signal_connect(button, "clicked", G_CALLBACK(on_file_save_button_clicked), e);
image = gtk_image_new_from_stock("gtk-open", GTK_ICON_SIZE_BUTTON);
gtk_container_add(GTK_CONTAINER(button), image);
bbox = gtk_hbox_new(FALSE, 6);
gtk_box_pack_start_defaults(GTK_BOX(bbox), e->file_name);
gtk_box_pack_start(GTK_BOX(bbox), button, FALSE, FALSE, 0);
ui_table_add_row(GTK_TABLE(table), 1, label, bbox, NULL);
label = gtk_label_new(_("Base path:"));
gtk_misc_set_alignment(GTK_MISC(label), 1, 0);
e->base_path = gtk_entry_new();
ui_entry_add_clear_icon(GTK_ENTRY(e->base_path));
gtk_widget_set_tooltip_text(e->base_path,
_("Base directory of all files that make up the project. "
"This can be a new path, or an existing directory tree. "
"You can use paths relative to the project filename."));
bbox = ui_path_box_new(_("Choose Project Base Path"),
GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER, GTK_ENTRY(e->base_path));
ui_table_add_row(GTK_TABLE(table), 2, label, bbox, NULL);
gtk_container_add(GTK_CONTAINER(vbox), table);
/* signals */
g_signal_connect(e->name, "changed", G_CALLBACK(on_name_entry_changed), e);
/* run the callback manually to initialise the base_path and file_name fields */
on_name_entry_changed(GTK_EDITABLE(e->name), e);
g_signal_connect(e->file_name, "changed", G_CALLBACK(on_entries_changed), e);
g_signal_connect(e->base_path, "changed", G_CALLBACK(on_entries_changed), e);
gtk_widget_show_all(e->dialog);
while (gtk_dialog_run(GTK_DIALOG(e->dialog)) == GTK_RESPONSE_OK)
{
if (update_config(e, TRUE))
{
if (!write_config(TRUE))
SHOW_ERR(_("Project file could not be written"));
else
{
ui_set_statusbar(TRUE, _("Project \"%s\" created."), app->project->name);
ui_add_recent_project_file(app->project->file_name);
break;
}
}
}
gtk_widget_destroy(e->dialog);
g_free(e);
}
static void create_dialog_find_file(void)
{
GtkWidget *label, *vbox, *ebox, *entry;
GtkSizeGroup *size_group;
if (s_ft_dialog.widget)
return;
s_ft_dialog.widget = gtk_dialog_new_with_buttons(
_("Find Tag"), GTK_WINDOW(geany->main_widgets->window),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NULL);
gtk_dialog_add_button(GTK_DIALOG(s_ft_dialog.widget), "gtk-find", GTK_RESPONSE_ACCEPT);
gtk_dialog_set_default_response(GTK_DIALOG(s_ft_dialog.widget), GTK_RESPONSE_ACCEPT);
vbox = ui_dialog_vbox_new(GTK_DIALOG(s_ft_dialog.widget));
gtk_box_set_spacing(GTK_BOX(vbox), 9);
size_group = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
label = gtk_label_new_with_mnemonic(_("_Search for:"));
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
gtk_size_group_add_widget(size_group, label);
s_ft_dialog.combo = gtk_combo_box_text_new_with_entry();
entry = gtk_bin_get_child(GTK_BIN(s_ft_dialog.combo));
ui_entry_add_clear_icon(GTK_ENTRY(entry));
gtk_entry_set_width_chars(GTK_ENTRY(entry), 40);
gtk_label_set_mnemonic_widget(GTK_LABEL(label), entry);
ui_entry_add_clear_icon(GTK_ENTRY(entry));
gtk_entry_set_activates_default(GTK_ENTRY(entry), TRUE);
ebox = gtk_hbox_new(FALSE, 6);
gtk_box_pack_start(GTK_BOX(ebox), label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(ebox), s_ft_dialog.combo, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), ebox, TRUE, FALSE, 0);
label = gtk_label_new_with_mnemonic(_("_Match type:"));
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
gtk_size_group_add_widget(size_group, label);
s_ft_dialog.combo_match = gtk_combo_box_text_new();
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(s_ft_dialog.combo_match), _("exact"));
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(s_ft_dialog.combo_match), _("prefix"));
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(s_ft_dialog.combo_match), _("pattern"));
gtk_combo_box_set_active(GTK_COMBO_BOX(s_ft_dialog.combo_match), 1);
gtk_label_set_mnemonic_widget(GTK_LABEL(label), s_ft_dialog.combo_match);
ebox = gtk_hbox_new(FALSE, 6);
gtk_box_pack_start(GTK_BOX(ebox), label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(ebox), s_ft_dialog.combo_match, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), ebox, TRUE, FALSE, 0);
s_ft_dialog.case_sensitive = gtk_check_button_new_with_mnemonic(_("C_ase sensitive"));
gtk_button_set_focus_on_click(GTK_BUTTON(s_ft_dialog.case_sensitive), FALSE);
s_ft_dialog.declaration = gtk_check_button_new_with_mnemonic(_("_Declaration"));
gtk_button_set_focus_on_click(GTK_BUTTON(s_ft_dialog.declaration), FALSE);
g_object_unref(G_OBJECT(size_group)); /* auto destroy the size group */
gtk_container_add(GTK_CONTAINER(vbox), s_ft_dialog.case_sensitive);
gtk_container_add(GTK_CONTAINER(vbox), s_ft_dialog.declaration);
gtk_widget_show_all(vbox);
}
/*!
\brief personality_choice() is called from a one shot timeout from main
in order to open the window to ask the user what ECU family to deal with
running.
*/
G_MODULE_EXPORT gboolean personality_choice(void)
{
GtkWidget *dialog = NULL;
GtkWidget *vbox = NULL;
GtkWidget *hbox = NULL;
GtkWidget *ebox = NULL;
GtkWidget *sep = NULL;
GtkWidget *button = NULL;
GtkWidget *label = NULL;
gchar ** dirs = NULL;
gchar * filename = NULL;
PersonaElement *element = NULL;
gchar *tmpbuf = NULL;
gboolean shouldjump = FALSE;
gchar *name = NULL;
GArray *classes = NULL;
GSList *group = NULL;
GList *p_list = NULL;
GList *s_list = NULL;
ConfigFile *cfgfile = NULL;
guint i = 0;
gint result = 0;
gchar * pathstub = NULL;
extern gconstpointer *global_data;
pathstub = g_build_filename(INTERROGATOR_DATA_DIR,"Profiles",NULL);
dirs = get_dirs((const gchar *)DATA_GET(global_data,"project_name"),pathstub,&classes);
if (!dirs)
{
MTXDBG(CRITICAL,_("NO Interrogation profiles found, was MegaTunix installed properly?\n"));
return FALSE;
}
i = 0;
while (dirs[i])
{
tmpbuf = g_build_filename(dirs[i],"details.cfg",NULL);
cfgfile = cfg_open_file(tmpbuf);
if (!cfgfile)
{
/*MTXDBG(CRITICAL,_("\"%s\" file missing!, was MegaTunix installed properly?\n"),tmpbuf);*/
i++;
g_free(tmpbuf);
continue;
}
g_free(tmpbuf);
element = g_new0(PersonaElement, 1);
cfg_read_string(cfgfile,"Family","sequence",&element->sequence);
cfg_read_string(cfgfile,"Family","friendly_name",&element->name);
cfg_read_string(cfgfile,"Family","persona",&element->persona);
cfg_read_string(cfgfile,"Family","ecu_lib",&element->ecu_lib);
cfg_read_string(cfgfile,"Family","common_lib",&element->common_lib);
if (!cfg_read_string(cfgfile,"Family","baud",&element->baud_str))
MTXDBG(CRITICAL,_("\"details.cfg\" baud string undefined!, was MegaTunix installed properly?\n"));
element->dirname = g_strdup(dirs[i]);
element->filename = g_path_get_basename(dirs[i]);
if (g_strcasecmp(element->filename,(gchar *)DATA_GET(global_data,"last_ecu_family")) == 0)
element->def = TRUE;
if ((DATA_GET(global_data,"cli_persona")) && (element->persona))
{
if (g_strcasecmp(element->persona, (gchar *)DATA_GET(global_data,"cli_persona")) == 0)
{
button = gtk_toggle_button_new();
gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(button),TRUE);
persona_selection(button,(gpointer)element);
g_object_ref_sink(button);
g_object_unref(button);
shouldjump = TRUE;
}
}
if (g_array_index(classes,FileClass,i) == PERSONAL)
p_list = g_list_prepend(p_list,(gpointer)element);
if (g_array_index(classes,FileClass,i) == SYSTEM)
s_list = g_list_prepend(s_list,(gpointer)element);
g_free(name);
i++;
cfg_free(cfgfile);
}
p_list = g_list_sort(p_list,persona_seq_sort);
s_list = g_list_sort(s_list,persona_seq_sort);
g_strfreev(dirs);
g_array_free(classes,TRUE);
if (shouldjump)
{
g_list_foreach(p_list,free_persona_element,NULL);
g_list_foreach(s_list,free_persona_element,NULL);
g_list_free(p_list);
g_list_free(s_list);
DATA_SET(global_data,"cli_persona",NULL);
if (DATA_GET(global_data,"offline"))
goto jumpahead_offline;
else
goto jumpahead;
}
set_title(g_strdup(_("Choose an ECU family?")));
update_logbar("interr_view","warning",_("Prompting user for ECU family to interrogate...\n"),FALSE,FALSE,FALSE);
dialog = gtk_dialog_new_with_buttons("Select ECU Personality",
GTK_WINDOW(lookup_widget("main_window")),
GTK_DIALOG_DESTROY_WITH_PARENT,
"Exit MegaTunix",
GTK_RESPONSE_CLOSE,
"Go Offline",
GTK_RESPONSE_CANCEL,
"Find my ECU",
GTK_RESPONSE_OK,
NULL);
vbox = gtk_vbox_new(TRUE,2);
gtk_container_set_border_width(GTK_CONTAINER(vbox),5);
//gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox),vbox,TRUE,TRUE,0);
gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))),vbox,TRUE,TRUE,0);
if (g_list_length(p_list) > 0)
{
label = gtk_label_new("Custom (personal) Profiles");
gtk_box_pack_start(GTK_BOX(vbox),label,TRUE,TRUE,0);
group = NULL;
/* Cycle list for PERSONAL profile files */
for (i=0;i<g_list_length(p_list);i++)
{
element = (PersonaElement *)g_list_nth_data(p_list,i);
ebox = gtk_event_box_new();
gtk_box_pack_start(GTK_BOX(vbox),ebox,TRUE,TRUE,0);
hbox = gtk_hbox_new(FALSE,10);
gtk_container_add(GTK_CONTAINER(ebox),hbox);
label = gtk_label_new(element->name);
gtk_box_pack_start(GTK_BOX(hbox),label,FALSE,TRUE,0);
if (!check_for_files (element->dirname,"prof"))
{
gtk_widget_set_sensitive(ebox,FALSE);
button = gtk_radio_button_new(NULL);
}
else
{
button = gtk_radio_button_new(group);
group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(button));
}
g_signal_connect(button,
"toggled",
G_CALLBACK(persona_selection),
element);
gtk_box_pack_end(GTK_BOX(hbox),button,FALSE,TRUE,0);
if (element->def)
{
gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(button),TRUE);
gtk_toggle_button_toggled(GTK_TOGGLE_BUTTON(button));
}
}
sep = gtk_hseparator_new();
gtk_box_pack_start(GTK_BOX(vbox),sep,TRUE,TRUE,0);
}
label = gtk_label_new("System Wide ECU Profiles");
gtk_box_pack_start(GTK_BOX(vbox),label,TRUE,TRUE,0);
/* Cycle list for System interogation files */
for (i=0;i<g_list_length(s_list);i++)
{
element = (PersonaElement *)g_list_nth_data(s_list,i);
ebox = gtk_event_box_new();
gtk_box_pack_start(GTK_BOX(vbox),ebox,TRUE,TRUE,0);
hbox = gtk_hbox_new(FALSE,10);
gtk_container_add(GTK_CONTAINER(ebox),hbox);
label = gtk_label_new(element->name);
gtk_box_pack_start(GTK_BOX(hbox),label,FALSE,TRUE,0);
if (!check_for_files (element->dirname,"prof"))
{
gtk_widget_set_sensitive(ebox,FALSE);
button = gtk_radio_button_new(NULL);
}
else
{
button = gtk_radio_button_new(group);
group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(button));
}
g_signal_connect(button,
"toggled",
G_CALLBACK(persona_selection),
element);
gtk_box_pack_end(GTK_BOX(hbox),button,FALSE,TRUE,0);
if (element->def)
{
gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(button),TRUE);
gtk_toggle_button_toggled(GTK_TOGGLE_BUTTON(button));
}
}
gtk_widget_show_all(dialog);
result = gtk_dialog_run(GTK_DIALOG(dialog));
gtk_widget_destroy(dialog);
g_list_foreach(p_list,free_persona_element,NULL);
g_list_foreach(s_list,free_persona_element,NULL);
g_list_free(p_list);
g_list_free(s_list);
switch (result)
{
case GTK_RESPONSE_CLOSE:
leave(NULL,NULL);
break;
case GTK_RESPONSE_ACCEPT:
case GTK_RESPONSE_OK: /* Normal mode */
jumpahead:
plugins_init();
pathstub = g_build_filename(INTERROGATOR_DATA_DIR,"Profiles",DATA_GET(global_data,"ecu_family"),"comm.xml",NULL);
filename = get_file((const gchar *)DATA_GET(global_data,"project_name"),pathstub,NULL);
g_free(pathstub);
load_comm_xml(filename);
g_free(filename);
io_cmd("interrogation",NULL);
break;
default: /* Offline */
jumpahead_offline:
plugins_init();
pathstub = g_build_filename(INTERROGATOR_DATA_DIR,"Profiles",DATA_GET(global_data,"ecu_family"),"comm.xml",NULL);
filename = get_file((const gchar *)DATA_GET(global_data,"project_name"),pathstub,NULL);
g_free(pathstub);
load_comm_xml(filename);
g_free(filename);
g_timeout_add(100,(GSourceFunc)set_offline_mode,NULL);
return FALSE;
}
return FALSE;
}
