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; }