static void logview_filter_manager_init (LogviewFilterManager *manager) { GtkWidget *table; GtkWidget *scrolled_window; GtkTreeViewColumn *column; GtkCellRenderer *text_renderer; LogviewFilterManagerPrivate *priv; manager->priv = LOGVIEW_FILTER_MANAGER_GET_PRIVATE (manager); priv = manager->priv; priv->builder = gtk_builder_new (); g_object_ref (priv->builder); priv->prefs = logview_prefs_get (); gtk_dialog_add_button (GTK_DIALOG(manager), GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE); gtk_window_set_modal (GTK_WINDOW (manager), TRUE); priv->model = GTK_TREE_MODEL (gtk_list_store_new (N_COLUMNS, G_TYPE_STRING, G_TYPE_OBJECT)); logview_filter_manager_update_model (manager); table = gtk_table_new (3, 2, FALSE); scrolled_window = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_window), GTK_SHADOW_ETCHED_IN); priv->tree = gtk_tree_view_new_with_model (priv->model); gtk_widget_set_size_request (priv->tree, 150, 200); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (priv->tree), FALSE); gtk_container_add (GTK_CONTAINER (scrolled_window), priv->tree); text_renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new(); gtk_tree_view_column_pack_start (column, text_renderer, TRUE); gtk_tree_view_column_set_attributes (column, text_renderer, "text", COLUMN_NAME, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (priv->tree), column); priv->add_button = gtk_button_new_from_stock (GTK_STOCK_ADD); priv->edit_button = gtk_button_new_from_stock (GTK_STOCK_PROPERTIES); priv->remove_button = gtk_button_new_from_stock (GTK_STOCK_REMOVE); gtk_window_set_title (GTK_WINDOW (manager), _("Filters")); g_signal_connect (priv->add_button, "clicked", G_CALLBACK (on_add_clicked), manager); g_signal_connect (priv->edit_button, "clicked", G_CALLBACK (on_edit_clicked), manager); g_signal_connect (priv->remove_button, "clicked", G_CALLBACK (on_remove_clicked), manager); gtk_widget_set_sensitive (priv->edit_button, FALSE); gtk_widget_set_sensitive (priv->remove_button, FALSE); g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->tree)), "changed", G_CALLBACK (on_tree_selection_changed), manager); gtk_table_attach_defaults (GTK_TABLE (table), scrolled_window, 0, 1, 0, 3); gtk_table_attach (GTK_TABLE (table), priv->add_button, 1, 2, 0, 1, GTK_FILL, 0, 5, 5); gtk_table_attach (GTK_TABLE (table), priv->edit_button, 1, 2, 1, 2, GTK_FILL, 0, 5, 5); gtk_table_attach (GTK_TABLE (table), priv->remove_button, 1, 2, 2, 3, GTK_FILL, 0, 5, 5); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (manager))), table, TRUE, TRUE, 5); gtk_widget_show_all (GTK_WIDGET (manager)); }
void DictMngr::CreateDictMngrDialog() { GtkWidget *dialog, *selector; GtkCellRenderer *renderer; HildonTouchSelectorColumn *column; GtkTreeModel *tree_model; GtkTreeIter iter; gboolean iter_valid = TRUE; std::list < std::string > all_dict_list; std::list < std::string > selected_dict_list; GtkListStore *dict_list = NULL; const gint RESPONSE_REORDER = 1; gint response; dict_list = gtk_list_store_new(N_DICT_INFO_COLUMNS, G_TYPE_STRING, /* bookname */ G_TYPE_STRING); /* filename */ /* create dialog */ dialog = gtk_dialog_new(); gtk_window_set_modal(GTK_WINDOW(dialog), TRUE); gtk_window_set_title(GTK_WINDOW(dialog), _("Dictionaries")); gtk_dialog_add_button(GTK_DIALOG(dialog), _("Reorder"), RESPONSE_REORDER); gtk_dialog_add_button(GTK_DIALOG(dialog), "OK", GTK_RESPONSE_ACCEPT); gtk_window_set_default_size(GTK_WINDOW(dialog), -1, 400); /* dictionary selector */ selector = hildon_touch_selector_new(); gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), selector); renderer = gtk_cell_renderer_text_new(); g_object_set(G_OBJECT(renderer), "xpad", 10, "ellipsize", PANGO_ELLIPSIZE_END, "ellipsize-set", TRUE, NULL); column = hildon_touch_selector_append_column(HILDON_TOUCH_SELECTOR (selector), GTK_TREE_MODEL(dict_list), renderer, "text", BOOKNAME_DICT_INFO_COLUMN, NULL); hildon_touch_selector_column_set_text_column(column, 0); /* fill list with all available dictionaries */ GetAllDictionaryList(all_dict_list); for (std::list < std::string >::iterator i = all_dict_list.begin(); i != all_dict_list.end(); ++i) { DictInfo dictinfo; dictinfo.load_from_ifo_file(i->c_str(), 0); gtk_list_store_append(dict_list, &iter); gtk_list_store_set(dict_list, &iter, BOOKNAME_DICT_INFO_COLUMN, dictinfo.bookname.c_str(), FILENAME_DICT_INFO_COLUMN, i->c_str(), -1); } g_object_unref(dict_list); /* set selector mode to multiple */ hildon_touch_selector_set_column_selection_mode(HILDON_TOUCH_SELECTOR (selector), HILDON_TOUCH_SELECTOR_SELECTION_MODE_MULTIPLE); hildon_touch_selector_unselect_all(HILDON_TOUCH_SELECTOR(selector), BOOKNAME_DICT_INFO_COLUMN); /* select all load dictionaries */ tree_model = hildon_touch_selector_get_model(HILDON_TOUCH_SELECTOR(selector), BOOKNAME_DICT_INFO_COLUMN); for (iter_valid = gtk_tree_model_get_iter_first(tree_model, &iter); iter_valid; iter_valid = gtk_tree_model_iter_next(tree_model, &iter)) { const gchar *bookname; gtk_tree_model_get(tree_model, &iter, BOOKNAME_DICT_INFO_COLUMN, &bookname, -1); for (size_t iLib = 0; iLib < oStarDict->oLibs->query_dictmask.size(); iLib++) { if (!strcmp(oStarDict->oLibs->dict_name(iLib).c_str(), bookname)) { hildon_touch_selector_select_iter(HILDON_TOUCH_SELECTOR (selector), BOOKNAME_DICT_INFO_COLUMN, &iter, FALSE); break; } } } /* show dialog */ gtk_widget_show_all(GTK_WIDGET(dialog)); /* run the dialog */ response = gtk_dialog_run(GTK_DIALOG(dialog)); if (response == GTK_RESPONSE_ACCEPT || response == RESPONSE_REORDER) { GList *selected_dicts = NULL; selected_dicts = hildon_touch_selector_get_selected_rows(HILDON_TOUCH_SELECTOR (selector), BOOKNAME_DICT_INFO_COLUMN); if (selected_dicts) { GList *dict = selected_dicts; const gchar *filename; while (dict) { gtk_tree_model_get_iter(GTK_TREE_MODEL(tree_model), &iter, (GtkTreePath *) (dict->data)); gtk_tree_model_get(GTK_TREE_MODEL(tree_model), &iter, FILENAME_DICT_INFO_COLUMN, &filename, -1); selected_dict_list.push_back(std::string(filename)); dict = dict->next; } g_list_foreach(selected_dicts, (GFunc) gtk_tree_path_free, NULL); g_list_free(selected_dicts); } if (oStarDict->oConf->SetStringList("/apps/maemo/mstardict/dict_list", selected_dict_list)) { /* reload dictionaries */ ReLoadDictionaries(selected_dict_list); } } gtk_widget_destroy(GTK_WIDGET(dialog)); if (response == RESPONSE_REORDER) { CreateReorderDialog(); } }
gint main(gint argc, gchar * argv[]){ GtkWidget *colorseldlg; GdkColor color; GtkColorSelection *colorsel; gint response; gint r, g, b; guint16 alpha=65535; float f; self = argv[0]; gtk_init(&argc, &argv); if(argc == 2){ g = 0; b = 0; if(argv[1][0] == 'r'){ if(argv[1][3] == 'a'){ //rgba(...) sscanf(argv[1], "rgba(%d, %d, %d, %f)", &r, &g, &b, &f); color.red = r * 256; color.green = g * 256; color.blue = b * 256; alpha = f * 65535; }else if(argv[1][3] == '('){ //rgb(...) sscanf(argv[1], "rgb(%d, %d, %d)", &r, &g, &b); color.red = r * 256; color.green = g * 256; color.blue = b * 256; }else{ usage(); return 2; } goto option_ok; } if(argv[1][0] == '#'){ b = 1; } for(r=b; r<b+6; r++){ if(!isxdigit(argv[1][r])){ usage(); return 2; } } if(b){ /* # 开头 */ argv[1] = (char*)((int)argv[1] + 1); } sscanf(argv[1], "%2x%2x%2x", &r, &g, &b); color.red = r * 256; color.green = g * 256; color.blue = b * 256; }else if(argc == 1){ color.red = 0xffff; color.green = 0xffff; color.blue = 0xffff; }else{ usage(); return 2; } option_ok: colorseldlg = gtk_color_selection_dialog_new("Select color"); colorsel = GTK_COLOR_SELECTION(GTK_COLOR_SELECTION_DIALOG(colorseldlg)->colorsel); gtk_color_selection_set_current_color(colorsel, &color); gtk_color_selection_set_has_palette(colorsel, TRUE); gtk_color_selection_set_has_opacity_control(colorsel, TRUE); gtk_color_selection_set_current_alpha(colorsel, alpha); gtk_window_set_position(GTK_WINDOW(colorseldlg), GTK_WIN_POS_MOUSE); gtk_window_set_keep_above(GTK_WINDOW(colorseldlg), TRUE); response = gtk_dialog_run(GTK_DIALOG(colorseldlg)); if(response == GTK_RESPONSE_OK){ gtk_color_selection_get_current_color(colorsel, &color); r = color.red / 256; g = color.green / 256; b = color.blue / 256; alpha = gtk_color_selection_get_current_alpha(colorsel); alpha /= 256; if(alpha == 255) printf("#%02x%02x%02x\n", r, g, b); else printf("rgba(%d, %d, %d, %.2f\n)", r, g, b, (float)alpha/256); }else /* 取消了 */ return 1; return 0; }
static void delete_button_clicked(GtkButton *button, gpointer user_data) { dt_lib_module_t *self = (dt_lib_module_t *)user_data; dt_lib_tagging_t *d = (dt_lib_tagging_t *)self->data; int res = GTK_RESPONSE_YES; guint tagid; GtkTreeIter iter; GtkTreeModel *model = NULL; GtkTreeView *view = d->related; GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(view)); if(!gtk_tree_selection_get_selected(selection, &model, &iter)) return; gtk_tree_model_get(model, &iter, DT_LIB_TAGGING_COL_ID, &tagid, -1); // First check how many images are affected by the remove int count = dt_tag_remove(tagid, FALSE); if(count > 0 && dt_conf_get_bool("plugins/lighttable/tagging/ask_before_delete_tag")) { GtkWidget *dialog; GtkWidget *win = dt_ui_main_window(darktable.gui->ui); gchar *tagname = dt_tag_get_name(tagid); dialog = gtk_message_dialog_new( GTK_WINDOW(win), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO, ngettext("do you really want to delete the tag `%s'?\n%d image is assigned this tag!", "do you really want to delete the tag `%s'?\n%d images are assigned this tag!", count), tagname, count); gtk_window_set_title(GTK_WINDOW(dialog), _("delete tag?")); res = gtk_dialog_run(GTK_DIALOG(dialog)); gtk_widget_destroy(dialog); free(tagname); } if(res != GTK_RESPONSE_YES) return; GList *tagged_images = NULL; sqlite3_stmt *stmt; DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db), "select imgid from tagged_images where tagid=?1", -1, &stmt, NULL); DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, tagid); while(sqlite3_step(stmt) == SQLITE_ROW) { tagged_images = g_list_append(tagged_images, GINT_TO_POINTER(sqlite3_column_int(stmt, 0))); } sqlite3_finalize(stmt); dt_tag_remove(tagid, TRUE); GList *list_iter; if((list_iter = g_list_first(tagged_images)) != NULL) { do { dt_image_synch_xmp(GPOINTER_TO_INT(list_iter->data)); } while((list_iter = g_list_next(list_iter)) != NULL); } g_list_free(g_list_first(tagged_images)); update(self, 0); update(self, 1); dt_control_signal_raise(darktable.signals, DT_SIGNAL_TAG_CHANGED); }
// sets up the file chooser dialog static void create_file_chooser_dialog() { GtkWidget *parent = get_widget_checked("ssv_main_window"); browse_widget = gtk_file_chooser_dialog_new( "Open Image File", GTK_WINDOW(parent), GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, //Cancel button GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, //Open button NULL); // we need to extract the buttons, so we can connect them to our // button handlers, above GtkHButtonBox *box = (GtkHButtonBox*)(((GtkDialog*)browse_widget)->action_area); GList *buttons = box->button_box.box.children; GtkWidget *cancel_btn = ((GtkBoxChild*)buttons->data)->widget; GtkWidget *ok_btn = ((GtkBoxChild*)buttons->next->data)->widget; g_signal_connect((gpointer)cancel_btn, "clicked", G_CALLBACK(new_cancel_clicked), NULL); g_signal_connect((gpointer)ok_btn, "clicked", G_CALLBACK(new_ok_clicked), NULL); g_signal_connect(browse_widget, "destroy", G_CALLBACK(browse_widget_destroy), NULL); g_signal_connect(browse_widget, "destroy_event", G_CALLBACK(browse_widget_destroy), NULL); g_signal_connect(browse_widget, "delete_event", G_CALLBACK(browse_widget_destroy), NULL); // add the filters GtkFileFilter *D_filt = gtk_file_filter_new(); gtk_file_filter_set_name(D_filt, "CEOS Data Files (*.D)"); gtk_file_filter_add_pattern(D_filt, "*.D"); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(browse_widget), D_filt); GtkFileFilter *alos2_filt = gtk_file_filter_new(); gtk_file_filter_set_name(alos2_filt, "ALOS Image Files (IMG-*)"); gtk_file_filter_add_pattern(alos2_filt, "IMG-*"); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(browse_widget), alos2_filt); GtkFileFilter *img_filt = gtk_file_filter_new(); gtk_file_filter_set_name(img_filt, "ASF Internal Files (*.img)"); gtk_file_filter_add_pattern(img_filt, "*.img"); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(browse_widget), img_filt); GtkFileFilter *airsar_filt = gtk_file_filter_new(); gtk_file_filter_set_name(airsar_filt, "AirSAR Files"); gtk_file_filter_add_pattern(airsar_filt, "*.vvi2"); gtk_file_filter_add_pattern(airsar_filt, "*.demi2"); gtk_file_filter_add_pattern(airsar_filt, "*.corgr"); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(browse_widget), airsar_filt); GtkFileFilter *tiff_filt = gtk_file_filter_new(); gtk_file_filter_set_name(tiff_filt, "GeoTIFF Image Files (*.tif)"); gtk_file_filter_add_pattern(tiff_filt, "*.tif"); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(browse_widget), tiff_filt); GtkFileFilter *tsx_filt = gtk_file_filter_new(); gtk_file_filter_set_name(tsx_filt, "TerraSAR-X Files (*.xml)"); gtk_file_filter_add_pattern(tsx_filt, "*.xml"); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(browse_widget), tsx_filt); GtkFileFilter *jpg_filt = gtk_file_filter_new(); gtk_file_filter_set_name(jpg_filt, "JPEG Image Files (*.jpg)"); gtk_file_filter_add_pattern(jpg_filt, "*.jpg"); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(browse_widget), jpg_filt); GtkFileFilter *png_filt = gtk_file_filter_new(); gtk_file_filter_set_name(png_filt, "PNG Image Files (*.png)"); gtk_file_filter_add_pattern(png_filt, "*.png"); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(browse_widget), png_filt); GtkFileFilter *pgm_filt = gtk_file_filter_new(); gtk_file_filter_set_name(pgm_filt, "PGM Image Files (*.pgm)"); gtk_file_filter_add_pattern(pgm_filt, "*.pgm"); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(browse_widget), pgm_filt); GtkFileFilter *envi_filt = gtk_file_filter_new(); gtk_file_filter_set_name(envi_filt, "ENVI Files (*.hdr)"); gtk_file_filter_add_pattern(envi_filt, "*.hdr"); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(browse_widget), envi_filt); GtkFileFilter *roipac_filt = gtk_file_filter_new(); gtk_file_filter_set_name(roipac_filt, "ROI_PAC Files (*.rsc)"); gtk_file_filter_add_pattern(roipac_filt, "*.rsc"); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(browse_widget), roipac_filt); //GtkFileFilter *ppm_filt = gtk_file_filter_new(); //gtk_file_filter_set_name(ppm_filt, "PPM Image Files (*.ppm)"); //gtk_file_filter_add_pattern(ppm_filt, "*.ppm"); //gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(browse_widget), ppm_filt); GtkFileFilter *all_filt = gtk_file_filter_new(); gtk_file_filter_set_name(all_filt, "All Files (*.*)"); gtk_file_filter_add_pattern(all_filt, "*"); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(browse_widget), all_filt); // allow multi-select gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(browse_widget), TRUE); // we need to make these modal -- if the user opens multiple "open" // dialogs, we'll get confused on the callbacks gtk_window_set_modal(GTK_WINDOW(browse_widget), TRUE); gtk_window_set_destroy_with_parent(GTK_WINDOW(browse_widget), TRUE); gtk_dialog_set_default_response(GTK_DIALOG(browse_widget), GTK_RESPONSE_OK); }
GtkWidget *create_dialog1 (void) { GtkWidget *dialog1; GtkWidget *dialog_vbox1; GtkWidget *table1; GtkWidget *label1; GtkWidget *label2; GtkWidget *label3; GtkWidget *label4; GtkWidget *label5; GtkWidget *label6; GtkWidget *label7; GtkWidget *label8; GtkObject *spinbuttonTreshold_adj; GtkWidget *spinbuttonTreshold; GtkObject *spinbuttonNoise_adj; GtkWidget *spinbuttonNoise; GtkObject *spinbuttonIdentical_adj; GtkWidget *spinbuttonIdentical; GtkWidget *checkbuttonShow; GtkWidget *dialog_action_area1; GtkWidget *cancelbutton1; GtkWidget *okbutton1; GtkTooltips *tooltips; tooltips = gtk_tooltips_new (); dialog1 = gtk_dialog_new (); gtk_window_set_title (GTK_WINDOW (dialog1), _("Blend removal / Hard pulldown removal")); gtk_window_set_type_hint (GTK_WINDOW (dialog1), GDK_WINDOW_TYPE_HINT_DIALOG); dialog_vbox1 = GTK_DIALOG (dialog1)->vbox; gtk_widget_show (dialog_vbox1); table1 = gtk_table_new (4, 3, FALSE); gtk_widget_show (table1); gtk_box_pack_start (GTK_BOX (dialog_vbox1), table1, TRUE, TRUE, 0); label1 = gtk_label_new (_("%")); gtk_widget_show (label1); gtk_table_attach (GTK_TABLE (table1), label1, 2, 3, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label1), 0, 0.5); label2 = gtk_label_new (_("%")); gtk_widget_show (label2); gtk_table_attach (GTK_TABLE (table1), label2, 2, 3, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label2), 0, 0.5); label3 = gtk_label_new (_("%")); gtk_widget_show (label3); gtk_table_attach (GTK_TABLE (table1), label3, 2, 3, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label3), 0, 0.5); label4 = gtk_label_new (_(" ")); gtk_widget_show (label4); gtk_table_attach (GTK_TABLE (table1), label4, 2, 3, 3, 4, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label4), 0, 0.5); label5 = gtk_label_new (_("Threshold :")); gtk_widget_show (label5); gtk_table_attach (GTK_TABLE (table1), label5, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label5), 0, 0.5); label6 = gtk_label_new (_("Noise threshold :")); gtk_widget_show (label6); gtk_table_attach (GTK_TABLE (table1), label6, 0, 1, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label6), 0, 0.5); label7 = gtk_label_new (_("Identical threshold :")); gtk_widget_show (label7); gtk_table_attach (GTK_TABLE (table1), label7, 0, 1, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label7), 0, 0.5); label8 = gtk_label_new (_("Show metrics")); gtk_widget_show (label8); gtk_table_attach (GTK_TABLE (table1), label8, 0, 1, 3, 4, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label8), 0, 0.5); spinbuttonTreshold_adj = gtk_adjustment_new (1, 1, 99, 1, 10, 10); spinbuttonTreshold = gtk_spin_button_new (GTK_ADJUSTMENT (spinbuttonTreshold_adj), 1, 0); gtk_widget_show (spinbuttonTreshold); gtk_table_attach (GTK_TABLE (table1), spinbuttonTreshold, 1, 2, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_tooltips_set_tip (tooltips, spinbuttonTreshold, _("If the image is closer than treshold, is it considered valid, smaller means more false detection"), NULL); gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbuttonTreshold), TRUE); spinbuttonNoise_adj = gtk_adjustment_new (1, 1, 99, 1, 10, 10); spinbuttonNoise = gtk_spin_button_new (GTK_ADJUSTMENT (spinbuttonNoise_adj), 1, 0); gtk_widget_show (spinbuttonNoise); gtk_table_attach (GTK_TABLE (table1), spinbuttonNoise, 1, 2, 1, 2, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_tooltips_set_tip (tooltips, spinbuttonNoise, _("If pixels are closer than noise threshold, they are considered identical"), NULL); gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbuttonNoise), TRUE); spinbuttonIdentical_adj = gtk_adjustment_new (1, 1, 99, 1, 10, 10); spinbuttonIdentical = gtk_spin_button_new (GTK_ADJUSTMENT (spinbuttonIdentical_adj), 1, 0); gtk_widget_show (spinbuttonIdentical); gtk_table_attach (GTK_TABLE (table1), spinbuttonIdentical, 1, 2, 2, 3, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_tooltips_set_tip (tooltips, spinbuttonIdentical, _("If the picture are less than identical threshold, they are considered identical"), NULL); gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbuttonIdentical), TRUE); checkbuttonShow = gtk_check_button_new_with_mnemonic (""); gtk_widget_show (checkbuttonShow); gtk_table_attach (GTK_TABLE (table1), checkbuttonShow, 1, 2, 3, 4, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_tooltips_set_tip (tooltips, checkbuttonShow, _("Show metrics in picture (debug only)"), NULL); dialog_action_area1 = GTK_DIALOG (dialog1)->action_area; gtk_widget_show (dialog_action_area1); gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area1), GTK_BUTTONBOX_END); cancelbutton1 = gtk_button_new_from_stock ("gtk-cancel"); gtk_widget_show (cancelbutton1); gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), cancelbutton1, GTK_RESPONSE_CANCEL); GTK_WIDGET_SET_FLAGS (cancelbutton1, GTK_CAN_DEFAULT); okbutton1 = gtk_button_new_from_stock ("gtk-ok"); gtk_widget_show (okbutton1); gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), okbutton1, GTK_RESPONSE_OK); GTK_WIDGET_SET_FLAGS (okbutton1, GTK_CAN_DEFAULT); /* Store pointers to all widgets, for use by lookup_widget(). */ GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog1, "dialog1"); GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_vbox1, "dialog_vbox1"); GLADE_HOOKUP_OBJECT (dialog1, table1, "table1"); GLADE_HOOKUP_OBJECT (dialog1, label1, "label1"); GLADE_HOOKUP_OBJECT (dialog1, label2, "label2"); GLADE_HOOKUP_OBJECT (dialog1, label3, "label3"); GLADE_HOOKUP_OBJECT (dialog1, label4, "label4"); GLADE_HOOKUP_OBJECT (dialog1, label5, "label5"); GLADE_HOOKUP_OBJECT (dialog1, label6, "label6"); GLADE_HOOKUP_OBJECT (dialog1, label7, "label7"); GLADE_HOOKUP_OBJECT (dialog1, label8, "label8"); GLADE_HOOKUP_OBJECT (dialog1, spinbuttonTreshold, "spinbuttonTreshold"); GLADE_HOOKUP_OBJECT (dialog1, spinbuttonNoise, "spinbuttonNoise"); GLADE_HOOKUP_OBJECT (dialog1, spinbuttonIdentical, "spinbuttonIdentical"); GLADE_HOOKUP_OBJECT (dialog1, checkbuttonShow, "checkbuttonShow"); GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_action_area1, "dialog_action_area1"); GLADE_HOOKUP_OBJECT (dialog1, cancelbutton1, "cancelbutton1"); GLADE_HOOKUP_OBJECT (dialog1, okbutton1, "okbutton1"); GLADE_HOOKUP_OBJECT_NO_REF (dialog1, tooltips, "tooltips"); return dialog1; }
static SCM gnc_style_sheet_new (StyleSheetDialog * ssd) { SCM make_ss = scm_c_eval_string("gnc:make-html-style-sheet"); SCM templates = scm_c_eval_string("(gnc:get-html-templates)"); SCM t_name = scm_c_eval_string("gnc:html-style-sheet-template-name"); SCM new_ss = SCM_BOOL_F; GtkWidget * template_combo; GtkTreeModel * template_model; GtkWidget * name_entry; gint dialog_retval; GList *template_names = NULL; /* get the new name for the style sheet */ GladeXML *xml = gnc_glade_xml_new ("report.glade", "New Style Sheet Dialog"); GtkWidget * dlg = glade_xml_get_widget (xml, "New Style Sheet Dialog"); template_combo = glade_xml_get_widget (xml, "template_combobox"); name_entry = glade_xml_get_widget (xml, "name_entry"); g_assert(ssd); /* Erase the initial dummy entry. */ template_model = gtk_combo_box_get_model(GTK_COMBO_BOX(template_combo)); gtk_list_store_clear(GTK_LIST_STORE(template_model)); /* put in the list of style sheet type names */ for (; !scm_is_null(templates); templates = SCM_CDR(templates)) { char * str; const char* orig_name; SCM t = SCM_CAR(templates); scm_dynwind_begin (0); str = scm_to_locale_string (scm_call_1(t_name, t)); orig_name = g_strdup (str); scm_dynwind_free (str); scm_dynwind_end (); /* Store the untranslated names for lookup later */ template_names = g_list_prepend (template_names, (gpointer)orig_name); /* The displayed name should be translated */ gtk_combo_box_prepend_text(GTK_COMBO_BOX(template_combo), _(orig_name)); } gtk_combo_box_set_active(GTK_COMBO_BOX(template_combo), 0); /* get the name */ gtk_window_set_transient_for (GTK_WINDOW(dlg), GTK_WINDOW(ssd->toplevel)); dialog_retval = gtk_dialog_run(GTK_DIALOG(dlg)); if (dialog_retval == GTK_RESPONSE_OK) { gint choice = gtk_combo_box_get_active (GTK_COMBO_BOX(template_combo)); const char *template_str = g_list_nth_data (template_names, choice); const char *name_str = gtk_entry_get_text(GTK_ENTRY(name_entry)); if (name_str && strlen(name_str) == 0) { /* If the name is empty, we display an error dialog but * refuse to create the new style sheet. */ gnc_error_dialog (ssd->toplevel, "%s", _("You must provide a name for the new style sheet.")); name_str = NULL; } if (template_str && name_str) { new_ss = scm_call_2(make_ss, scm_makfrom0str(template_str), scm_makfrom0str(name_str)); } } g_list_free (template_names); gtk_widget_destroy(dlg); return(new_ss); }
int main( int argc, char *argv[] ) { #ifdef __HYPHYMPI__ int rank, size; MPI_Init (&argc, &argv); MPI_Comm_rank(MPI_COMM_WORLD, &rank); MPI_Comm_size(MPI_COMM_WORLD, &size); _hy_mpi_node_rank = rank; setParameter (mpiNodeID, (_Parameter)rank); setParameter (mpiNodeCount, (_Parameter)size); if (rank == 0) #endif gtk_init (&argc, &argv); /* set up globals */ char curWd[4096]; getcwd (curWd,4096); _String baseDir (curWd); baseDir=baseDir&'/'; pathNames&& &baseDir; baseDirectory = baseDir; for (long i=1; i<argc;i++) { _String thisArg (argv[i]); if (thisArg.beginswith ("BASEPATH=")) { baseDirectory = thisArg.Cut(9,-1); if (baseDirectory.sLength) { if (baseDirectory.sData[baseDirectory.sLength-1]!='/') baseDirectory = baseDirectory&"/"; } } else if (thisArg.beginswith ("USEPATH=")) { _String baseArgDir (thisArg,8,-1); errorFileName = baseArgDir & errorFileName; messageFileName = baseArgDir & messageFileName; pathNames.Delete (0); pathNames&& &baseDir; } else if (thisArg.beginswith ("CPU=")) { #ifdef __MP__ _String cpus = thisArg.Cut(4,-1); systemCPUCount = cpus.toNum(); if (systemCPUCount<1) systemCPUCount = 1; #ifdef __MP2__ pthread_setconcurrency (systemCPUCount+1); #endif #endif } #ifdef __HYPHYMPI__ else if (thisArg == _String("MPIOPTIMIZER")) { mpiParallelOptimizer = true; setParameter (mpiNodeCount, 0.0); } else if (thisArg == _String("MPIPARTITIONS")) { mpiPartitionOptimizer = true; setParameter (mpiNodeCount, 0.0); } #endif } #ifdef __HYPHYMPI__ if (rank == 0) #endif { baseDir = baseDirectory & "GTKResources"; _List scanRes; ScanDirectoryForFileNames(baseDir,scanRes,false); if (scanRes.lLength == 0) { GtkWidget * noRez = gtk_message_dialog_new (NULL, GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "HYPHY_GTK was unable to find a required GTKResources directory in %s. Please use BASEPATH= command line option to specify where the installation directory of HyPhy can be found.", baseDirectory.sData); gtk_dialog_run (GTK_DIALOG (noRez)); gtk_widget_destroy (noRez); return 1; } _String rcPath = baseDir & "/theme/theme.rc"; //printf ("Loading res files from %s\n", rcPath.sData); gtk_rc_parse (rcPath.sData); } GlobalStartup(); #ifdef __HYPHYMPI__ if (rank == 0) { #endif GdkDisplay * defDisplay = gdk_screen_get_display (gdk_screen_get_default()); hSizeCursor = gdk_cursor_new_for_display (defDisplay,GDK_SB_H_DOUBLE_ARROW); pickUpCursor = gdk_cursor_new_for_display (defDisplay,GDK_TARGET); dropOffCursor = gdk_cursor_new_for_display (defDisplay,GDK_TCROSS); screenPContext = gdk_pango_context_get_for_screen (gdk_screen_get_default()); tablePDMenuIcon = (GdkPixbuf*)ProcureIconResource(4020); /*{ GdkScreen * defD = gdk_screen_get_default(); fontConversionFactor = 72.27 / (gdk_screen_get_height (defD) *25.4 / gdk_screen_get_height_mm(defD)); printf ("Pango conversion factor computed at: %g\n", fontConversionFactor); }*/ ReadInTemplateFiles (); hyphyConsoleWindow = new _HYConsoleWindow ("HYPHY Console"); ReadPreferences (); SetStatusLine ("None","Idle","00:00:00"); while (gtk_events_pending()) gtk_main_iteration(); SetPreferences (); ReadGeneticCodes (); ReadModelTemplates (); ReadTreeProcessors (); MoveConsoleWindow (consolePositionRectangle); StringToConsole (hyphyCiteString); hyphyConsoleWindow->BringToFront(); #ifdef __HYPHYMPI__ { char statBuffer[1024]; sprintf (statBuffer,"MPI version of HyPhy running on %d nodes (a master and %d compute nodes) in %s mode\n", size, size-1, mpiPartitionOptimizer?"partition":(mpiParallelOptimizer?"rate heterogeneity":"normal")); BufferToConsole (statBuffer); } #endif g_timeout_add (100,GlobalQueueTimer,nil); g_timeout_add (1000,progressTimerFunction,nil); gtk_main (); WritePreferences(); #ifdef __HYPHYMPI__ } else // slave node { if (mpiParallelOptimizer || mpiPartitionOptimizer) mpiOptimizerLoop (rank, size); else mpiNormalLoop (rank, size, baseDir); } #endif GlobalShutdown(); return 0; }
static void ppg_add_instrument_dialog_init (PpgAddInstrumentDialog *dialog) { PpgAddInstrumentDialogPrivate *priv; GtkWidget *content_area; GtkWidget *vbox; GtkWidget *hbox; GtkWidget *l; GtkWidget *scroller; priv = G_TYPE_INSTANCE_GET_PRIVATE(dialog, PPG_TYPE_ADD_INSTRUMENT_DIALOG, PpgAddInstrumentDialogPrivate); dialog->priv = priv; g_object_set(dialog, "border-width", 6, "default-width", 350, "default-height", 400, #if !GTK_CHECK_VERSION(2, 91, 0) "has-separator", FALSE, #endif "title", _("Add Instrument"), NULL); content_area = gtk_dialog_get_content_area(GTK_DIALOG(dialog)); vbox = g_object_new(GTK_TYPE_VBOX, "border-width", 6, "spacing", 12, "visible", TRUE, NULL); gtk_container_add(GTK_CONTAINER(content_area), vbox); l = g_object_new(GTK_TYPE_LABEL, "justify", GTK_JUSTIFY_CENTER, "label", _("Choose one or more instruments to\n" "add to your session."), "visible", TRUE, "wrap", TRUE, NULL); gtk_container_add_with_properties(GTK_CONTAINER(vbox), l, "expand", FALSE, NULL); hbox = g_object_new(GTK_TYPE_HBOX, "spacing", 12, "visible", TRUE, NULL); gtk_container_add_with_properties(GTK_CONTAINER(vbox), hbox, "expand", FALSE, NULL); priv->entry = g_object_new(GTK_TYPE_ENTRY, "activates-default", TRUE, "visible", TRUE, NULL); gtk_container_add_with_properties(GTK_CONTAINER(hbox), priv->entry, "position", 1, NULL); g_signal_connect(priv->entry, "changed", G_CALLBACK(ppg_add_instrument_dialog_entry_changed), dialog); l = g_object_new(GTK_TYPE_LABEL, "label", _("_Search:"), "mnemonic-widget", priv->entry, "use-underline", TRUE, "visible", TRUE, NULL); gtk_container_add_with_properties(GTK_CONTAINER(hbox), l, "expand", FALSE, "position", 0, NULL); scroller = g_object_new(GTK_TYPE_SCROLLED_WINDOW, "hscrollbar-policy", GTK_POLICY_AUTOMATIC, "shadow-type", GTK_SHADOW_IN, "visible", TRUE, "vscrollbar-policy", GTK_POLICY_AUTOMATIC, NULL); gtk_container_add(GTK_CONTAINER(vbox), scroller); priv->model = ppg_instruments_store_new(); priv->filter = g_object_new(GTK_TYPE_TREE_MODEL_FILTER, "child-model", priv->model, NULL); gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(priv->filter), ppg_add_instrument_dialog_filter_func, dialog, NULL); priv->icon_view = g_object_new(GTK_TYPE_ICON_VIEW, "model", priv->filter, "pixbuf-column", PPG_INSTRUMENTS_STORE_COLUMN_PIXBUF, "visible", TRUE, "text-column", PPG_INSTRUMENTS_STORE_COLUMN_TITLE, NULL); gtk_container_add(GTK_CONTAINER(scroller), priv->icon_view); g_signal_connect(priv->icon_view, "selection-changed", G_CALLBACK(ppg_add_instrument_dialog_selection_changed), dialog); g_signal_connect(priv->icon_view, "item-activated", G_CALLBACK(ppg_add_instrument_dialog_item_activated), dialog); gtk_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE); priv->add_button = gtk_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_ADD, GTK_RESPONSE_OK); gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK); g_object_set(priv->add_button, "sensitive", FALSE, NULL); g_signal_connect(dialog, "response", G_CALLBACK(ppg_add_instrument_dialog_response), NULL); }
/** * Shows a dialog to edit the given connection (or create a new one, * if conn is NULL) */ static void edit_connection (gpointer *parent, StrongswanConnection *conn) { GtkWidget *dialog; dialog = gtk_dialog_new_with_buttons ( conn ? "Edit Connection" : "New Connection", GTK_WINDOW (parent), GTK_DIALOG_MODAL | GTK_DIALOG_NO_SEPARATOR, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_SAVE, GTK_RESPONSE_OK, NULL); GtkWidget *vbox = GTK_DIALOG (dialog)->vbox; GtkSizeGroup *group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL); GtkWidget *name = hildon_entry_new (HILDON_SIZE_AUTO); hildon_gtk_entry_set_placeholder_text (GTK_ENTRY (name), "Connection Name"); hildon_gtk_entry_set_input_mode (GTK_ENTRY (name), HILDON_GTK_INPUT_MODE_AUTOCAP | HILDON_GTK_INPUT_MODE_ALPHA | HILDON_GTK_INPUT_MODE_NUMERIC); GtkWidget *ncap = hildon_caption_new (group, "Name", name, NULL, HILDON_CAPTION_OPTIONAL); gtk_box_pack_start (GTK_BOX (vbox), ncap, TRUE, TRUE, 0); GtkWidget *host = hildon_entry_new (HILDON_SIZE_AUTO); hildon_gtk_entry_set_placeholder_text (GTK_ENTRY (host), "Hostname / IP"); hildon_gtk_entry_set_input_mode (GTK_ENTRY (host), HILDON_GTK_INPUT_MODE_FULL); GtkWidget *hcap = hildon_caption_new (group, "Host", host, NULL, HILDON_CAPTION_OPTIONAL); gtk_box_pack_start (GTK_BOX (vbox), hcap, TRUE, TRUE, 0); GtkWidget *cert = hildon_button_new (HILDON_SIZE_FINGER_HEIGHT | HILDON_SIZE_AUTO_WIDTH, HILDON_BUTTON_ARRANGEMENT_VERTICAL); hildon_button_set_text (HILDON_BUTTON (cert), "Host or CA Certificate", "None"); hildon_button_set_alignment (HILDON_BUTTON (cert), 0, 0.5, 1, 1); g_signal_connect (cert, "clicked", G_CALLBACK (select_cert), dialog); GtkWidget *ccap = hildon_caption_new (group, "Certificate", cert, NULL, HILDON_CAPTION_OPTIONAL); gtk_box_pack_start (GTK_BOX (vbox), ccap, TRUE, TRUE, 0); GtkWidget *user = hildon_entry_new (HILDON_SIZE_AUTO); hildon_gtk_entry_set_placeholder_text (GTK_ENTRY (user), "Username"); hildon_gtk_entry_set_input_mode (GTK_ENTRY (user), HILDON_GTK_INPUT_MODE_FULL); GtkWidget *ucap = hildon_caption_new (group, "Username", user, NULL, HILDON_CAPTION_OPTIONAL); gtk_box_pack_start (GTK_BOX (vbox), ucap, TRUE, TRUE, 0); if (conn) { gchar *c_name, *c_host, *c_cert, *c_user; g_object_get (conn, "name", &c_name, "host", &c_host, "cert", &c_cert, "user", &c_user, NULL); gtk_entry_set_text (GTK_ENTRY (name), c_name); gtk_entry_set_text (GTK_ENTRY (host), c_host); hildon_button_set_value (HILDON_BUTTON (cert), c_cert ? c_cert : "None"); gtk_entry_set_text (GTK_ENTRY (user), c_user); g_free (c_name); g_free (c_host); g_free (c_cert); g_free (c_user); } gtk_widget_show_all (dialog); gint retval = gtk_dialog_run (GTK_DIALOG (dialog)); if (retval == GTK_RESPONSE_OK) { const gchar *c_name, *c_cert; c_name = gtk_entry_get_text (GTK_ENTRY (name)); if (!conn) { conn = strongswan_connection_new (c_name); } c_cert = hildon_button_get_value (HILDON_BUTTON (cert)); c_cert = strcmp (c_cert, "None") ? c_cert : NULL; g_object_set (conn, "name", c_name, "host", gtk_entry_get_text (GTK_ENTRY (host)), "cert", c_cert, "user", gtk_entry_get_text (GTK_ENTRY (user)), NULL); strongswan_connections_save_connection (ListDialog.conns, conn); } gtk_widget_destroy (dialog); }
void prop_cb (GtkAction *action, ProgressData *battstat) { GtkBuilder *builder; GtkWidget *combo_ptr, *spin_ptr; GtkListStore *liststore; GtkCellRenderer *renderer; GtkTreeIter iter; if (DEBUG) g_print("prop_cb()\n"); if (battstat->prop_win) { gtk_window_set_screen (GTK_WINDOW (battstat->prop_win), gtk_widget_get_screen (battstat->applet)); gtk_window_present (GTK_WINDOW (battstat->prop_win)); return; } builder = gtk_builder_new (); gtk_builder_add_from_file (builder, GTK_BUILDERDIR"/battstat_applet.ui", NULL); battstat->prop_win = GTK_DIALOG (gtk_builder_get_object (builder, "battstat_properties")); gtk_window_set_screen (GTK_WINDOW (battstat->prop_win), gtk_widget_get_screen (battstat->applet)); g_signal_connect (G_OBJECT (battstat->prop_win), "delete_event", G_CALLBACK (gtk_true), NULL); battstat->lowbatt_toggle = GTK_WIDGET (gtk_builder_get_object (builder, "lowbatt_toggle")); g_signal_connect (G_OBJECT (battstat->lowbatt_toggle), "toggled", G_CALLBACK (lowbatt_toggled), battstat); if (!g_settings_is_writable (battstat->settings, "low-battery-notification")) { hard_set_sensitive (battstat->lowbatt_toggle, FALSE); } battstat->hbox_ptr = GTK_WIDGET (gtk_builder_get_object (builder, "hbox_ptr")); hard_set_sensitive (battstat->hbox_ptr, battstat->lowbattnotification); combo_ptr = GTK_WIDGET (gtk_builder_get_object (builder, "combo_ptr")); g_signal_connect (G_OBJECT (combo_ptr), "changed", G_CALLBACK (combo_ptr_cb), battstat); liststore = gtk_list_store_new (1, G_TYPE_STRING); gtk_combo_box_set_model (GTK_COMBO_BOX (combo_ptr), GTK_TREE_MODEL (liststore)); gtk_cell_layout_clear (GTK_CELL_LAYOUT (combo_ptr)); renderer = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo_ptr), renderer, TRUE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo_ptr), renderer, "text", 0, NULL); gtk_list_store_append (liststore, &iter); /* TRANSLATOR: this is a selectable item in a drop-down menu to end * this sentence: * "Warn when battery charge drops to: [XX] percent". */ gtk_list_store_set (liststore, &iter, 0, _("Percent"), -1); gtk_list_store_append (liststore, &iter); /* TRANSLATOR: this is a selectable item in a drop-down menu to end * this sentence: * "Warn when battery charge drops to: [XX] minutes remaining" */ gtk_list_store_set (liststore, &iter, 0, _("Minutes Remaining"), -1); spin_ptr = GTK_WIDGET (gtk_builder_get_object (builder, "spin_ptr")); gtk_spin_button_set_value (GTK_SPIN_BUTTON (spin_ptr), battstat->red_val); g_signal_connect (G_OBJECT (spin_ptr), "value-changed", G_CALLBACK (spin_ptr_cb), battstat); if (battstat->red_value_is_time) gtk_combo_box_set_active (GTK_COMBO_BOX (combo_ptr), 1); else gtk_combo_box_set_active (GTK_COMBO_BOX (combo_ptr), 0); battstat->full_toggle = GTK_WIDGET (gtk_builder_get_object (builder, "full_toggle")); g_signal_connect (G_OBJECT (battstat->full_toggle), "toggled", G_CALLBACK (full_toggled), battstat); if (!g_settings_is_writable (battstat->settings, "full-battery-notification")) { hard_set_sensitive (battstat->full_toggle, FALSE); } if (battstat->fullbattnot) { gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (battstat->full_toggle), TRUE); } if (battstat->lowbattnotification) { gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (battstat->lowbatt_toggle), TRUE); } battstat->radio_traditional_battery = GTK_WIDGET (gtk_builder_get_object (builder, "battery_view_2")); g_signal_connect (G_OBJECT (battstat->radio_traditional_battery), "toggled", G_CALLBACK (radio_traditional_toggled), battstat); if (!g_settings_is_writable (battstat->settings, "show-battery")) hard_set_sensitive (battstat->radio_traditional_battery, FALSE); if (battstat->showbattery) { gtk_toggle_button_set_active ( GTK_TOGGLE_BUTTON (battstat->radio_traditional_battery), TRUE); } battstat->radio_ubuntu_battery = GTK_WIDGET (gtk_builder_get_object (builder, "battery_view")); g_signal_connect (G_OBJECT (battstat->radio_ubuntu_battery), "toggled", G_CALLBACK (radio_ubuntu_toggled), battstat); if (!g_settings_is_writable (battstat->settings, "show-status")) hard_set_sensitive (battstat->radio_ubuntu_battery, FALSE); if (battstat->showstatus) { gtk_toggle_button_set_active ( GTK_TOGGLE_BUTTON (battstat->radio_ubuntu_battery), TRUE); } battstat->radio_text_1 = GTK_WIDGET (gtk_builder_get_object (builder, "show_text_radio")); battstat->radio_text_2 = GTK_WIDGET (gtk_builder_get_object (builder, "show_text_radio_2")); battstat->check_text = GTK_WIDGET (gtk_builder_get_object (builder, "show_text_remaining")); g_object_unref (builder); g_signal_connect (G_OBJECT (battstat->radio_text_1), "toggled", G_CALLBACK (show_text_toggled), battstat); g_signal_connect (G_OBJECT (battstat->radio_text_2), "toggled", G_CALLBACK (show_text_toggled), battstat); g_signal_connect (G_OBJECT (battstat->check_text), "toggled", G_CALLBACK (show_text_toggled), battstat); if (!g_settings_is_writable (battstat->settings, "show-text")) { hard_set_sensitive (battstat->check_text, FALSE); hard_set_sensitive (battstat->radio_text_1, FALSE); hard_set_sensitive (battstat->radio_text_2, FALSE); } if (battstat->showtext == APPLET_SHOW_PERCENT) { gtk_toggle_button_set_active ( GTK_TOGGLE_BUTTON (battstat->check_text), TRUE); gtk_toggle_button_set_active ( GTK_TOGGLE_BUTTON (battstat->radio_text_2), TRUE); gtk_widget_set_sensitive (GTK_WIDGET (battstat->radio_text_1), TRUE); gtk_widget_set_sensitive (GTK_WIDGET (battstat->radio_text_2), TRUE); } else if (battstat->showtext == APPLET_SHOW_TIME) { gtk_toggle_button_set_active ( GTK_TOGGLE_BUTTON (battstat->check_text), TRUE); gtk_toggle_button_set_active ( GTK_TOGGLE_BUTTON (battstat->radio_text_1), TRUE); gtk_widget_set_sensitive (GTK_WIDGET (battstat->radio_text_1), TRUE); gtk_widget_set_sensitive (GTK_WIDGET (battstat->radio_text_2), TRUE); } else /* APPLET_SHOW_NONE */ { gtk_toggle_button_set_active ( GTK_TOGGLE_BUTTON (battstat->check_text), FALSE); gtk_widget_set_sensitive (GTK_WIDGET (battstat->radio_text_1), FALSE); gtk_widget_set_sensitive (GTK_WIDGET (battstat->radio_text_2), FALSE); } gtk_dialog_set_default_response (GTK_DIALOG (battstat->prop_win), GTK_RESPONSE_CLOSE); gtk_window_set_resizable (GTK_WINDOW (battstat->prop_win), FALSE); gtk_dialog_set_has_separator (GTK_DIALOG (battstat->prop_win), FALSE); g_signal_connect (G_OBJECT (battstat->prop_win), "response", G_CALLBACK (response_cb), battstat); gtk_widget_show_all (GTK_WIDGET (battstat->prop_win)); }
/** * Callback if no certificate should be selected */ void no_certificate(HildonButton *button, gpointer user_data) { gtk_dialog_response (GTK_DIALOG (user_data), GTK_RESPONSE_REJECT); }
/** * main callback for control panel plugins */ osso_return_t execute(osso_context_t *osso, gpointer data, gboolean user_activated) { gint response; create_list_dialog (data); if (!user_activated) { /* load state */ } do { gchar *selected; response = gtk_dialog_run (GTK_DIALOG (ListDialog.dialog)); switch (response) { case RESPONSE_NEW: { edit_connection (data, NULL); break; } case RESPONSE_EDIT: { StrongswanConnection *conn; selected = get_selected (); conn = strongswan_connections_get_connection (ListDialog.conns, selected); if (conn) { edit_connection (data, conn); } else { hildon_banner_show_information (NULL, NULL, "Select a connection first"); } g_free (selected); break; } case RESPONSE_DELETE: { GtkWidget *confirm; gint retval; gchar *msg; selected = get_selected (); if (!selected) { hildon_banner_show_information (NULL, NULL, "Select a connection first"); break; } msg = g_strdup_printf ("Delete connection?\n%s", selected); confirm = hildon_note_new_confirmation (data, msg); retval = gtk_dialog_run (GTK_DIALOG (confirm)); if (retval == GTK_RESPONSE_OK) { strongswan_connections_remove_connection (ListDialog.conns, selected); } gtk_widget_destroy (confirm); g_free (msg); g_free (selected); break; } default: break; } } while (response > 0); gtk_widget_destroy (ListDialog.dialog); g_object_unref (ListDialog.conns); return OSSO_OK; }
static void do_simple_message_box(ESD_TYPE_E type, gboolean *notagain, const char *secondary_msg, const char *msg_format, va_list ap) { GtkMessageType gtk_message_type; gchar *message; GtkWidget *msg_dialog; GtkWidget *checkbox = NULL; if (notagain != NULL) { if (*notagain) { /* * The user had checked the "Don't show this message again" checkbox * in the past; don't bother showing it. */ return; } } switch (type) { case ESD_TYPE_INFO: gtk_message_type = GTK_MESSAGE_INFO; break; case ESD_TYPE_WARN: gtk_message_type = GTK_MESSAGE_WARNING; break; case ESD_TYPE_ERROR: gtk_message_type = GTK_MESSAGE_ERROR; break; default: g_assert_not_reached(); gtk_message_type = GTK_MESSAGE_INFO; break; } /* Format the message. */ message = g_strdup_vprintf(msg_format, ap); msg_dialog = gtk_message_dialog_new(GTK_WINDOW(top_level), (GtkDialogFlags)(GTK_DIALOG_MODAL|GTK_DIALOG_DESTROY_WITH_PARENT), gtk_message_type, GTK_BUTTONS_OK, "%s", message); g_free(message); if (secondary_msg != NULL) gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(msg_dialog), "%s", secondary_msg); if (notagain != NULL) { checkbox = gtk_check_button_new_with_label("Don't show this message again."); gtk_container_set_border_width(GTK_CONTAINER(checkbox), 12); gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(msg_dialog))), checkbox, TRUE, TRUE, 0); gtk_widget_show(checkbox); } gtk_dialog_run(GTK_DIALOG(msg_dialog)); if (notagain != NULL) { /* * OK, did they check the checkbox? */ *notagain = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(checkbox)); } gtk_widget_destroy(msg_dialog); }
static void set_dialog_properties (GtkAppChooserDialog *self) { gchar *name; gchar *extension; gchar *description; gchar *string; gboolean unknown; gchar *title; gchar *subtitle; gboolean use_header; GtkWidget *header; name = NULL; extension = NULL; description = NULL; unknown = TRUE; if (self->priv->gfile != NULL) { name = g_file_get_basename (self->priv->gfile); extension = get_extension (name); } if (self->priv->content_type) { description = g_content_type_get_description (self->priv->content_type); unknown = g_content_type_is_unknown (self->priv->content_type); } if (name != NULL) { title = g_strdup (_("Select Application")); /* Translators: %s is a filename */ subtitle = g_strdup_printf (_("Opening “%s”."), name); string = g_strdup_printf (_("No applications found for “%s”"), name); } else { title = g_strdup (_("Select Application")); /* Translators: %s is a file type description */ subtitle = g_strdup_printf (_("Opening “%s” files."), unknown ? self->priv->content_type : description); string = g_strdup_printf (_("No applications found for “%s” files"), unknown ? self->priv->content_type : description); } g_object_get (self, "use-header-bar", &use_header, NULL); if (use_header) { header = gtk_dialog_get_header_bar (GTK_DIALOG (self)); gtk_header_bar_set_title (GTK_HEADER_BAR (header), title); gtk_header_bar_set_subtitle (GTK_HEADER_BAR (header), subtitle); } else { gtk_window_set_title (GTK_WINDOW (self), _("Select Application")); } if (self->priv->heading != NULL) { gtk_label_set_markup (GTK_LABEL (self->priv->label), self->priv->heading); gtk_widget_show (self->priv->label); } else { gtk_widget_hide (self->priv->label); } gtk_app_chooser_widget_set_default_text (GTK_APP_CHOOSER_WIDGET (self->priv->app_chooser_widget), string); g_free (title); g_free (subtitle); g_free (name); g_free (extension); g_free (description); g_free (string); }
static PidginLogViewer *display_log_viewer(struct log_viewer_hash_t *ht, GList *logs, const char *title, GtkWidget *icon, int log_size) { PidginLogViewer *lv; GtkWidget *title_box; char *text; GtkWidget *pane; GtkWidget *sw; GtkCellRenderer *rend; GtkTreeViewColumn *col; GtkTreeSelection *sel; GtkWidget *vbox; GtkWidget *frame; GtkWidget *hbox; GtkWidget *find_button; GtkWidget *size_label; if (logs == NULL) { /* No logs were found. */ const char *log_preferences = NULL; if (ht == NULL) { if (!purple_prefs_get_bool("/purple/logging/log_system")) log_preferences = _("System events will only be logged if the \"Log all status changes to system log\" preference is enabled."); } else { if (ht->type == PURPLE_LOG_IM) { if (!purple_prefs_get_bool("/purple/logging/log_ims")) log_preferences = _("Instant messages will only be logged if the \"Log all instant messages\" preference is enabled."); } else if (ht->type == PURPLE_LOG_CHAT) { if (!purple_prefs_get_bool("/purple/logging/log_chats")) log_preferences = _("Chats will only be logged if the \"Log all chats\" preference is enabled."); } g_free(ht->buddyname); g_free(ht); } if(icon != NULL) gtk_widget_destroy(icon); purple_notify_info(NULL, title, _("No logs were found"), log_preferences); return NULL; } lv = g_new0(PidginLogViewer, 1); lv->logs = logs; if (ht != NULL) g_hash_table_insert(log_viewers, ht, lv); /* Window ***********/ lv->window = gtk_dialog_new_with_buttons(title, NULL, 0, GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, NULL); #ifdef _WIN32 /* Steal the "HELP" response and use it to trigger browsing to the logs folder */ gtk_dialog_add_button(GTK_DIALOG(lv->window), _("_Browse logs folder"), GTK_RESPONSE_HELP); #endif gtk_container_set_border_width (GTK_CONTAINER(lv->window), PIDGIN_HIG_BOX_SPACE); gtk_dialog_set_has_separator(GTK_DIALOG(lv->window), FALSE); gtk_box_set_spacing(GTK_BOX(GTK_DIALOG(lv->window)->vbox), 0); g_signal_connect(G_OBJECT(lv->window), "response", G_CALLBACK(destroy_cb), ht); gtk_window_set_role(GTK_WINDOW(lv->window), "log_viewer"); /* Icon *************/ if (icon != NULL) { title_box = gtk_hbox_new(FALSE, PIDGIN_HIG_BOX_SPACE); gtk_container_set_border_width(GTK_CONTAINER(title_box), PIDGIN_HIG_BOX_SPACE); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(lv->window)->vbox), title_box, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(title_box), icon, FALSE, FALSE, 0); } else title_box = GTK_DIALOG(lv->window)->vbox; /* Label ************/ lv->label = gtk_label_new(NULL); text = g_strdup_printf("<span size='larger' weight='bold'>%s</span>", title); gtk_label_set_markup(GTK_LABEL(lv->label), text); gtk_misc_set_alignment(GTK_MISC(lv->label), 0, 0); gtk_box_pack_start(GTK_BOX(title_box), lv->label, FALSE, FALSE, 0); g_free(text); /* Pane *************/ pane = gtk_hpaned_new(); gtk_container_set_border_width(GTK_CONTAINER(pane), PIDGIN_HIG_BOX_SPACE); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(lv->window)->vbox), pane, TRUE, TRUE, 0); /* List *************/ sw = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_IN); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS); gtk_paned_add1(GTK_PANED(pane), sw); lv->treestore = gtk_tree_store_new (2, G_TYPE_STRING, G_TYPE_POINTER); lv->treeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (lv->treestore)); g_object_unref(G_OBJECT(lv->treestore)); rend = gtk_cell_renderer_text_new(); col = gtk_tree_view_column_new_with_attributes ("time", rend, "markup", 0, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW(lv->treeview), col); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (lv->treeview), FALSE); gtk_container_add (GTK_CONTAINER (sw), lv->treeview); populate_log_tree(lv); sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (lv->treeview)); g_signal_connect (G_OBJECT (sel), "changed", G_CALLBACK (log_select_cb), lv); g_signal_connect (G_OBJECT(lv->treeview), "row-activated", G_CALLBACK(log_row_activated_cb), lv); pidgin_set_accessible_label(lv->treeview, lv->label); g_signal_connect(lv->treeview, "button-press-event", G_CALLBACK(log_button_press_cb), lv); g_signal_connect(lv->treeview, "popup-menu", G_CALLBACK(log_popup_menu_cb), lv); /* Log size ************/ if(log_size) { char *sz_txt = purple_str_size_to_units(log_size); text = g_strdup_printf("<span weight='bold'>%s</span> %s", _("Total log size:"), sz_txt); size_label = gtk_label_new(NULL); gtk_label_set_markup(GTK_LABEL(size_label), text); /* gtk_paned_add1(GTK_PANED(pane), size_label); */ gtk_misc_set_alignment(GTK_MISC(size_label), 0, 0); gtk_box_pack_end(GTK_BOX(GTK_DIALOG(lv->window)->vbox), size_label, FALSE, FALSE, 0); g_free(sz_txt); g_free(text); } /* A fancy little box ************/ vbox = gtk_vbox_new(FALSE, PIDGIN_HIG_BOX_SPACE); gtk_paned_add2(GTK_PANED(pane), vbox); /* Viewer ************/ frame = pidgin_create_imhtml(FALSE, &lv->imhtml, NULL, NULL); gtk_widget_set_name(lv->imhtml, "pidgin_log_imhtml"); gtk_widget_set_size_request(lv->imhtml, 320, 200); gtk_box_pack_start(GTK_BOX(vbox), frame, TRUE, TRUE, 0); gtk_widget_show(frame); /* Search box **********/ hbox = gtk_hbox_new(FALSE, PIDGIN_HIG_BOX_SPACE); gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0); lv->entry = gtk_entry_new(); gtk_box_pack_start(GTK_BOX(hbox), lv->entry, TRUE, TRUE, 0); find_button = gtk_button_new_from_stock(GTK_STOCK_FIND); gtk_box_pack_start(GTK_BOX(hbox), find_button, FALSE, FALSE, 0); g_signal_connect(GTK_ENTRY(lv->entry), "activate", G_CALLBACK(search_cb), lv); g_signal_connect(GTK_BUTTON(find_button), "clicked", G_CALLBACK(search_cb), lv); select_first_log(lv); gtk_widget_show_all(lv->window); return lv; }
/** * vdpdbg_window_show(): Show the VDP Layer Options window. * @param parent Parent window. */ void MDP_FNCALL vdpdbg_window_show(void *parent) { if (vdpdbg_window) { // VDP Debugger window is already visible. Set focus. gtk_widget_grab_focus(vdpdbg_window); return; } // Initialize VDP Data. vdpdbg_data_init(); // Clear previous CRam buffer. memset(prev_CRam, 0, sizeof(prev_CRam)); // Create the window. vdpdbg_window = gtk_dialog_new(); gtk_container_set_border_width(GTK_CONTAINER(vdpdbg_window), 4); gtk_window_set_title(GTK_WINDOW(vdpdbg_window), "VDP Debugger"); gtk_window_set_position(GTK_WINDOW(vdpdbg_window), GTK_WIN_POS_CENTER); gtk_window_set_resizable(GTK_WINDOW(vdpdbg_window), FALSE); gtk_window_set_type_hint(GTK_WINDOW(vdpdbg_window), GDK_WINDOW_TYPE_HINT_DIALOG); gtk_dialog_set_has_separator(GTK_DIALOG(vdpdbg_window), FALSE); // Callbacks for if the window is closed. g_signal_connect((gpointer)vdpdbg_window, "delete_event", G_CALLBACK(vdpdbg_window_callback_close), NULL); g_signal_connect((gpointer)vdpdbg_window, "destroy_event", G_CALLBACK(vdpdbg_window_callback_close), NULL); // Dialog response callback. g_signal_connect((gpointer)vdpdbg_window, "response", G_CALLBACK(vdpdbg_window_callback_response), NULL); // Get the dialog VBox. GtkWidget *vboxDialog = gtk_bin_get_child(GTK_BIN(vdpdbg_window)); gtk_box_set_spacing(GTK_BOX(vboxDialog), 8); gtk_widget_show(vboxDialog); // Create the CRam image. (each color will be 16x16) pbufCRam = gdk_pixbuf_new(GDK_COLORSPACE_RGB, TRUE, 8, 16*16, 4*16); imgCRam = gtk_image_new_from_pixbuf(pbufCRam); gtk_widget_show(imgCRam); gtk_box_pack_start(GTK_BOX(vboxDialog), imgCRam, FALSE, FALSE, 0); // Clear the pixel buffer. uint32_t *pixels = (uint32_t*)gdk_pixbuf_get_pixels(pbufCRam); int rowstride = gdk_pixbuf_get_rowstride(pbufCRam); int n_channels = gdk_pixbuf_get_n_channels(pbufCRam); int px_count = ((rowstride * 63) + (16*16*n_channels)) / 4; for (; px_count != 0; px_count -= 4) { *pixels = 0xFF000000U; *(pixels + 1) = 0xFF000000U; *(pixels + 2) = 0xFF000000U; *(pixels + 3) = 0xFF000000U; pixels += 4; } // Create the GtkTreeView for the register listing. vdpdbg_window_create_lstRegList(vboxDialog); // Create the dialog buttons. gtk_dialog_add_buttons(GTK_DIALOG(vdpdbg_window), "gtk-close", GTK_RESPONSE_CLOSE, NULL); // Set the window as modal to the main application window. if (parent) gtk_window_set_transient_for(GTK_WINDOW(vdpdbg_window), GTK_WINDOW(parent)); // Update the window. vdpdbg_window_update(); // Show the window. gtk_widget_show_all(vdpdbg_window); // Register the window with MDP Host Services. vdpdbg_host_srv->window_register(&mdp, vdpdbg_window); }
VectorsImportDialog * vectors_import_dialog_new (GimpImage *image, GtkWidget *parent, gboolean merge_vectors, gboolean scale_vectors) { VectorsImportDialog *dialog; GtkWidget *vbox; GtkWidget *button; GtkFileFilter *filter; g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL); g_return_val_if_fail (GTK_IS_WIDGET (parent), NULL); dialog = g_slice_new0 (VectorsImportDialog); dialog->image = image; dialog->merge_vectors = merge_vectors; dialog->scale_vectors = scale_vectors; dialog->dialog = gtk_file_chooser_dialog_new (_("Import Paths from SVG"), NULL, GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_OK, NULL); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog->dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); gtk_window_set_screen (GTK_WINDOW (dialog->dialog), gtk_widget_get_screen (parent)); gtk_window_set_role (GTK_WINDOW (dialog->dialog), "gimp-vectors-import"); gtk_window_set_position (GTK_WINDOW (dialog->dialog), GTK_WIN_POS_MOUSE); gtk_dialog_set_default_response (GTK_DIALOG (dialog->dialog), GTK_RESPONSE_OK); g_object_weak_ref (G_OBJECT (dialog->dialog), (GWeakNotify) vectors_import_dialog_free, dialog); g_signal_connect_object (image, "disconnect", G_CALLBACK (gtk_widget_destroy), dialog->dialog, 0); g_signal_connect (dialog->dialog, "delete-event", G_CALLBACK (gtk_true), NULL); filter = gtk_file_filter_new (); gtk_file_filter_set_name (filter, _("All files (*.*)")); gtk_file_filter_add_pattern (filter, "*"); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog->dialog), filter); filter = gtk_file_filter_new (); gtk_file_filter_set_name (filter, _("Scalable SVG image (*.svg)")); gtk_file_filter_add_pattern (filter, "*.[Ss][Vv][Gg]"); gtk_file_filter_add_mime_type (filter, "image/svg+xml"); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog->dialog), filter); gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (dialog->dialog), filter); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (dialog->dialog), vbox); gtk_widget_show (vbox); button = gtk_check_button_new_with_mnemonic (_("_Merge imported paths")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), dialog->merge_vectors); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); gtk_widget_show (button); g_signal_connect (button, "toggled", G_CALLBACK (gimp_toggle_button_update), &dialog->merge_vectors); button = gtk_check_button_new_with_mnemonic (_("_Scale imported paths " "to fit image")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), dialog->scale_vectors); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); gtk_widget_show (button); g_signal_connect (button, "toggled", G_CALLBACK (gimp_toggle_button_update), &dialog->scale_vectors); return dialog; }
GtkWidget* create_dialog1 (void) { GtkWidget *dialog1; GtkWidget *dialog_vbox1; GtkWidget *vbox1; GtkWidget *hbox2; GtkWidget *vbox3; GtkWidget *vbox4; GtkWidget *label1; GtkWidget *vbox5; GtkWidget *vbox2; GtkWidget *dialog_action_area1; GtkWidget *hbox1; GtkWidget *button_ok; GtkWidget *button_cancel; GtkWidget *button_update; dialog1 = gtk_dialog_new (); gtk_object_set_data (GTK_OBJECT (dialog1), "dialog1", dialog1); gtk_window_set_title (GTK_WINDOW (dialog1), "Rotate"); gtk_window_set_policy (GTK_WINDOW (dialog1), TRUE, TRUE, FALSE); dialog_vbox1 = GTK_DIALOG (dialog1)->vbox; gtk_object_set_data (GTK_OBJECT (dialog1), "dialog_vbox1", dialog_vbox1); gtk_widget_show (dialog_vbox1); vbox1 = gtk_vbox_new (FALSE, 0); gtk_widget_ref (vbox1); gtk_object_set_data_full (GTK_OBJECT (dialog1), "vbox1", vbox1, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (vbox1); gtk_box_pack_start (GTK_BOX (dialog_vbox1), vbox1, TRUE, TRUE, 0); hbox2 = gtk_hbox_new (FALSE, 0); gtk_widget_ref (hbox2); gtk_object_set_data_full (GTK_OBJECT (dialog1), "hbox2", hbox2, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (hbox2); gtk_box_pack_start (GTK_BOX (vbox1), hbox2, TRUE, TRUE, 0); vbox3 = gtk_vbox_new (FALSE, 0); gtk_widget_ref (vbox3); gtk_object_set_data_full (GTK_OBJECT (dialog1), "vbox3", vbox3, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (vbox3); gtk_box_pack_start (GTK_BOX (hbox2), vbox3, TRUE, TRUE, 0); vbox4 = gtk_vbox_new (FALSE, 0); gtk_widget_ref (vbox4); gtk_object_set_data_full (GTK_OBJECT (dialog1), "vbox4", vbox4, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (vbox4); gtk_box_pack_start (GTK_BOX (vbox3), vbox4, TRUE, TRUE, 0); label1 = gtk_label_new ("Angle"); gtk_widget_ref (label1); gtk_object_set_data_full (GTK_OBJECT (dialog1), "label1", label1, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (label1); gtk_box_pack_start (GTK_BOX (vbox4), label1, FALSE, FALSE, 0); // angle _______________________________________________________________ adj_angle=gtk_adjustment_new (0.0, 0.0, 360.0, 90.0, 90.0, 90.0); hscale2 = gtk_hscale_new (GTK_ADJUSTMENT (adj_angle)); gtk_widget_ref (hscale2); gtk_object_set_data_full (GTK_OBJECT (dialog1), "hscale2", hscale2, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (hscale2); gtk_box_pack_start (GTK_BOX (vbox4), hscale2, TRUE, TRUE, 0); vbox5 = gtk_vbox_new (FALSE, 0); gtk_widget_ref (vbox5); gtk_object_set_data_full (GTK_OBJECT (dialog1), "vbox5", vbox5, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (vbox5); gtk_box_pack_start (GTK_BOX (vbox3), vbox5, TRUE, TRUE, 0); // gtk_box_pack_start (GTK_BOX (vbox5), hscale3, TRUE, TRUE, 0); // gtk_scale_set_digits (GTK_SCALE (hscale3), 0); vbox2 = gtk_vbox_new (FALSE, 0); gtk_widget_ref (vbox2); gtk_object_set_data_full (GTK_OBJECT (dialog1), "vbox2", vbox2, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (vbox2); gtk_box_pack_start (GTK_BOX (hbox2), vbox2, TRUE, TRUE, 0); drawing = gtk_drawing_area_new (); gtk_widget_ref (drawing); gtk_object_set_data_full (GTK_OBJECT (dialog1), "drawing", drawing, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (drawing); gtk_box_pack_start (GTK_BOX (vbox1), drawing, TRUE, TRUE, 0); dialog_action_area1 = GTK_DIALOG (dialog1)->action_area; gtk_object_set_data (GTK_OBJECT (dialog1), "dialog_action_area1", dialog_action_area1); gtk_widget_show (dialog_action_area1); gtk_container_set_border_width (GTK_CONTAINER (dialog_action_area1), 10); hbox1 = gtk_hbox_new (FALSE, 0); gtk_widget_ref (hbox1); gtk_object_set_data_full (GTK_OBJECT (dialog1), "hbox1", hbox1, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (hbox1); gtk_box_pack_start (GTK_BOX (dialog_action_area1), hbox1, TRUE, TRUE, 0); button_ok = gtk_button_new_with_label ("Ok"); gtk_widget_ref (button_ok); gtk_object_set_data_full (GTK_OBJECT (dialog1), "button_ok", button_ok, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (button_ok); gtk_box_pack_start (GTK_BOX (hbox1), button_ok, FALSE, FALSE, 0); button_cancel = gtk_button_new_with_label ("Cancel"); gtk_widget_ref (button_cancel); gtk_object_set_data_full (GTK_OBJECT (dialog1), "button_cancel", button_cancel, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (button_cancel); gtk_box_pack_start (GTK_BOX (hbox1), button_cancel, FALSE, FALSE, 0); button_update = gtk_button_new_with_label ("Update"); gtk_widget_ref (button_update); gtk_object_set_data_full (GTK_OBJECT (dialog1), "button_update", button_update, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (button_update); gtk_box_pack_start (GTK_BOX (hbox1), button_update, FALSE, FALSE, 0); //------------------------------------------- gtk_signal_connect (GTK_OBJECT (button_ok), "clicked", GTK_SIGNAL_FUNC (gui_ok), (void *)1); gtk_signal_connect (GTK_OBJECT (button_cancel), "clicked", GTK_SIGNAL_FUNC (gui_ok), (void *)0); gtk_signal_connect (GTK_OBJECT (button_update), "clicked", GTK_SIGNAL_FUNC (gui_update), NULL); gtk_signal_connect(GTK_OBJECT(drawing), "expose_event", GTK_SIGNAL_FUNC(gui_draw), NULL); /*gtk_signal_connect(GTK_OBJECT(hscale3), "drag_data_received", GTK_SIGNAL_FUNC(gui_update), NULL);*/ gtk_signal_connect(GTK_OBJECT(hscale2), "drag_data_received", GTK_SIGNAL_FUNC(gui_update), NULL); /*gtk_signal_connect(GTK_OBJECT(hscale3), "drag_motion", GTK_SIGNAL_FUNC(gui_update), NULL);*/ gtk_signal_connect(GTK_OBJECT(hscale2), "drag_motion", GTK_SIGNAL_FUNC(gui_update), NULL); /*gtk_signal_connect(GTK_OBJECT(hscale3), "drag_data_get", GTK_SIGNAL_FUNC(gui_update), NULL);*/ gtk_signal_connect(GTK_OBJECT(hscale2), "drag_data_get", GTK_SIGNAL_FUNC(gui_update), NULL); /*gtk_signal_connect(GTK_OBJECT(hscale3), "drag_begin", GTK_SIGNAL_FUNC(gui_update), NULL);*/ gtk_signal_connect(GTK_OBJECT(hscale2), "drag_begin", GTK_SIGNAL_FUNC(gui_update), NULL); gtk_signal_connect(GTK_OBJECT(adj_angle), "value_changed", GTK_SIGNAL_FUNC(gui_update), (void *) (NULL)); return dialog1; }
static gboolean dialog (void) { /* Missing options: Color-dialogs? / own curl layer ? / transparency to original drawable / Warp-curl (unsupported yet) */ GtkWidget *dialog; GtkWidget *hbox; GtkWidget *vbox; GtkWidget *table; GtkWidget *frame; GtkWidget *button; GtkWidget *combo; GtkObject *adjustment; gboolean run; gimp_ui_init (PLUG_IN_BINARY, FALSE); dialog = gimp_dialog_new (_("Pagecurl Effect"), PLUG_IN_BINARY, NULL, 0, gimp_standard_help_func, PLUG_IN_PROC, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); gimp_window_set_transient (GTK_WINDOW (dialog)); vbox = gtk_vbox_new (FALSE, 12); gtk_container_set_border_width (GTK_CONTAINER (vbox), 12); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), vbox, TRUE, TRUE, 0); gtk_widget_show (vbox); frame = gimp_frame_new (_("Curl Location")); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); table = gtk_table_new (3, 2, TRUE); gtk_table_set_col_spacings (GTK_TABLE (table), 6); gtk_table_set_row_spacings (GTK_TABLE (table), 6); gtk_container_add (GTK_CONTAINER (frame), table); curl_image = gtk_image_new (); gtk_table_attach (GTK_TABLE (table), curl_image, 0, 2, 1, 2, GTK_SHRINK, GTK_SHRINK, 0, 0); gtk_widget_show (curl_image); curl_pixbuf_update (); { static const gchar *name[] = { N_("Lower right"), N_("Lower left"), N_("Upper left"), N_("Upper right") }; gint i; button = NULL; for (i = CURL_EDGE_FIRST; i <= CURL_EDGE_LAST; i++) { button = gtk_radio_button_new_with_label (button == NULL ? NULL : gtk_radio_button_get_group (GTK_RADIO_BUTTON (button)), gettext (name[i - CURL_EDGE_FIRST])); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), curl.edge == i); g_object_set_data (G_OBJECT (button), "gimp-item-data", GINT_TO_POINTER (i)); gtk_table_attach (GTK_TABLE (table), button, CURL_EDGE_LEFT (i) ? 0 : 1, CURL_EDGE_LEFT (i) ? 1 : 2, CURL_EDGE_UPPER (i) ? 0 : 2, CURL_EDGE_UPPER (i) ? 1 : 3, GTK_FILL | GTK_EXPAND, GTK_SHRINK, 0, 0); gtk_widget_show (button); g_signal_connect (button, "toggled", G_CALLBACK (gimp_radio_button_update), &curl.edge); g_signal_connect (button, "toggled", G_CALLBACK (curl_pixbuf_update), NULL); } } gtk_widget_show (table); gtk_widget_show (frame); frame = gimp_frame_new (_("Curl Orientation")); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); hbox = gtk_hbox_new (TRUE, 6); gtk_container_add (GTK_CONTAINER (frame), hbox); { static const gchar *name[] = { N_("_Vertical"), N_("_Horizontal") }; gint i; button = NULL; for (i = 0; i <= CURL_ORIENTATION_LAST; i++) { button = gtk_radio_button_new_with_mnemonic (button == NULL ? NULL : gtk_radio_button_get_group (GTK_RADIO_BUTTON (button)), gettext (name[i])); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), curl.orientation == i); g_object_set_data (G_OBJECT (button), "gimp-item-data", GINT_TO_POINTER (i)); gtk_box_pack_end (GTK_BOX (hbox), button, TRUE, TRUE, 0); gtk_widget_show (button); g_signal_connect (button, "toggled", G_CALLBACK (gimp_radio_button_update), &curl.orientation); g_signal_connect (button, "toggled", G_CALLBACK (curl_pixbuf_update), NULL); } } gtk_widget_show (hbox); gtk_widget_show (frame); button = gtk_check_button_new_with_mnemonic (_("_Shade under curl")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), curl.shade); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); gtk_widget_show (button); g_signal_connect (button, "toggled", G_CALLBACK (gimp_toggle_button_update), &curl.shade); combo = g_object_new (GIMP_TYPE_INT_COMBO_BOX, NULL); gimp_int_combo_box_prepend (GIMP_INT_COMBO_BOX (combo), GIMP_INT_STORE_VALUE, CURL_COLORS_GRADIENT_REVERSE, GIMP_INT_STORE_LABEL, _("Current gradient (reversed)"), GIMP_INT_STORE_STOCK_ID, GIMP_STOCK_GRADIENT, -1); gimp_int_combo_box_prepend (GIMP_INT_COMBO_BOX (combo), GIMP_INT_STORE_VALUE, CURL_COLORS_GRADIENT, GIMP_INT_STORE_LABEL, _("Current gradient"), GIMP_INT_STORE_STOCK_ID, GIMP_STOCK_GRADIENT, -1); gimp_int_combo_box_prepend (GIMP_INT_COMBO_BOX (combo), GIMP_INT_STORE_VALUE, CURL_COLORS_FG_BG, GIMP_INT_STORE_LABEL, _("Foreground / background colors"), GIMP_INT_STORE_STOCK_ID, GIMP_STOCK_DEFAULT_COLORS, -1); gtk_box_pack_start (GTK_BOX (vbox), combo, FALSE, FALSE, 0); gtk_widget_show (combo); gimp_int_combo_box_connect (GIMP_INT_COMBO_BOX (combo), curl.colors, G_CALLBACK (gimp_int_combo_box_get_active), &curl.colors); gtk_widget_show (dialog); table = gtk_table_new (1, 3, FALSE); gtk_table_set_col_spacings (GTK_TABLE (table), 6); gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0); gtk_widget_show (table); adjustment = gimp_scale_entry_new (GTK_TABLE (table), 0, 0, _("_Opacity:"), 100, 0, curl.opacity * 100.0, 0.0, 100.0, 1.0, 1.0, 0.0, TRUE, 0, 0, NULL, NULL); g_signal_connect (adjustment, "value-changed", G_CALLBACK (dialog_scale_update), &curl.opacity); run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK); gtk_widget_destroy (dialog); return run; }
GtkWidget* create_dialog1 (void) { GtkWidget *dialog1; GtkWidget *dialog_vbox1; GtkWidget *vbox1; GtkWidget *table1; GtkWidget *label1; GtkWidget *comboboxOrder; GtkWidget *label2; GtkWidget *comboboxInterpolate; GtkWidget *label3; GtkWidget *comboboxType; GtkWidget *label4; GtkWidget *comboboxMnt; GtkWidget *label7; GtkWidget *checkbuttonChroma; GtkWidget *label8; GtkWidget *checkbuttonTryweave; GtkWidget *label10; GtkWidget *checkbuttonDenoise; GtkWidget *label9; GtkWidget *combobox5; GtkWidget *label5; GtkWidget *checkbuttonSharp; GtkWidget *label16; GtkWidget *checkbuttonFull; GtkWidget *label6; GtkWidget *combobox6; GtkWidget *table2; GtkWidget *label11; GtkWidget *label12; GtkObject *spinbuttonmthreshL_adj; GtkWidget *spinbuttonmthreshL; GtkObject *spinbuttonmthreshC_adj; GtkWidget *spinbuttonmthreshC; GtkWidget *label13; GtkObject *spinbuttoncthresh_adj; GtkWidget *spinbuttoncthresh; GtkWidget *label14; GtkObject *spinbuttonMI_adj; GtkWidget *spinbuttonMI; GtkWidget *label15; GtkObject *spinbuttonAP_adj; GtkWidget *spinbuttonAP; GtkWidget *dialog_action_area1; GtkWidget *cancelbutton1; GtkWidget *okbutton1; dialog1 = gtk_dialog_new (); gtk_window_set_title (GTK_WINDOW (dialog1), _("TDeint param")); gtk_window_set_type_hint (GTK_WINDOW (dialog1), GDK_WINDOW_TYPE_HINT_DIALOG); dialog_vbox1 = GTK_DIALOG (dialog1)->vbox; gtk_widget_show (dialog_vbox1); vbox1 = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox1); gtk_box_pack_start (GTK_BOX (dialog_vbox1), vbox1, TRUE, TRUE, 0); table1 = gtk_table_new (11, 2, FALSE); gtk_widget_show (table1); gtk_box_pack_start (GTK_BOX (vbox1), table1, TRUE, TRUE, 0); label1 = gtk_label_new (_("Field Order :")); gtk_widget_show (label1); gtk_table_attach (GTK_TABLE (table1), label1, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label1), 0, 0.5); comboboxOrder = gtk_combo_box_new_text (); gtk_widget_show (comboboxOrder); gtk_table_attach (GTK_TABLE (table1), comboboxOrder, 1, 2, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); gtk_combo_box_append_text (GTK_COMBO_BOX (comboboxOrder), _("Bottom Field First")); gtk_combo_box_append_text (GTK_COMBO_BOX (comboboxOrder), _("Top Field First")); label2 = gtk_label_new (_("Interpolate :")); gtk_widget_show (label2); gtk_table_attach (GTK_TABLE (table1), label2, 0, 1, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label2), 0, 0.5); comboboxInterpolate = gtk_combo_box_new_text (); gtk_widget_show (comboboxInterpolate); gtk_table_attach (GTK_TABLE (table1), comboboxInterpolate, 1, 2, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); gtk_combo_box_append_text (GTK_COMBO_BOX (comboboxInterpolate), _("Top field (keep bottom)")); gtk_combo_box_append_text (GTK_COMBO_BOX (comboboxInterpolate), _("Bottom field (keep top)")); label3 = gtk_label_new (_("Type")); gtk_widget_show (label3); gtk_table_attach (GTK_TABLE (table1), label3, 0, 1, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label3), 0, 0.5); comboboxType = gtk_combo_box_new_text (); gtk_widget_show (comboboxType); gtk_table_attach (GTK_TABLE (table1), comboboxType, 1, 2, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); gtk_combo_box_append_text (GTK_COMBO_BOX (comboboxType), _("Cubic Interpolation")); gtk_combo_box_append_text (GTK_COMBO_BOX (comboboxType), _("Modified ELA")); gtk_combo_box_append_text (GTK_COMBO_BOX (comboboxType), _("Kernerl interpolation")); gtk_combo_box_append_text (GTK_COMBO_BOX (comboboxType), _("Modified ELA-2")); label4 = gtk_label_new (_("MntMode")); gtk_widget_show (label4); gtk_table_attach (GTK_TABLE (table1), label4, 0, 1, 3, 4, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label4), 0, 0.5); comboboxMnt = gtk_combo_box_new_text (); gtk_widget_show (comboboxMnt); gtk_table_attach (GTK_TABLE (table1), comboboxMnt, 1, 2, 3, 4, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); gtk_combo_box_append_text (GTK_COMBO_BOX (comboboxMnt), _("4 field check")); gtk_combo_box_append_text (GTK_COMBO_BOX (comboboxMnt), _("5 field check")); gtk_combo_box_append_text (GTK_COMBO_BOX (comboboxMnt), _("4 field check (no average)")); gtk_combo_box_append_text (GTK_COMBO_BOX (comboboxMnt), _("5 field check (no average)")); label7 = gtk_label_new (_("Use Chroma to evalute")); gtk_widget_show (label7); gtk_table_attach (GTK_TABLE (table1), label7, 0, 1, 6, 7, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label7), 0, 0.5); checkbuttonChroma = gtk_check_button_new_with_mnemonic (""); gtk_widget_show (checkbuttonChroma); gtk_table_attach (GTK_TABLE (table1), checkbuttonChroma, 1, 2, 6, 7, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); label8 = gtk_label_new (_("Try weave ")); gtk_widget_show (label8); gtk_table_attach (GTK_TABLE (table1), label8, 0, 1, 7, 8, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label8), 0, 0.5); checkbuttonTryweave = gtk_check_button_new_with_mnemonic (""); gtk_widget_show (checkbuttonTryweave); gtk_table_attach (GTK_TABLE (table1), checkbuttonTryweave, 1, 2, 7, 8, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); label10 = gtk_label_new (_("Denoise")); gtk_widget_show (label10); gtk_table_attach (GTK_TABLE (table1), label10, 0, 1, 8, 9, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label10), 0, 0.5); checkbuttonDenoise = gtk_check_button_new_with_mnemonic (""); gtk_widget_show (checkbuttonDenoise); gtk_table_attach (GTK_TABLE (table1), checkbuttonDenoise, 1, 2, 8, 9, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); label9 = gtk_label_new (_("Link")); gtk_widget_show (label9); gtk_table_attach (GTK_TABLE (table1), label9, 0, 1, 4, 5, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label9), 0, 0.5); combobox5 = gtk_combo_box_new_text (); gtk_widget_show (combobox5); gtk_table_attach (GTK_TABLE (table1), combobox5, 1, 2, 4, 5, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); gtk_combo_box_append_text (GTK_COMBO_BOX (combobox5), _("No link")); gtk_combo_box_append_text (GTK_COMBO_BOX (combobox5), _("Full linking")); gtk_combo_box_append_text (GTK_COMBO_BOX (combobox5), _("Y to UV link")); gtk_combo_box_append_text (GTK_COMBO_BOX (combobox5), _("UV to Y link")); label5 = gtk_label_new (_("Sharp :")); gtk_widget_show (label5); gtk_table_attach (GTK_TABLE (table1), label5, 0, 1, 9, 10, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label5), 0, 0.5); checkbuttonSharp = gtk_check_button_new_with_mnemonic (""); gtk_widget_show (checkbuttonSharp); gtk_table_attach (GTK_TABLE (table1), checkbuttonSharp, 1, 2, 9, 10, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); label16 = gtk_label_new (_("AP type")); gtk_widget_show (label16); gtk_table_attach (GTK_TABLE (table1), label16, 0, 1, 5, 6, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label16), 0, 0.5); checkbuttonFull = gtk_check_button_new_with_mnemonic (""); gtk_widget_show (checkbuttonFull); gtk_table_attach (GTK_TABLE (table1), checkbuttonFull, 1, 2, 10, 11, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); label6 = gtk_label_new (_("Evaluate ALL frames")); gtk_widget_show (label6); gtk_table_attach (GTK_TABLE (table1), label6, 0, 1, 10, 11, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label6), 0, 0.5); combobox6 = gtk_combo_box_new_text (); gtk_widget_show (combobox6); gtk_table_attach (GTK_TABLE (table1), combobox6, 1, 2, 5, 6, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); gtk_combo_box_append_text (GTK_COMBO_BOX (combobox6), _("0 (read manual)")); gtk_combo_box_append_text (GTK_COMBO_BOX (combobox6), _("1 (read manual)")); gtk_combo_box_append_text (GTK_COMBO_BOX (combobox6), _("2 (read manual)")); table2 = gtk_table_new (5, 2, FALSE); gtk_widget_show (table2); gtk_box_pack_start (GTK_BOX (vbox1), table2, TRUE, TRUE, 0); label11 = gtk_label_new (_("motion Threshold, Luma")); gtk_widget_show (label11); gtk_table_attach (GTK_TABLE (table2), label11, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label11), 0, 0.5); label12 = gtk_label_new (_("motion Threshold, Chroma")); gtk_widget_show (label12); gtk_table_attach (GTK_TABLE (table2), label12, 0, 1, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label12), 0, 0.5); spinbuttonmthreshL_adj = gtk_adjustment_new (1, 0, 255, 1, 10, 10); spinbuttonmthreshL = gtk_spin_button_new (GTK_ADJUSTMENT (spinbuttonmthreshL_adj), 1, 0); gtk_widget_show (spinbuttonmthreshL); gtk_table_attach (GTK_TABLE (table2), spinbuttonmthreshL, 1, 2, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbuttonmthreshL), TRUE); spinbuttonmthreshC_adj = gtk_adjustment_new (1, 0, 255, 1, 10, 10); spinbuttonmthreshC = gtk_spin_button_new (GTK_ADJUSTMENT (spinbuttonmthreshC_adj), 1, 0); gtk_widget_show (spinbuttonmthreshC); gtk_table_attach (GTK_TABLE (table2), spinbuttonmthreshC, 1, 2, 1, 2, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbuttonmthreshC), TRUE); label13 = gtk_label_new (_("Area Combing Threshold")); gtk_widget_show (label13); gtk_table_attach (GTK_TABLE (table2), label13, 0, 1, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label13), 0, 0.5); spinbuttoncthresh_adj = gtk_adjustment_new (1, 0, 255, 1, 10, 10); spinbuttoncthresh = gtk_spin_button_new (GTK_ADJUSTMENT (spinbuttoncthresh_adj), 1, 0); gtk_widget_show (spinbuttoncthresh); gtk_table_attach (GTK_TABLE (table2), spinbuttoncthresh, 1, 2, 2, 3, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); label14 = gtk_label_new (_("Combed Treshold")); gtk_widget_show (label14); gtk_table_attach (GTK_TABLE (table2), label14, 0, 1, 3, 4, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label14), 0, 0.5); spinbuttonMI_adj = gtk_adjustment_new (1, 0, 255, 1, 10, 10); spinbuttonMI = gtk_spin_button_new (GTK_ADJUSTMENT (spinbuttonMI_adj), 1, 0); gtk_widget_show (spinbuttonMI); gtk_table_attach (GTK_TABLE (table2), spinbuttonMI, 1, 2, 3, 4, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbuttonMI), TRUE); label15 = gtk_label_new (_("Artefact Protection threshold ")); gtk_widget_show (label15); gtk_table_attach (GTK_TABLE (table2), label15, 0, 1, 4, 5, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label15), 0, 0.5); spinbuttonAP_adj = gtk_adjustment_new (1, 0, 255, 1, 10, 10); spinbuttonAP = gtk_spin_button_new (GTK_ADJUSTMENT (spinbuttonAP_adj), 1, 0); gtk_widget_show (spinbuttonAP); gtk_table_attach (GTK_TABLE (table2), spinbuttonAP, 1, 2, 4, 5, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbuttonAP), TRUE); dialog_action_area1 = GTK_DIALOG (dialog1)->action_area; gtk_widget_show (dialog_action_area1); gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area1), GTK_BUTTONBOX_END); cancelbutton1 = gtk_button_new_from_stock ("gtk-cancel"); gtk_widget_show (cancelbutton1); gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), cancelbutton1, GTK_RESPONSE_CANCEL); GTK_WIDGET_SET_FLAGS (cancelbutton1, GTK_CAN_DEFAULT); okbutton1 = gtk_button_new_from_stock ("gtk-ok"); gtk_widget_show (okbutton1); gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), okbutton1, GTK_RESPONSE_OK); GTK_WIDGET_SET_FLAGS (okbutton1, GTK_CAN_DEFAULT); /* Store pointers to all widgets, for use by lookup_widget(). */ GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog1, "dialog1"); GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_vbox1, "dialog_vbox1"); GLADE_HOOKUP_OBJECT (dialog1, vbox1, "vbox1"); GLADE_HOOKUP_OBJECT (dialog1, table1, "table1"); GLADE_HOOKUP_OBJECT (dialog1, label1, "label1"); GLADE_HOOKUP_OBJECT (dialog1, comboboxOrder, "comboboxOrder"); GLADE_HOOKUP_OBJECT (dialog1, label2, "label2"); GLADE_HOOKUP_OBJECT (dialog1, comboboxInterpolate, "comboboxInterpolate"); GLADE_HOOKUP_OBJECT (dialog1, label3, "label3"); GLADE_HOOKUP_OBJECT (dialog1, comboboxType, "comboboxType"); GLADE_HOOKUP_OBJECT (dialog1, label4, "label4"); GLADE_HOOKUP_OBJECT (dialog1, comboboxMnt, "comboboxMnt"); GLADE_HOOKUP_OBJECT (dialog1, label7, "label7"); GLADE_HOOKUP_OBJECT (dialog1, checkbuttonChroma, "checkbuttonChroma"); GLADE_HOOKUP_OBJECT (dialog1, label8, "label8"); GLADE_HOOKUP_OBJECT (dialog1, checkbuttonTryweave, "checkbuttonTryweave"); GLADE_HOOKUP_OBJECT (dialog1, label10, "label10"); GLADE_HOOKUP_OBJECT (dialog1, checkbuttonDenoise, "checkbuttonDenoise"); GLADE_HOOKUP_OBJECT (dialog1, label9, "label9"); GLADE_HOOKUP_OBJECT (dialog1, combobox5, "combobox5"); GLADE_HOOKUP_OBJECT (dialog1, label5, "label5"); GLADE_HOOKUP_OBJECT (dialog1, checkbuttonSharp, "checkbuttonSharp"); GLADE_HOOKUP_OBJECT (dialog1, label16, "label16"); GLADE_HOOKUP_OBJECT (dialog1, checkbuttonFull, "checkbuttonFull"); GLADE_HOOKUP_OBJECT (dialog1, label6, "label6"); GLADE_HOOKUP_OBJECT (dialog1, combobox6, "combobox6"); GLADE_HOOKUP_OBJECT (dialog1, table2, "table2"); GLADE_HOOKUP_OBJECT (dialog1, label11, "label11"); GLADE_HOOKUP_OBJECT (dialog1, label12, "label12"); GLADE_HOOKUP_OBJECT (dialog1, spinbuttonmthreshL, "spinbuttonmthreshL"); GLADE_HOOKUP_OBJECT (dialog1, spinbuttonmthreshC, "spinbuttonmthreshC"); GLADE_HOOKUP_OBJECT (dialog1, label13, "label13"); GLADE_HOOKUP_OBJECT (dialog1, spinbuttoncthresh, "spinbuttoncthresh"); GLADE_HOOKUP_OBJECT (dialog1, label14, "label14"); GLADE_HOOKUP_OBJECT (dialog1, spinbuttonMI, "spinbuttonMI"); GLADE_HOOKUP_OBJECT (dialog1, label15, "label15"); GLADE_HOOKUP_OBJECT (dialog1, spinbuttonAP, "spinbuttonAP"); GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_action_area1, "dialog_action_area1"); GLADE_HOOKUP_OBJECT (dialog1, cancelbutton1, "cancelbutton1"); GLADE_HOOKUP_OBJECT (dialog1, okbutton1, "okbutton1"); return dialog1; }
void gtr_confirm_remove (GtkWindow * parent, TrCore * core, GSList * torrent_ids, gboolean delete_files) { GSList * l; GtkWidget * d; GString * primary_text; GString * secondary_text; struct delete_data * dd; int connected = 0; int incomplete = 0; const int count = g_slist_length (torrent_ids); if (!count) return; dd = g_new0 (struct delete_data, 1); dd->core = core; dd->torrent_ids = torrent_ids; dd->delete_files = delete_files; for (l=torrent_ids; l!=NULL; l=l->next) { const int id = GPOINTER_TO_INT (l->data); tr_torrent * tor = gtr_core_find_torrent (core, id); const tr_stat * stat = tr_torrentStat (tor); if (stat->leftUntilDone) ++incomplete; if (stat->peersConnected) ++connected; } primary_text = g_string_new (NULL); if (!delete_files) { g_string_printf (primary_text, ngettext ("Remove Torrent?", "Remove %d Torrents?", count), count); } else { g_string_printf (primary_text, ngettext ("Delete this torrent's downloaded files?", "Delete these %d torrents' downloaded files?", count), count); } secondary_text = g_string_new (NULL); if (!incomplete && !connected) { g_string_assign (secondary_text, ngettext ( "Once removed, continuing the transfer will require the torrent file or magnet link.", "Once removed, continuing the transfers will require the torrent files or magnet links.", count)); } else if (count == incomplete) { g_string_assign (secondary_text, ngettext ("This torrent has not finished downloading.", "These torrents have not finished downloading.", count)); } else if (count == connected) { g_string_assign (secondary_text, ngettext ("This torrent is connected to peers.", "These torrents are connected to peers.", count)); } else { if (connected) g_string_append (secondary_text, ngettext ("One of these torrents is connected to peers.", "Some of these torrents are connected to peers.", connected)); if (connected && incomplete) g_string_append (secondary_text, "\n"); if (incomplete) g_string_assign (secondary_text, ngettext ("One of these torrents has not finished downloading.", "Some of these torrents have not finished downloading.", incomplete)); } d = gtk_message_dialog_new_with_markup (parent, GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_QUESTION, GTK_BUTTONS_NONE, "<big><b>%s</b></big>", primary_text->str); if (secondary_text->len) gtk_message_dialog_format_secondary_markup (GTK_MESSAGE_DIALOG (d), "%s", secondary_text->str); gtk_dialog_add_buttons (GTK_DIALOG (d), _("_Cancel"), GTK_RESPONSE_CANCEL, (delete_files ? _("_Delete"): _("Remove")), GTK_RESPONSE_ACCEPT, NULL); gtk_dialog_set_default_response (GTK_DIALOG (d), GTK_RESPONSE_CANCEL); g_signal_connect (d, "response", G_CALLBACK (on_remove_dialog_response), dd); gtk_widget_show_all (d); g_string_free (primary_text, TRUE); g_string_free (secondary_text, TRUE); }
static void fnr_dialog_setup_common (GtkWidget *dialog, gboolean is_replace, DDisplay *ddisp) { GtkWidget *vbox; GtkWidget *hbox; GtkWidget *label; GtkWidget *search_entry; GtkWidget *match_case; GtkWidget *match_word; GtkWidget *match_all_properties; gtk_dialog_set_default_response (GTK_DIALOG (dialog), RESPONSE_FIND); /* don't destroy dialog when window manager close button pressed */ g_signal_connect(G_OBJECT (dialog), "response", G_CALLBACK(fnr_respond), ddisp); g_signal_connect(G_OBJECT(dialog), "delete_event", G_CALLBACK(gtk_widget_hide), NULL); g_signal_connect(GTK_OBJECT(dialog), "delete_event", G_CALLBACK(gtk_true), NULL); vbox = GTK_DIALOG(dialog)->vbox; hbox = gtk_hbox_new (FALSE, 12); label = gtk_label_new_with_mnemonic (_("_Search for:")); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); search_entry = gtk_entry_new (); g_object_set_data (G_OBJECT (dialog), "search-entry", search_entry); gtk_label_set_mnemonic_widget (GTK_LABEL (label), search_entry); gtk_entry_set_width_chars (GTK_ENTRY (search_entry), 30); gtk_box_pack_start (GTK_BOX (hbox), search_entry, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 6); if (is_replace) { GtkWidget *replace_entry; hbox = gtk_hbox_new (FALSE, 12); label = gtk_label_new_with_mnemonic (_("Replace _with:")); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); replace_entry = gtk_entry_new (); g_object_set_data (G_OBJECT (dialog), "replace-entry", replace_entry); gtk_label_set_mnemonic_widget (GTK_LABEL (label), replace_entry); gtk_entry_set_width_chars (GTK_ENTRY (replace_entry), 30); gtk_box_pack_start (GTK_BOX (hbox), replace_entry, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 6); } match_case = gtk_check_button_new_with_mnemonic (_("_Match case")); gtk_box_pack_start (GTK_BOX (vbox), match_case, FALSE, FALSE, 6); g_object_set_data (G_OBJECT (dialog), "match-case", match_case); match_word = gtk_check_button_new_with_mnemonic (_("Match _entire word only")); gtk_box_pack_start (GTK_BOX (vbox), match_word, FALSE, FALSE, 6); g_object_set_data (G_OBJECT (dialog), "match-word", match_word); match_all_properties = gtk_check_button_new_with_mnemonic (_("Match _all properties (not just object name)")); gtk_box_pack_start (GTK_BOX (vbox), match_all_properties, FALSE, FALSE, 6); g_object_set_data (G_OBJECT (dialog), "match-all-properties", match_all_properties); if (is_replace) gtk_widget_set_sensitive (GTK_WIDGET (match_all_properties), FALSE); gtk_widget_show_all (vbox); }
static GObject* close_confirmation_dialog_constructor (GType type, guint n_construct_properties, GObjectConstructParam *construct_params) { GObject *object; CloseConfirmationDialog *dialog; GtkWidget *hbox, *image, *vbox, *label; GtkTreeIter iter; gboolean ret, single_page; gchar *tmp, *str; const gchar *cstr; /* chain up to constructor of parent class */ object = G_OBJECT_CLASS (close_confirmation_dialog_parent_class)->constructor ( type, n_construct_properties, construct_params); dialog = CLOSE_CONFIRMATION_DIALOG (object); g_object_set (dialog, /* GtkDialog */ "has-separator", FALSE, /* GtkWindow */ "resizable", FALSE, "skip-taskbar-hint", TRUE, /* GtkContainer */ "border-width", 5, NULL); g_object_set (GTK_DIALOG (dialog)->vbox, /* GtkBox */ "spacing", 14, NULL); g_object_set (GTK_DIALOG (dialog)->action_area, /* GtkBox */ "spacing", 6, /* GtkContainer */ "border-width", 5, NULL); /* check if there is one or more than one page with changes */ ret = gtk_tree_model_get_iter_first (GTK_TREE_MODEL ( dialog->store_unsaved_pages), &iter); g_assert (ret); single_page = !gtk_tree_model_iter_next (GTK_TREE_MODEL ( dialog->store_unsaved_pages), &iter); /* here starts the layout of the dialog */ hbox = GTK_WIDGET (g_object_new (GTK_TYPE_HBOX, /* GtkContainer */ "border-width", 5, /* GtkBox */ "homogeneous", FALSE, "spacing", 12, NULL)); /* warning image */ image = GTK_WIDGET (g_object_new (GTK_TYPE_IMAGE, /* GtkMisc */ "xalign", 0.5, "yalign", 0.0, /* GtkImage */ "stock", GTK_STOCK_DIALOG_WARNING, "icon-size", GTK_ICON_SIZE_DIALOG, NULL)); gtk_box_pack_start (GTK_BOX (hbox), image, FALSE, FALSE, 0); /* vertical box on the right hand side of the dialog */ vbox = GTK_WIDGET (g_object_new (GTK_TYPE_VBOX, /* GtkBox */ "homogeneous", FALSE, "spacing", 12, NULL)); /* primary label */ if (single_page) { /* single page */ gchar *page_name; page_name = get_page_name (GTK_TREE_MODEL (dialog->store_unsaved_pages), NULL); tmp = g_strdup_printf ( _("Save the changes to schematic \"%1$s\" before closing?"), page_name); g_free (page_name); } else { /* multi page */ tmp = g_strdup_printf ( _("There are %1$d schematics with unsaved changes. " "Save changes before closing?"), count_pages (GTK_TREE_MODEL (dialog->store_unsaved_pages))); } str = g_strconcat ("<big><b>", tmp, "</b></big>", NULL); g_free (tmp); label = GTK_WIDGET (g_object_new (GTK_TYPE_LABEL, /* GtkMisc */ "xalign", 0.0, "yalign", 0.0, "selectable", TRUE, /* GtkLabel */ "wrap", TRUE, "use-markup", TRUE, "label", str, NULL)); g_free (str); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); if (!single_page) { /* more than one page with changes, display each page and offer */ /* the opportunity to save them before exiting */ gtk_box_pack_start (GTK_BOX (vbox), close_confirmation_dialog_build_page_list (dialog), FALSE, FALSE, 0); } /* secondary label */ cstr = _("If you don't save, all your changes will be permanently lost."); label = GTK_WIDGET (g_object_new (GTK_TYPE_LABEL, /* GtkMisc */ "xalign", 0.0, "yalign", 0.0, "selectable", TRUE, /* GtkLabel */ "wrap", TRUE, "label", cstr, NULL)); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0); /* add buttons to dialog action area */ gtk_dialog_add_buttons (GTK_DIALOG (dialog), _("Close _without saving"), GTK_RESPONSE_NO, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_SAVE, GTK_RESPONSE_YES, NULL); /* Set the alternative button order (ok, cancel, help) for other systems */ gtk_dialog_set_alternative_button_order(GTK_DIALOG(dialog), GTK_RESPONSE_YES, GTK_RESPONSE_NO, GTK_RESPONSE_CANCEL, -1); gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_YES); /* all done, let's show the contents of the dialog */ gtk_widget_show_all (hbox); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), hbox, FALSE, FALSE, 0); return object; }
void DictMngr::CreateReorderDialog() { GtkWidget *dialog, *selector; GtkCellRenderer *renderer; HildonTouchSelectorColumn *column; GtkTreeModel *tree_model; GtkTreeIter iter, iter2; GtkTreePath *path; gboolean iter_valid = TRUE; std::list < std::string > selected_dict_list; GtkListStore *dict_list = NULL; const gint RESPONSE_FIRST = 1; const gint RESPONSE_UP = 2; const gint RESPONSE_DOWN = 3; const gint RESPONSE_LAST = 4; gint response; dict_list = gtk_list_store_new(N_DICT_INFO_COLUMNS, G_TYPE_STRING, /* bookname */ G_TYPE_STRING); /* filename */ /* create dialog */ dialog = gtk_dialog_new(); gtk_window_set_modal(GTK_WINDOW(dialog), TRUE); gtk_window_set_title(GTK_WINDOW(dialog), _("Reorder")); gtk_dialog_add_button(GTK_DIALOG(dialog), _("First"), RESPONSE_FIRST); gtk_dialog_add_button(GTK_DIALOG(dialog), _("Up"), RESPONSE_UP); gtk_dialog_add_button(GTK_DIALOG(dialog), _("Down"), RESPONSE_DOWN); gtk_dialog_add_button(GTK_DIALOG(dialog), _("Last"), RESPONSE_LAST); gtk_dialog_add_button(GTK_DIALOG(dialog), "OK", GTK_RESPONSE_ACCEPT); gtk_window_set_default_size(GTK_WINDOW(dialog), -1, 400); /* dictionary selector */ selector = hildon_touch_selector_new(); gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), selector); renderer = gtk_cell_renderer_text_new(); g_object_set(G_OBJECT(renderer), "xpad", 10, "ellipsize", PANGO_ELLIPSIZE_END, "ellipsize-set", TRUE, NULL); column = hildon_touch_selector_append_column(HILDON_TOUCH_SELECTOR (selector), GTK_TREE_MODEL(dict_list), renderer, "text", BOOKNAME_DICT_INFO_COLUMN, NULL); hildon_touch_selector_column_set_text_column(column, 0); /* fill list with selected dictionaries */ oStarDict->oConf->GetStringList("/apps/maemo/mstardict/dict_list", selected_dict_list); for (std::list < std::string >::iterator i = selected_dict_list.begin(); i != selected_dict_list.end(); ++i) { DictInfo dictinfo; dictinfo.load_from_ifo_file(i->c_str(), 0); gtk_list_store_append(dict_list, &iter); gtk_list_store_set(dict_list, &iter, BOOKNAME_DICT_INFO_COLUMN, dictinfo.bookname.c_str(), FILENAME_DICT_INFO_COLUMN, i->c_str(), -1); } g_object_unref(dict_list); /* show dialog */ gtk_widget_show_all(GTK_WIDGET(dialog)); /* run the dialog */ while (TRUE) { response = gtk_dialog_run(GTK_DIALOG(dialog)); switch(response) { case RESPONSE_FIRST: tree_model = hildon_touch_selector_get_model(HILDON_TOUCH_SELECTOR(selector), BOOKNAME_DICT_INFO_COLUMN); if (hildon_touch_selector_get_selected(HILDON_TOUCH_SELECTOR(selector), BOOKNAME_DICT_INFO_COLUMN, &iter)) { gtk_list_store_move_after(GTK_LIST_STORE(tree_model), &iter, NULL); hildon_touch_selector_center_on_selected(HILDON_TOUCH_SELECTOR(selector)); } break; case RESPONSE_UP: tree_model = hildon_touch_selector_get_model(HILDON_TOUCH_SELECTOR(selector), BOOKNAME_DICT_INFO_COLUMN); if (hildon_touch_selector_get_selected(HILDON_TOUCH_SELECTOR(selector), BOOKNAME_DICT_INFO_COLUMN, &iter)) { path = gtk_tree_model_get_path(tree_model, &iter); gtk_tree_path_prev(path); if (gtk_tree_model_get_iter(tree_model, &iter2, path)) { gtk_list_store_swap(GTK_LIST_STORE(tree_model), &iter, &iter2); } gtk_tree_path_free(path); hildon_touch_selector_center_on_selected(HILDON_TOUCH_SELECTOR(selector)); } break; case RESPONSE_DOWN: tree_model = hildon_touch_selector_get_model(HILDON_TOUCH_SELECTOR(selector), BOOKNAME_DICT_INFO_COLUMN); if (hildon_touch_selector_get_selected(HILDON_TOUCH_SELECTOR(selector), BOOKNAME_DICT_INFO_COLUMN, &iter)) { path = gtk_tree_model_get_path(tree_model, &iter); gtk_tree_path_next(path); if (gtk_tree_model_get_iter(tree_model, &iter2, path)) { gtk_list_store_swap(GTK_LIST_STORE(tree_model), &iter, &iter2); } gtk_tree_path_free(path); hildon_touch_selector_center_on_selected(HILDON_TOUCH_SELECTOR(selector)); } break; case RESPONSE_LAST: tree_model = hildon_touch_selector_get_model(HILDON_TOUCH_SELECTOR(selector), BOOKNAME_DICT_INFO_COLUMN); if (hildon_touch_selector_get_selected(HILDON_TOUCH_SELECTOR(selector), BOOKNAME_DICT_INFO_COLUMN, &iter)) { gtk_list_store_move_before(GTK_LIST_STORE(tree_model), &iter, NULL); hildon_touch_selector_center_on_selected(HILDON_TOUCH_SELECTOR(selector)); } break; case GTK_RESPONSE_ACCEPT: tree_model = hildon_touch_selector_get_model(HILDON_TOUCH_SELECTOR(selector), BOOKNAME_DICT_INFO_COLUMN); iter_valid = gtk_tree_model_get_iter_first(tree_model, &iter); selected_dict_list.clear(); while (iter_valid) { const gchar *filename; gtk_tree_model_get(GTK_TREE_MODEL(tree_model), &iter, FILENAME_DICT_INFO_COLUMN, &filename, -1); selected_dict_list.push_back(std::string(filename)); iter_valid = gtk_tree_model_iter_next(tree_model, &iter); } if (oStarDict->oConf->SetStringList("/apps/maemo/mstardict/dict_list", selected_dict_list)) { /* reload dictionaries */ ReLoadDictionaries(selected_dict_list); } gtk_widget_destroy(GTK_WIDGET(dialog)); return; default: gtk_widget_destroy(GTK_WIDGET(dialog)); return; } } }
/*! \brief Asks for confirmation before closing a window. * \par Function Description * This function asks the user to confirm its closing order for * the given window. * * The user is given the possibility to save the pages that currently * have unsaved changes, if any. * * It returns TRUE if the user really accepts the close of the * window. Otherwise the user has somehow cancelled and the window * must not be closed. * * \param [in] w_current The toplevel environment. * \returns TRUE if the window can be closed, FALSE otherwise. */ gboolean x_dialog_close_window (GschemToplevel *w_current) { TOPLEVEL *toplevel = gschem_toplevel_get_toplevel (w_current); GList *iter; GtkWidget *dialog; PAGE *p_current; PAGE *keep_page; GList *unsaved_pages, *p_unsaved; gboolean ret = FALSE; keep_page = toplevel->page_current; for ( iter = geda_list_get_glist( toplevel->pages ), unsaved_pages = NULL; iter != NULL; iter = g_list_next( iter ) ) { p_current = (PAGE*)iter->data; if (p_current->CHANGED) { unsaved_pages = g_list_append (unsaved_pages, (gpointer)p_current); } } if (unsaved_pages == NULL) { /* no page with unsaved changes, close window */ return TRUE; } dialog = GTK_WIDGET (g_object_new (TYPE_CLOSE_CONFIRMATION_DIALOG, "unsaved-pages", unsaved_pages, NULL)); gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (w_current->main_window)); g_list_free (unsaved_pages); switch (gtk_dialog_run (GTK_DIALOG (dialog))) { case GTK_RESPONSE_NO: /* action selected: close without saving */ /* discard changes, ok to close window */ ret = TRUE; break; case GTK_RESPONSE_YES: /* action selected: save */ g_object_get (dialog, "selected-pages", &unsaved_pages, NULL); for (p_unsaved = unsaved_pages, ret = TRUE; p_unsaved != NULL; p_unsaved = g_list_next (p_unsaved)) { p_current = (PAGE*)p_unsaved->data; s_page_goto (toplevel, p_current); gschem_toplevel_page_changed (w_current); i_callback_file_save(w_current, 0, NULL); /* if user cancelled previous, do not close window */ ret &= !p_current->CHANGED; } g_list_free (unsaved_pages); break; case GTK_RESPONSE_CANCEL: /* action selected: cancel */ /* fall through */ default: /* Hit when the user breaks out of the dialog with the escape key * or otherwise destroys the dialog window without a proper response */ ret = FALSE; break; } gtk_widget_destroy (dialog); /* Switch back to the page we were on */ g_return_val_if_fail (keep_page != NULL, ret); s_page_goto (toplevel, keep_page); gschem_toplevel_page_changed (w_current); return ret; }
/** * crée la boite de dialogue initiale avec le GtkIconView * * \param nom de l'icône * * \return le nouveau nom de l'icône ou NULL * */ gchar * gsb_select_icon_create_window ( gchar *name_icon ) { GtkWidget *content_area; GtkWidget *hbox; GtkWidget *chooser_button; GtkWidget *scroll; GtkWidget *icon_view; gint result; devel_debug ( name_icon ); if ( new_icon && strlen ( new_icon ) > 0 ) g_free ( new_icon ); new_icon = g_strdup ( name_icon ); path_icon = g_path_get_dirname ( name_icon ); dialog = gtk_dialog_new_with_buttons ( _("Browse icons"), GTK_WINDOW ( run.window ), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, NULL); gtk_window_set_position ( GTK_WINDOW ( dialog ), GTK_WIN_POS_CENTER_ON_PARENT ); gtk_window_set_resizable ( GTK_WINDOW ( dialog ), TRUE ); bouton_OK = gtk_dialog_add_button (GTK_DIALOG ( dialog ), GTK_STOCK_OK, GTK_RESPONSE_ACCEPT); gtk_widget_set_size_request ( dialog, 400, 450 ); content_area = GTK_DIALOG ( dialog ) -> vbox; /* création hbox pour GtkEntry répertoire et bouton sélection des répertoires */ hbox = gtk_hbox_new ( FALSE, 5); gtk_container_set_border_width ( GTK_CONTAINER( hbox ), 6 ); gtk_box_pack_start ( GTK_BOX ( content_area ), hbox, FALSE, FALSE, 5 ); /* création du GtkComboBoxEntry pour la saisie du répertoire */ entry_text = gsb_select_icon_create_entry_text ( name_icon ); gtk_box_pack_start ( GTK_BOX ( hbox ), entry_text, TRUE, TRUE, 0 ); /* création du bouton de sélection des répertoires */ chooser_button = gtk_button_new_with_label ( _("Browse") ); gtk_box_pack_start ( GTK_BOX ( hbox ), chooser_button, FALSE, FALSE, 0 ); /* création de la vue pour les icônes */ scroll = gtk_scrolled_window_new ( NULL, NULL); gtk_scrolled_window_set_policy ( GTK_SCROLLED_WINDOW ( scroll ), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_box_pack_start ( GTK_BOX ( content_area ), scroll, TRUE, TRUE, 0 ); icon_view = gsb_select_icon_create_icon_view ( name_icon ); gtk_container_set_border_width ( GTK_CONTAINER( scroll ), 6 ); gtk_container_add ( GTK_CONTAINER ( scroll ), icon_view ); /* gestion des signaux */ g_signal_connect ( G_OBJECT ( icon_view ), "selection-changed", G_CALLBACK( gsb_select_icon_selection_changed ), NULL ); g_signal_connect ( G_OBJECT ( chooser_button ), "clicked", G_CALLBACK(gsb_select_icon_create_file_chooser), NULL ); g_signal_connect ( G_OBJECT( entry_text ), "changed", G_CALLBACK( gsb_select_icon_entry_text_changed ), NULL ); gtk_widget_show_all ( dialog ); result = gtk_dialog_run (GTK_DIALOG (dialog)); switch (result) { case GTK_RESPONSE_ACCEPT: devel_debug ( "réponse OK" ); break; default: devel_debug ( "réponse Non OK" ); if ( new_icon && strlen ( new_icon ) > 0 ) g_free ( new_icon ); new_icon = NULL; break; } gtk_widget_destroy (dialog); return new_icon; }
static void gimp_file_entry_browse_clicked (GtkWidget *widget, GimpFileEntry *entry) { GtkFileChooser *chooser; gchar *utf8; gchar *filename; utf8 = gtk_editable_get_chars (GTK_EDITABLE (entry->entry), 0, -1); filename = g_filename_from_utf8 (utf8, -1, NULL, NULL, NULL); g_free (utf8); if (! entry->file_dialog) { const gchar *title = entry->title; if (! title) { if (entry->dir_only) title = _("Select Folder"); else title = _("Select File"); } entry->file_dialog = gtk_file_chooser_dialog_new (title, NULL, entry->dir_only ? GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER : GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_alternative_button_order (GTK_DIALOG (entry->file_dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); chooser = GTK_FILE_CHOOSER (entry->file_dialog); gtk_window_set_position (GTK_WINDOW (chooser), GTK_WIN_POS_MOUSE); gtk_window_set_role (GTK_WINDOW (chooser), "gimp-file-entry-file-dialog"); g_signal_connect (chooser, "response", G_CALLBACK (gimp_file_entry_chooser_response), entry); g_signal_connect (chooser, "delete-event", G_CALLBACK (gtk_true), NULL); g_signal_connect_swapped (entry, "unmap", G_CALLBACK (gtk_widget_hide), chooser); } else { chooser = GTK_FILE_CHOOSER (entry->file_dialog); } gtk_file_chooser_set_filename (chooser, filename); g_free (filename); gtk_window_set_screen (GTK_WINDOW (chooser), gtk_widget_get_screen (widget)); gtk_window_present (GTK_WINDOW (chooser)); }
void dlg_preferences (GthBrowser *browser) { DialogData *data; GtkWidget *notebook; GList *children; GList *scan; int page_num; GtkWidget *list_box; GtkTreeSelection *selection; if (gth_browser_get_dialog (browser, "preferences") != NULL) { gtk_window_present (GTK_WINDOW (gth_browser_get_dialog (browser, "preferences"))); return; } data = g_new0 (DialogData, 1); data->browser = browser; data->builder = _gtk_builder_new_from_file ("preferences.ui", NULL); data->dialog = GET_WIDGET ("preferences_dialog"); gtk_container_set_border_width (GTK_CONTAINER (gtk_dialog_get_content_area (GTK_DIALOG (data->dialog))), 0); gth_browser_set_dialog (browser, "preferences", data->dialog); gth_hook_invoke ("dlg-preferences-construct", data->dialog, data->browser, data->builder); /* widgets */ list_box = GET_WIDGET ("tabs_listbox"); notebook = GET_WIDGET ("notebook"); children = gtk_container_get_children (GTK_CONTAINER (notebook)); page_num = 0; for (scan = children; scan; scan = scan->next) { GtkWidget *child = scan->data; const char *name; GtkWidget *row; GtkWidget *box; GtkWidget *label; name = gtk_notebook_get_tab_label_text (GTK_NOTEBOOK (notebook), child); if (name == NULL) continue; if (scan != children) _gtk_list_box_add_separator (GTK_LIST_BOX (list_box)); row = gtk_list_box_row_new (); g_object_set_data (G_OBJECT (row), "gth.page_num", GINT_TO_POINTER (page_num)); gtk_widget_show (row); gtk_container_add (GTK_CONTAINER (list_box), row); box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); gtk_container_set_border_width (GTK_CONTAINER (box), 10); gtk_widget_show (box); gtk_container_add (GTK_CONTAINER (row), box); label = gtk_label_new (name); gtk_label_set_ellipsize (GTK_LABEL(label), PANGO_ELLIPSIZE_END); gtk_widget_show (label); gtk_container_add (GTK_CONTAINER (box), label); page_num += 1; } /* Set the signals handlers. */ g_signal_connect (data->dialog, "destroy", G_CALLBACK (destroy_cb), data); g_signal_connect (list_box, "row-activated", G_CALLBACK (list_box_row_activated_cb), data); /* run dialog. */ gtk_window_set_transient_for (GTK_WINDOW (data->dialog), GTK_WINDOW (browser)); gtk_widget_show (data->dialog); }
static void on_dialog_add_edit_reponse (GtkWidget *dialog, int response_id, LogviewFilterManager *manager) { GtkWidget *entry_name, *entry_regex; GtkWidget *radio_color, *radio_visible; GtkWidget *check_foreground, *check_background; GtkWidget *color_foreground, *color_background; gchar *old_name; const gchar *name; const gchar *regex; LogviewFilter *filter; GtkTextTag *tag; GtkBuilder *builder; old_name = g_object_get_data (G_OBJECT (manager), "old_name"); builder = manager->priv->builder; entry_name = GTK_WIDGET (gtk_builder_get_object (builder, "entry_name")); entry_regex = GTK_WIDGET (gtk_builder_get_object (builder, "entry_regex")); radio_color = GTK_WIDGET (gtk_builder_get_object (builder, "radio_color")); radio_visible = GTK_WIDGET (gtk_builder_get_object (builder, "radio_visible")); check_foreground = GTK_WIDGET (gtk_builder_get_object (builder, "check_foreground")); check_background = GTK_WIDGET (gtk_builder_get_object (builder, "check_background")); color_foreground = GTK_WIDGET (gtk_builder_get_object (builder, "color_foreground")); color_background = GTK_WIDGET (gtk_builder_get_object (builder, "color_background")); if (response_id == GTK_RESPONSE_APPLY) { name = gtk_entry_get_text (GTK_ENTRY (entry_name)); regex = gtk_entry_get_text (GTK_ENTRY (entry_regex)); if (!check_name (manager, name) || !check_regex (manager, regex)) { return; } filter = logview_filter_new (name, regex); tag = gtk_text_tag_new (name); if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (radio_color))) { if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (check_foreground))) { GdkColor foreground_color; gtk_color_button_get_color (GTK_COLOR_BUTTON (color_foreground), &foreground_color); g_object_set (G_OBJECT (tag), "foreground-gdk", &foreground_color, "foreground-set", TRUE, NULL); } if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (check_background))) { GdkColor background_color; gtk_color_button_get_color (GTK_COLOR_BUTTON (color_background), &background_color); g_object_set (tag, "paragraph-background-gdk", &background_color, "paragraph-background-set", TRUE, NULL); } if (!gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (check_foreground)) && !gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (check_background))) { GtkWidget *error_dialog; error_dialog = gtk_message_dialog_new (GTK_WINDOW (manager), GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, "%s", _("Please specify either foreground or background color!")); gtk_dialog_run (GTK_DIALOG (error_dialog)); gtk_widget_destroy (error_dialog); g_object_unref (tag); g_object_unref (filter); return; } } else { /* !gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (radio_color)) */ g_object_set (tag, "invisible", TRUE, NULL); } if (old_name && !g_str_equal (old_name, name)) { logview_prefs_remove_filter (manager->priv->prefs, old_name); } g_object_set (G_OBJECT (filter), "texttag", tag, NULL); g_object_unref (tag); logview_prefs_add_filter (manager->priv->prefs, filter); g_object_unref (filter); logview_filter_manager_update_model (manager); } gtk_widget_destroy (dialog); }