static void PopulateForm(int pgs) { if (pgs & (1<<TAB_CONFIG)) { int mode3d, i; GtkListStore *modes3d; GtkTreeIter iter; GtkComboBox *box3d; char buf[64]; mode3d = checkvideomode(&settings.xdim3d, &settings.ydim3d, settings.bpp3d, settings.fullscreen, 1); if (mode3d < 0) { int i, cd[] = { 32, 24, 16, 15, 8, 0 }; for (i=0; cd[i]; ) { if (cd[i] >= settings.bpp3d) i++; else break; } for ( ; cd[i]; i++) { mode3d = checkvideomode(&settings.xdim3d, &settings.ydim3d, cd[i], settings.fullscreen, 1); if (mode3d < 0) continue; settings.bpp3d = cd[i]; break; } } gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(lookup_widget(startwin,"fullscreencheck")), settings.fullscreen); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(lookup_widget(startwin,"alwaysshowcheck")), settings.forcesetup); box3d = GTK_COMBO_BOX(lookup_widget(startwin,"vmode3dcombo")); modes3d = GTK_LIST_STORE(gtk_combo_box_get_model(box3d)); gtk_list_store_clear(modes3d); for (i=0; i<validmodecnt; i++) { if (validmode[i].fs != settings.fullscreen) continue; // all modes get added to the 3D mode list Bsprintf(buf, "%d x %d %dbpp", validmode[i].xdim, validmode[i].ydim, validmode[i].bpp); gtk_list_store_append(modes3d, &iter); gtk_list_store_set(modes3d, &iter, 0,buf, 1,i, -1); if (i == mode3d) { g_signal_handlers_block_by_func(box3d, on_vmode3dcombo_changed, NULL); gtk_combo_box_set_active_iter(box3d, &iter); g_signal_handlers_unblock_by_func(box3d, on_vmode3dcombo_changed, NULL); } } gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(lookup_widget(startwin,"inputmousecheck")), settings.usemouse); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(lookup_widget(startwin,"inputjoycheck")), settings.usejoy); } if (pgs & (1<<TAB_GAME)) { struct grpfile *fg; int i; GtkListStore *list; GtkTreeIter iter; GtkTreeView *gamelist; gamelist = GTK_TREE_VIEW(lookup_widget(startwin,"gamelist")); list = GTK_LIST_STORE(gtk_tree_view_get_model(gamelist)); gtk_list_store_clear(list); for (fg = foundgrps; fg; fg=fg->next) { for (i = 0; i<numgrpfiles; i++) if (fg->crcval == grpfiles[i].crcval) break; if (i == numgrpfiles) continue; // unrecognised grp file gtk_list_store_append(list, &iter); gtk_list_store_set(list, &iter, 0, grpfiles[i].name, 1, fg->name, 2, (gpointer)fg, -1); if (!Bstrcasecmp(fg->name, settings.selectedgrp)) { GtkTreeSelection *sel = gtk_tree_view_get_selection(gamelist); g_signal_handlers_block_by_func(sel, on_gamelist_selection_changed, NULL); gtk_tree_selection_select_iter(sel, &iter); g_signal_handlers_unblock_by_func(sel, on_gamelist_selection_changed, NULL); } } } }
static void update_button_state (ButtonData *button_data) { gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button_data->button), button_data->showing_bigboard); update_button_display (button_data); }
static void mpg123_configurewin_ok(GtkWidget * widget, gpointer data) { ConfigFile *cfg; gchar *filename; if (GTK_TOGGLE_BUTTON(decode_res_16)->active) mpg123_cfg.resolution = 16; else if (GTK_TOGGLE_BUTTON(decode_res_8)->active) mpg123_cfg.resolution = 8; if (GTK_TOGGLE_BUTTON(decode_ch_stereo)->active) mpg123_cfg.channels = 2; else if (GTK_TOGGLE_BUTTON(decode_ch_mono)->active) mpg123_cfg.channels = 1; if (GTK_TOGGLE_BUTTON(decode_freq_1to1)->active) mpg123_cfg.downsample = 0; else if (GTK_TOGGLE_BUTTON(decode_freq_1to2)->active) mpg123_cfg.downsample = 1; if (GTK_TOGGLE_BUTTON(decode_freq_1to4)->active) mpg123_cfg.downsample = 2; if (GTK_TOGGLE_BUTTON(detect_by_content)->active) mpg123_cfg.detect_by = DETECT_CONTENT; else if (GTK_TOGGLE_BUTTON(detect_by_extension)->active) mpg123_cfg.detect_by = DETECT_EXTENSION; else if (GTK_TOGGLE_BUTTON(detect_by_both)->active) mpg123_cfg.detect_by = DETECT_BOTH; else mpg123_cfg.detect_by = DETECT_EXTENSION; #ifdef USE_SIMD if (GTK_TOGGLE_BUTTON(auto_select)->active) mpg123_cfg.default_synth = SYNTH_AUTO; else if (GTK_TOGGLE_BUTTON(decoder_fpu)->active) mpg123_cfg.default_synth = SYNTH_FPU; else if (GTK_TOGGLE_BUTTON(decoder_mmx)->active) mpg123_cfg.default_synth = SYNTH_MMX; else mpg123_cfg.default_synth = SYNTH_3DNOW; #endif mpg123_cfg.http_buffer_size = (gint) GTK_ADJUSTMENT(streaming_size_adj)->value; mpg123_cfg.http_prebuffer = (gint) GTK_ADJUSTMENT(streaming_pre_adj)->value; mpg123_cfg.use_proxy = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(streaming_proxy_use)); g_free(mpg123_cfg.proxy_host); mpg123_cfg.proxy_host = g_strdup(gtk_entry_get_text(GTK_ENTRY(streaming_proxy_host_entry))); mpg123_cfg.proxy_port = atoi(gtk_entry_get_text(GTK_ENTRY(streaming_proxy_port_entry))); mpg123_cfg.proxy_use_auth = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(streaming_proxy_auth_use)); if(mpg123_cfg.proxy_user) g_free(mpg123_cfg.proxy_user); mpg123_cfg.proxy_user = NULL; if(strlen(gtk_entry_get_text(GTK_ENTRY(streaming_proxy_auth_user_entry))) > 0) mpg123_cfg.proxy_user = g_strdup(gtk_entry_get_text(GTK_ENTRY(streaming_proxy_auth_user_entry))); if(mpg123_cfg.proxy_pass) g_free(mpg123_cfg.proxy_pass); mpg123_cfg.proxy_pass = NULL; if(strlen(gtk_entry_get_text(GTK_ENTRY(streaming_proxy_auth_pass_entry))) > 0) mpg123_cfg.proxy_pass = g_strdup(gtk_entry_get_text(GTK_ENTRY(streaming_proxy_auth_pass_entry))); mpg123_cfg.save_http_stream = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(streaming_save_use)); if (mpg123_cfg.save_http_path) g_free(mpg123_cfg.save_http_path); mpg123_cfg.save_http_path = g_strdup(gtk_entry_get_text(GTK_ENTRY(streaming_save_entry))); mpg123_cfg.cast_title_streaming = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(streaming_cast_title)); mpg123_cfg.use_udp_channel = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(streaming_udp_title)); mpg123_cfg.title_override = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(title_override)); mpg123_cfg.disable_id3v2 = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(title_id3v2_disable)); g_free(mpg123_cfg.id3_format); mpg123_cfg.id3_format = g_strdup(gtk_entry_get_text(GTK_ENTRY(title_id3_entry))); filename = g_strconcat(g_get_home_dir(), "/.xmms/config", NULL); cfg = xmms_cfg_open_file(filename); if (!cfg) cfg = xmms_cfg_new(); xmms_cfg_write_int(cfg, "MPG123", "resolution", mpg123_cfg.resolution); xmms_cfg_write_int(cfg, "MPG123", "channels", mpg123_cfg.channels); xmms_cfg_write_int(cfg, "MPG123", "downsample", mpg123_cfg.downsample); xmms_cfg_write_int(cfg, "MPG123", "http_buffer_size", mpg123_cfg.http_buffer_size); xmms_cfg_write_int(cfg, "MPG123", "http_prebuffer", mpg123_cfg.http_prebuffer); xmms_cfg_write_boolean(cfg, "MPG123", "use_proxy", mpg123_cfg.use_proxy); xmms_cfg_write_string(cfg, "MPG123", "proxy_host", mpg123_cfg.proxy_host); xmms_cfg_write_int(cfg, "MPG123", "proxy_port", mpg123_cfg.proxy_port); xmms_cfg_write_boolean(cfg, "MPG123", "proxy_use_auth", mpg123_cfg.proxy_use_auth); if(mpg123_cfg.proxy_user) xmms_cfg_write_string(cfg, "MPG123", "proxy_user", mpg123_cfg.proxy_user); else xmms_cfg_remove_key(cfg, "MPG123", "proxy_user"); if(mpg123_cfg.proxy_pass) xmms_cfg_write_string(cfg, "MPG123", "proxy_pass", mpg123_cfg.proxy_pass); else xmms_cfg_remove_key(cfg, "MPG123", "proxy_pass"); xmms_cfg_write_boolean(cfg, "MPG123", "save_http_stream", mpg123_cfg.save_http_stream); xmms_cfg_write_string(cfg, "MPG123", "save_http_path", mpg123_cfg.save_http_path); xmms_cfg_write_boolean(cfg, "MPG123", "cast_title_streaming", mpg123_cfg.cast_title_streaming); xmms_cfg_write_boolean(cfg, "MPG123", "use_udp_channel", mpg123_cfg.use_udp_channel); xmms_cfg_write_boolean(cfg, "MPG123", "title_override", mpg123_cfg.title_override); xmms_cfg_write_boolean(cfg, "MPG123", "disable_id3v2", mpg123_cfg.disable_id3v2); xmms_cfg_write_string(cfg, "MPG123", "id3_format", mpg123_cfg.id3_format); xmms_cfg_write_int(cfg, "MPG123", "detect_by", mpg123_cfg.detect_by); #ifdef USE_SIMD xmms_cfg_write_int(cfg, "MPG123", "default_synth", mpg123_cfg.default_synth); #endif xmms_cfg_write_file(cfg, filename); xmms_cfg_free(cfg); g_free(filename); gtk_widget_destroy(mpg123_configurewin); }
static void create_font_picker (void) { GtkWidget *fontpicker1,*fontpicker2,*fontpicker3; TestGnomeApp *app; GtkWidget *vbox,*vbox1,*vbox2,*vbox3; GtkWidget *hbox1,*hbox3; GtkWidget *frPixmap,*frFontInfo,*frUser; GtkWidget *lbPixmap,*lbFontInfo,*lbUser; GtkWidget *ckUseFont,*spUseFont,*ckShowSize; GtkAdjustment *adj; app = create_newwin(TRUE,"testGNOME","Font Picker"); vbox=gtk_vbox_new(FALSE,5); gtk_container_set_border_width(GTK_CONTAINER(vbox),5); bonobo_window_set_contents(BONOBO_WINDOW(app->app),vbox); /* Pixmap */ frPixmap=gtk_frame_new("Default Pixmap"); gtk_box_pack_start(GTK_BOX(vbox),frPixmap,TRUE,TRUE,0); vbox1=gtk_vbox_new(FALSE,FALSE); gtk_container_add(GTK_CONTAINER(frPixmap),vbox1); /* GnomeFontPicker with pixmap */ fontpicker1 = gnome_font_picker_new(); gtk_container_set_border_width(GTK_CONTAINER(fontpicker1),5); gtk_box_pack_start(GTK_BOX(vbox1),fontpicker1,TRUE,TRUE,0); lbPixmap=gtk_label_new("If you choose a font it will appear here"); gtk_box_pack_start(GTK_BOX(vbox1),lbPixmap,TRUE,TRUE,5); g_signal_connect(fontpicker1,"font_set", G_CALLBACK(cfp_set_font), lbPixmap); /* Font_Info */ frFontInfo=gtk_frame_new("Font Info"); gtk_box_pack_start(GTK_BOX(vbox),frFontInfo,TRUE,TRUE,0); vbox2=gtk_vbox_new(FALSE,FALSE); gtk_container_set_border_width(GTK_CONTAINER(vbox2),5); gtk_container_add(GTK_CONTAINER(frFontInfo),vbox2); fontpicker2 = gnome_font_picker_new(); /* GnomeFontPicker with fontinfo */ hbox1=gtk_hbox_new(FALSE,5); gtk_box_pack_start(GTK_BOX(vbox2),hbox1,FALSE,FALSE,0); ckUseFont=gtk_check_button_new_with_label("Use Font in button with size"); gtk_box_pack_start(GTK_BOX(hbox1),ckUseFont,TRUE,TRUE,0); adj=GTK_ADJUSTMENT(gtk_adjustment_new(14,5,150,1,1,1)); g_signal_connect (adj, "value_changed", G_CALLBACK (cfp_sp_value_changed), fontpicker2); spUseFont=gtk_spin_button_new(adj,1,0); gtk_box_pack_start(GTK_BOX(hbox1),spUseFont,FALSE,FALSE,0); g_object_set_data (G_OBJECT (fontpicker2), "spUseFont", spUseFont); g_signal_connect (ckUseFont, "toggled", G_CALLBACK (cfp_ck_UseFont), fontpicker2); ckShowSize=gtk_check_button_new_with_label("Show font size"); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(ckShowSize),TRUE); gtk_box_pack_start(GTK_BOX(vbox2),ckShowSize,FALSE,FALSE,5); g_signal_connect (ckShowSize, "toggled", G_CALLBACK (cfp_ck_ShowSize), fontpicker2); gnome_font_picker_set_mode(GNOME_FONT_PICKER(fontpicker2),GNOME_FONT_PICKER_MODE_FONT_INFO); gtk_box_pack_start(GTK_BOX(vbox2),fontpicker2,TRUE,TRUE,0); lbFontInfo=gtk_label_new("If you choose a font it will appear here"); gtk_box_pack_start(GTK_BOX(vbox2),lbFontInfo,TRUE,TRUE,5); g_signal_connect(fontpicker2,"font_set", G_CALLBACK(cfp_set_font),lbFontInfo); /* User Widget */ frUser=gtk_frame_new("User Widget"); gtk_box_pack_start(GTK_BOX(vbox),frUser,TRUE,TRUE,0); vbox3=gtk_vbox_new(FALSE,FALSE); gtk_container_add(GTK_CONTAINER(frUser),vbox3); /* GnomeFontPicker with User Widget */ fontpicker3 = gnome_font_picker_new(); gnome_font_picker_set_mode(GNOME_FONT_PICKER(fontpicker3),GNOME_FONT_PICKER_MODE_USER_WIDGET); hbox3=gtk_hbox_new(FALSE,0); gtk_box_pack_start(GTK_BOX(hbox3),gtk_image_new_from_stock (GNOME_STOCK_PIXMAP_SPELLCHECK, GTK_ICON_SIZE_BUTTON), FALSE,FALSE,5); gtk_box_pack_start(GTK_BOX(hbox3),gtk_label_new("This is an hbox with pixmap and text"), FALSE,FALSE,5); gnome_font_picker_uw_set_widget(GNOME_FONT_PICKER(fontpicker3),hbox3); gtk_container_set_border_width(GTK_CONTAINER(fontpicker3),5); gtk_box_pack_start(GTK_BOX(vbox3),fontpicker3,TRUE,TRUE,0); lbUser=gtk_label_new("If you choose a font it will appear here"); gtk_box_pack_start(GTK_BOX(vbox3),lbUser,TRUE,TRUE,5); g_signal_connect(fontpicker3,"font_set", G_CALLBACK(cfp_set_font),lbUser); gtk_widget_show_all(app->app); }
static void create_appearance_section (GtkWidget *appearance_vbox, GUI *appGUI) { GtkWidget *table, *colors_hbox; GtkWidget *checkbutton, *label, *color_button, *font_button; GdkColor color; table = gtk_table_new (4, 4, FALSE); gtk_box_pack_start (GTK_BOX (appearance_vbox), table, FALSE, FALSE, 0); gtk_table_set_col_spacings (GTK_TABLE (table), 4); gtk_table_set_row_spacings (GTK_TABLE (table), 8); colors_hbox = gtk_hbox_new (FALSE, 8); gtk_table_attach (GTK_TABLE (table), colors_hbox, 1, 2, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); color_button = gtk_color_button_new (); if (config.enable_tooltips) gtk_widget_set_tooltip_text (color_button, _("Color of items that are due today")); gdk_color_parse (config.due_today_color, &color); gtk_color_button_set_color (GTK_COLOR_BUTTON (color_button), &color); gtk_box_pack_start (GTK_BOX (colors_hbox), color_button, FALSE, FALSE, 0); g_signal_connect (G_OBJECT (color_button), "color-set", G_CALLBACK (due_today_color_changed_cb), appGUI); appGUI->opt->due_today_color_picker = color_button; color_button = gtk_color_button_new (); g_signal_connect (G_OBJECT (color_button), "color-set", G_CALLBACK (due_7days_color_changed_cb), appGUI); if (config.enable_tooltips) gtk_widget_set_tooltip_text (color_button, _("Color of items that are due in the next 7 days")); gdk_color_parse (config.due_7days_color, &color); gtk_color_button_set_color (GTK_COLOR_BUTTON (color_button), &color); gtk_box_pack_start (GTK_BOX (colors_hbox), color_button, FALSE, FALSE, 0); appGUI->opt->due_7days_color_picker = color_button; color_button = gtk_color_button_new (); if (config.enable_tooltips) gtk_widget_set_tooltip_text (color_button, _("Color of items that are past due")); gdk_color_parse(config.past_due_color, &color); gtk_color_button_set_color (GTK_COLOR_BUTTON (color_button), &color); gtk_box_pack_start (GTK_BOX (colors_hbox), color_button, FALSE, FALSE, 0); g_signal_connect (G_OBJECT (color_button), "color-set", G_CALLBACK (past_due_color_changed_cb), appGUI); appGUI->opt->past_due_color_picker = color_button; appGUI->opt->ti_font_entry = gtk_entry_new (); gtk_entry_set_text (GTK_ENTRY (appGUI->opt->ti_font_entry), config.task_info_font); GTK_WIDGET_UNSET_FLAGS (appGUI->opt->ti_font_entry, GTK_CAN_FOCUS); gtk_table_attach (GTK_TABLE (table), appGUI->opt->ti_font_entry, 1, 2, 1, 2, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); if (config.default_stock_icons) font_button = utl_gui_stock_button (GTK_STOCK_SELECT_FONT, FALSE); else font_button = utl_gui_stock_button (OSMO_STOCK_BUTTON_SELECT_FONT, FALSE); gtk_table_attach (GTK_TABLE (table), font_button, 2, 3, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); g_signal_connect (G_OBJECT (font_button), "clicked", G_CALLBACK (ti_font_select_cb), appGUI); label = utl_gui_create_label ("%s:", _("Task info font")); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); label = utl_gui_create_label ("%s:", _("Colors")); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); checkbutton = gtk_check_button_new_with_mnemonic (_("Show in bold tasks with high priority")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (checkbutton), config.tasks_high_in_bold); gtk_table_attach (GTK_TABLE (table), checkbutton, 0, 3, 3, 4, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); g_signal_connect (G_OBJECT (checkbutton), "toggled", G_CALLBACK (bold_items_cb), appGUI); appGUI->opt->ct_bold_items_checkbutton = checkbutton; }
void create_gtab_conf_window() { if (hime_gtab_conf_window) { gtk_window_present(GTK_WINDOW(hime_gtab_conf_window)); return; } load_setttings(); hime_gtab_conf_window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_position(GTK_WINDOW(hime_gtab_conf_window), GTK_WIN_POS_MOUSE); gtk_window_set_has_resize_grip(GTK_WINDOW(hime_gtab_conf_window), FALSE); g_signal_connect (G_OBJECT (hime_gtab_conf_window), "delete_event", G_CALLBACK (close_gtab_conf_window), NULL); gtk_window_set_title (GTK_WINDOW (hime_gtab_conf_window), _("倉頡/行列/大易設定")); gtk_container_set_border_width (GTK_CONTAINER (hime_gtab_conf_window), 3); GtkWidget *vbox_top = gtk_vbox_new (FALSE, 10); gtk_orientable_set_orientation(GTK_ORIENTABLE(vbox_top), GTK_ORIENTATION_VERTICAL); gtk_container_add (GTK_CONTAINER (hime_gtab_conf_window), vbox_top); GtkWidget *hbox_lr = gtk_hbox_new (FALSE, 10); gtk_box_pack_start (GTK_BOX (vbox_top), hbox_lr, FALSE, FALSE, 0); GtkWidget *frame_gtab_l = gtk_frame_new(_("外觀")); gtk_container_set_border_width (GTK_CONTAINER (frame_gtab_l), 5); gtk_box_pack_start (GTK_BOX (hbox_lr), frame_gtab_l, FALSE, FALSE, 0); GtkWidget *vbox_gtab_l = gtk_vbox_new (FALSE, 0); gtk_orientable_set_orientation(GTK_ORIENTABLE(vbox_gtab_l), GTK_ORIENTATION_VERTICAL); gtk_container_add (GTK_CONTAINER (frame_gtab_l), vbox_gtab_l); gtk_container_set_border_width (GTK_CONTAINER (vbox_gtab_l), 10); GtkWidget *frame_gtab_r = gtk_frame_new(_("行為")); gtk_container_set_border_width (GTK_CONTAINER (frame_gtab_r), 5); gtk_box_pack_start (GTK_BOX (hbox_lr), frame_gtab_r, FALSE, FALSE, 0); GtkWidget *vbox_gtab_r = gtk_vbox_new (FALSE, 0); gtk_orientable_set_orientation(GTK_ORIENTABLE(vbox_gtab_r), GTK_ORIENTATION_VERTICAL); gtk_container_add (GTK_CONTAINER (frame_gtab_r), vbox_gtab_r); gtk_container_set_border_width (GTK_CONTAINER (vbox_gtab_r), 10); #define SPC 1 GtkWidget *hbox_gtab_pre_select = gtk_hbox_new (FALSE, SPC); gtk_box_pack_start (GTK_BOX (vbox_gtab_l), hbox_gtab_pre_select, FALSE, FALSE, 0); opt_gtab_pre_select = gtk_label_new (_("預覽/預選 字")); gtk_box_pack_start (GTK_BOX (hbox_gtab_pre_select),opt_gtab_pre_select, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (hbox_gtab_pre_select), create_auto_select_by_phrase_opts(&opt_gtab_pre_select, gtab_pre_select), FALSE, FALSE, 0); GtkWidget *hbox_gtab_disp_partial_match = gtk_hbox_new (FALSE, SPC); gtk_box_pack_start (GTK_BOX (vbox_gtab_l), hbox_gtab_disp_partial_match, FALSE, FALSE, 0); opt_gtab_disp_partial_match = gtk_label_new (_("預選列中顯示部份符合的字")); gtk_box_pack_start (GTK_BOX (hbox_gtab_disp_partial_match), opt_gtab_disp_partial_match, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (hbox_gtab_disp_partial_match), create_auto_select_by_phrase_opts(&opt_gtab_disp_partial_match, gtab_disp_partial_match), FALSE, FALSE, 0); GtkWidget *hbox_gtab_disp_key_codes = gtk_hbox_new (FALSE, SPC); gtk_box_pack_start (GTK_BOX (vbox_gtab_l), hbox_gtab_disp_key_codes, FALSE, FALSE, 0); check_button_gtab_disp_key_codes = gtk_check_button_new_with_label (_("顯示字根")); gtk_box_pack_start (GTK_BOX (hbox_gtab_disp_key_codes), check_button_gtab_disp_key_codes, FALSE, FALSE, 0); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_button_gtab_disp_key_codes), gtab_disp_key_codes); GtkWidget *hbox_gtab_disp_im_name = gtk_hbox_new (FALSE, SPC); gtk_box_pack_start (GTK_BOX (vbox_gtab_l), hbox_gtab_disp_im_name, FALSE, FALSE, 0); check_button_gtab_disp_im_name = gtk_check_button_new_with_label (_("顯示輸入法名稱")); gtk_box_pack_start (GTK_BOX (hbox_gtab_disp_im_name), check_button_gtab_disp_im_name, FALSE, FALSE, 0); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_button_gtab_disp_im_name), gtab_disp_im_name); GtkWidget *hbox_gtab_hide_row2 = gtk_hbox_new (FALSE, SPC); gtk_box_pack_start (GTK_BOX (vbox_gtab_l), hbox_gtab_hide_row2, FALSE, FALSE, 0); check_button_gtab_hide_row2 = gtk_check_button_new_with_label (_("隱藏第二列 (輸入鍵…)")); gtk_box_pack_start (GTK_BOX (hbox_gtab_hide_row2), check_button_gtab_hide_row2, FALSE, FALSE, 0); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_button_gtab_hide_row2), gtab_hide_row2); GtkWidget *hbox_gtab_in_row1 = gtk_hbox_new (FALSE, SPC); gtk_box_pack_start (GTK_BOX (vbox_gtab_l), hbox_gtab_in_row1, FALSE, FALSE, 0); check_button_gtab_in_row1 = gtk_check_button_new_with_label (_("將字根移至第一列")); gtk_box_pack_start (GTK_BOX (hbox_gtab_in_row1), check_button_gtab_in_row1, FALSE, FALSE, 0); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_button_gtab_in_row1), gtab_in_row1); GtkWidget *hbox_gtab_vertical_select = gtk_hbox_new (FALSE, SPC); gtk_box_pack_start (GTK_BOX (vbox_gtab_l), hbox_gtab_vertical_select, FALSE, FALSE, 0); GtkWidget *label_gtab_vertical_select = gtk_label_new (_("垂直選擇")); gtk_box_pack_start (GTK_BOX (hbox_gtab_vertical_select), label_gtab_vertical_select, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (hbox_gtab_vertical_select), create_auto_select_by_phrase_opts(&opt_gtab_vertical_select, gtab_vertical_select), FALSE, FALSE, 0); GtkWidget *hbox_gtab_press_full_auto_send = gtk_hbox_new (FALSE, SPC); gtk_box_pack_start (GTK_BOX (vbox_gtab_r), hbox_gtab_press_full_auto_send, FALSE, FALSE, 0); GtkWidget *label_gtab_gtab_press_full_auto_send = gtk_label_new(_("按滿字根自動送字")); gtk_box_pack_start (GTK_BOX (hbox_gtab_press_full_auto_send), label_gtab_gtab_press_full_auto_send, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (hbox_gtab_press_full_auto_send), create_auto_select_by_phrase_opts(&opt_gtab_press_full_auto_send, gtab_press_full_auto_send), FALSE, FALSE, 0); GtkWidget *hbox_gtab_auto_select_by_phrase = gtk_hbox_new (FALSE, SPC); gtk_box_pack_start (GTK_BOX (vbox_gtab_r), hbox_gtab_auto_select_by_phrase, FALSE, FALSE, 0); GtkWidget *label_gtab_auto_select = gtk_label_new(_("由詞庫自動選字")); gtk_box_pack_start (GTK_BOX (hbox_gtab_auto_select_by_phrase), label_gtab_auto_select, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (hbox_gtab_auto_select_by_phrase), create_auto_select_by_phrase_opts(&opt_auto_select_by_phrase, gtab_auto_select_by_phrase), FALSE, FALSE, 0); check_button_gtab_phrase_pre_select = gtk_check_button_new_with_label (_("使用預選詞")); gtk_box_pack_start (GTK_BOX (hbox_gtab_auto_select_by_phrase), check_button_gtab_phrase_pre_select, FALSE, FALSE, 0); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_button_gtab_phrase_pre_select), gtab_phrase_pre_select); GtkWidget *hbox_gtab_dup_select_bell = gtk_hbox_new (FALSE, SPC); gtk_box_pack_start (GTK_BOX (vbox_gtab_r), hbox_gtab_dup_select_bell, FALSE, FALSE, 0); check_button_gtab_dup_select_bell = gtk_check_button_new_with_label (_("有重複字時,發出嗶聲")); gtk_box_pack_start (GTK_BOX (hbox_gtab_dup_select_bell),check_button_gtab_dup_select_bell, FALSE, FALSE, 0); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_button_gtab_dup_select_bell), gtab_dup_select_bell); gtk_box_pack_start (GTK_BOX (vbox_gtab_r), create_spc_opts(), FALSE, FALSE, 0); GtkWidget *hbox_gtab_invalid_key_in = gtk_hbox_new (FALSE, SPC); gtk_box_pack_start (GTK_BOX (vbox_gtab_r), hbox_gtab_invalid_key_in, FALSE, FALSE, 0); check_button_gtab_invalid_key_in = gtk_check_button_new_with_label (_("可鍵入錯誤字根 (傳統)")); gtk_box_pack_start (GTK_BOX (hbox_gtab_invalid_key_in), check_button_gtab_invalid_key_in, FALSE, FALSE, 0); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_button_gtab_invalid_key_in), gtab_invalid_key_in); GtkWidget *hbox_gtab_shift_phrase_key = gtk_hbox_new (FALSE, SPC); gtk_box_pack_start (GTK_BOX (vbox_gtab_r), hbox_gtab_shift_phrase_key, FALSE, FALSE, 0); check_button_gtab_shift_phrase_key = gtk_check_button_new_with_label (_("可用 Shift 輸入片語 (預設為 Alt-Shift)")); gtk_box_pack_start (GTK_BOX (hbox_gtab_shift_phrase_key), check_button_gtab_shift_phrase_key, FALSE, FALSE, 0); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_button_gtab_shift_phrase_key), gtab_shift_phrase_key); gtk_box_pack_start (GTK_BOX (vbox_gtab_r), create_en_pho_key_sel(_("切換[中/英]輸入")), FALSE, FALSE, 0); #if 0 GtkWidget *hbox_hime_capslock_lower = gtk_hbox_new (FALSE, SPC); gtk_box_pack_start (GTK_BOX (vbox_gtab_r), hbox_hime_capslock_lower, FALSE, FALSE, 0); check_button_hime_capslock_lower = gtk_check_button_new_with_label (_("\t用小寫字母")); gtk_box_pack_start (GTK_BOX (hbox_hime_capslock_lower), check_button_hime_capslock_lower, FALSE, FALSE, 0); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_button_hime_capslock_lower), hime_capslock_lower); #endif GtkWidget *hbox_gtab_unique_auto_send = gtk_hbox_new (FALSE, SPC); gtk_box_pack_start (GTK_BOX (vbox_gtab_r), hbox_gtab_unique_auto_send, FALSE, FALSE, 0); GtkWidget *label_gtab_unique_auto_send = gtk_label_new (_("唯一選擇時自動送出")); gtk_box_pack_start (GTK_BOX (hbox_gtab_unique_auto_send), label_gtab_unique_auto_send, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (hbox_gtab_unique_auto_send), create_auto_select_by_phrase_opts(&opt_gtab_unique_auto_send, gtab_unique_auto_send), FALSE, FALSE, 0); GtkWidget *hbox_gtab_que_wild_card = gtk_hbox_new (FALSE, SPC); gtk_box_pack_start (GTK_BOX (vbox_gtab_r), hbox_gtab_que_wild_card, FALSE, FALSE, 0); check_button_gtab_que_wild_card = gtk_check_button_new_with_label (_("使用?萬用字元")); gtk_box_pack_start (GTK_BOX (hbox_gtab_que_wild_card), check_button_gtab_que_wild_card, FALSE, FALSE, 0); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_button_gtab_que_wild_card), gtab_que_wild_card); GtkWidget *button_edit_append = gtk_button_new_with_label(_("編輯預設輸入法的使用者外加字詞")); gtk_box_pack_start (GTK_BOX (vbox_gtab_r), button_edit_append, FALSE, FALSE, 0); g_signal_connect_swapped (G_OBJECT (button_edit_append), "clicked", G_CALLBACK (cb_gtab_edit_append), NULL); GtkWidget *hbox_cancel_ok = gtk_hbox_new (FALSE, 10); gtk_grid_set_column_homogeneous(GTK_GRID(hbox_cancel_ok), TRUE); gtk_box_pack_start (GTK_BOX (vbox_top), hbox_cancel_ok, FALSE, FALSE, 0); GtkWidget *button_cancel = gtk_button_new_from_stock (GTK_STOCK_CANCEL); if (button_order) gtk_box_pack_end (GTK_BOX (hbox_cancel_ok), button_cancel, TRUE, TRUE, 0); else gtk_box_pack_start (GTK_BOX (hbox_cancel_ok), button_cancel, TRUE, TRUE, 0); g_signal_connect (G_OBJECT (button_cancel), "clicked", G_CALLBACK (close_gtab_conf_window), G_OBJECT (hime_gtab_conf_window)); GtkWidget *button_ok = gtk_button_new_from_stock (GTK_STOCK_OK); #if !GTK_CHECK_VERSION(2,91,2) if (button_order) gtk_box_pack_end (GTK_BOX (hbox_cancel_ok), button_ok, TRUE, TRUE, 0); else gtk_box_pack_start (GTK_BOX (hbox_cancel_ok), button_ok, TRUE, TRUE, 0); #else if (button_order) gtk_grid_attach_next_to (GTK_BOX (hbox_cancel_ok), button_ok, button_cancel, GTK_POS_LEFT, 1, 1); else gtk_grid_attach_next_to (GTK_BOX (hbox_cancel_ok), button_ok, button_cancel, GTK_POS_RIGHT, 1, 1); #endif g_signal_connect_swapped (G_OBJECT (button_ok), "clicked", G_CALLBACK (cb_gtab_conf_ok), G_OBJECT (hime_gtab_conf_window)); GTK_WIDGET_SET_FLAGS (button_ok, GTK_CAN_DEFAULT); gtk_widget_grab_default (button_ok); gtk_widget_show_all (hime_gtab_conf_window); return; }
static void show_auth_dialog(WebKitAuthData* authData, const char* login, const char* password) { GtkWidget* toplevel; GtkWidget* widget; GtkDialog* dialog; GtkWindow* window; GtkWidget* entryContainer; GtkWidget* hbox; GtkWidget* mainVBox; GtkWidget* vbox; GtkWidget* icon; GtkWidget* table; GtkWidget* messageLabel; char* message; SoupURI* uri; GtkWidget* rememberBox; GtkWidget* checkButton; /* From GTK+ gtkmountoperation.c, modified and simplified. LGPL 2 license */ widget = gtk_dialog_new(); window = GTK_WINDOW(widget); dialog = GTK_DIALOG(widget); gtk_dialog_add_buttons(dialog, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); /* Set the dialog up with HIG properties */ gtk_dialog_set_has_separator(dialog, FALSE); gtk_container_set_border_width(GTK_CONTAINER(dialog), 5); gtk_box_set_spacing(GTK_BOX(dialog->vbox), 2); /* 2 * 5 + 2 = 12 */ gtk_container_set_border_width(GTK_CONTAINER(dialog->action_area), 5); gtk_box_set_spacing(GTK_BOX(dialog->action_area), 6); gtk_window_set_resizable(window, FALSE); gtk_window_set_title(window, ""); gtk_window_set_icon_name(window, GTK_STOCK_DIALOG_AUTHENTICATION); gtk_dialog_set_default_response(dialog, GTK_RESPONSE_OK); /* Get the current toplevel */ g_signal_emit(authData->manager, signals[CURRENT_TOPLEVEL], 0, authData->msg, &toplevel); if (toplevel) gtk_window_set_transient_for(window, GTK_WINDOW(toplevel)); /* Build contents */ hbox = gtk_hbox_new(FALSE, 12); gtk_container_set_border_width(GTK_CONTAINER(hbox), 5); gtk_box_pack_start(GTK_BOX(dialog->vbox), hbox, TRUE, TRUE, 0); icon = gtk_image_new_from_stock(GTK_STOCK_DIALOG_AUTHENTICATION, GTK_ICON_SIZE_DIALOG); gtk_misc_set_alignment(GTK_MISC(icon), 0.5, 0.0); gtk_box_pack_start(GTK_BOX(hbox), icon, FALSE, FALSE, 0); mainVBox = gtk_vbox_new(FALSE, 18); gtk_box_pack_start(GTK_BOX(hbox), mainVBox, TRUE, TRUE, 0); uri = soup_message_get_uri(authData->msg); message = g_strdup_printf(_("A username and password are being requested by the site %s"), uri->host); messageLabel = gtk_label_new(message); g_free(message); gtk_misc_set_alignment(GTK_MISC(messageLabel), 0.0, 0.5); gtk_label_set_line_wrap(GTK_LABEL(messageLabel), TRUE); gtk_box_pack_start(GTK_BOX(mainVBox), GTK_WIDGET(messageLabel), FALSE, FALSE, 0); vbox = gtk_vbox_new(FALSE, 6); gtk_box_pack_start(GTK_BOX(mainVBox), vbox, FALSE, FALSE, 0); /* The table that holds the entries */ entryContainer = gtk_alignment_new(0.0, 0.0, 1.0, 1.0); gtk_alignment_set_padding(GTK_ALIGNMENT(entryContainer), 0, 0, 0, 0); gtk_box_pack_start(GTK_BOX(vbox), entryContainer, FALSE, FALSE, 0); table = gtk_table_new(2, 2, FALSE); gtk_table_set_col_spacings(GTK_TABLE(table), 12); gtk_table_set_row_spacings(GTK_TABLE(table), 6); gtk_container_add(GTK_CONTAINER(entryContainer), table); authData->loginEntry = table_add_entry(table, 0, _("Username:"******"Password:"******"_Remember password")); if (login && password) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkButton), TRUE); gtk_label_set_line_wrap(GTK_LABEL(gtk_bin_get_child(GTK_BIN(checkButton))), TRUE); gtk_box_pack_start(GTK_BOX(rememberBox), checkButton, FALSE, FALSE, 0); authData->checkButton = checkButton; } g_signal_connect(dialog, "response", G_CALLBACK(response_callback), authData); gtk_widget_show_all(widget); }
static gboolean _togglebutton_draw(GtkWidget *widget, cairo_t *cr) { g_return_val_if_fail(widget != NULL, FALSE); g_return_val_if_fail(DTGTK_IS_TOGGLEBUTTON(widget), FALSE); GtkDarktableToggleButton *button = DTGTK_TOGGLEBUTTON(widget); GtkStateFlags state = gtk_widget_get_state_flags(widget); GdkRGBA bg_color, fg_color; GtkStyleContext *context = gtk_widget_get_style_context(widget); if(button->icon_flags & CPF_CUSTOM_BG) bg_color = button->bg; else { GdkRGBA *bc; gtk_style_context_get(context, state, "background-color", &bc, NULL); bg_color = *bc; gdk_rgba_free(bc); } if(button->icon_flags & CPF_CUSTOM_FG) fg_color = button->fg; else gtk_style_context_get_color(context, state, &fg_color); /* fetch flags */ int flags = DTGTK_TOGGLEBUTTON(widget)->icon_flags; /* set inner border */ int border = DT_PIXEL_APPLY_DPI((flags & CPF_DO_NOT_USE_BORDER) ? 2 : 6); /* update active state paint flag */ gboolean active = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)); if(active) flags |= CPF_ACTIVE; else flags &= ~(CPF_ACTIVE); /* prelight */ if(state & GTK_STATE_FLAG_PRELIGHT) flags |= CPF_PRELIGHT; else flags &= ~CPF_PRELIGHT; /* begin cairo drawing */ GtkAllocation allocation; gtk_widget_get_allocation(widget, &allocation); int width = allocation.width; int height = allocation.height; /* draw standard button background if not transparent nor flat styled */ if((flags & CPF_STYLE_FLAT)) { if(flags & CPF_PRELIGHT || flags & CPF_ACTIVE) { cairo_rectangle(cr, 0, 0, width, height); gdk_cairo_set_source_rgba(cr, &bg_color); cairo_fill(cr); } } else if(!(flags & CPF_BG_TRANSPARENT)) { /* draw default boxed button */ gtk_render_background(context, cr, 0, 0, width, height); if(!(flags & CPF_DO_NOT_USE_BORDER)) gtk_render_frame(context, cr, 0, 0, width, height); } /* create pango text settings if label exists */ PangoLayout *layout = NULL; int pw = 0, ph = 0; const gchar *text = gtk_button_get_label(GTK_BUTTON(widget)); if(text) { layout = pango_cairo_create_layout(cr); pango_layout_set_font_description(layout, darktable.bauhaus->pango_font_desc); pango_cairo_context_set_resolution(pango_layout_get_context(layout), darktable.gui->dpi); pango_layout_set_text(layout, text, -1); pango_layout_get_pixel_size(layout, &pw, &ph); } gdk_cairo_set_source_rgba(cr, &fg_color); /* draw icon */ if(DTGTK_TOGGLEBUTTON(widget)->icon) { // if (flags & CPF_IGNORE_FG_STATE) // state = GTK_STATE_NORMAL; int icon_width = text ? height - (border * 2) : width - (border * 2); int icon_height = height - (border * 2); if(icon_width > 0 && icon_height > 0) { if(text) DTGTK_TOGGLEBUTTON(widget) ->icon(cr, border, border, height - (border * 2), height - (border * 2), flags); else DTGTK_TOGGLEBUTTON(widget) ->icon(cr, border, border, width - (border * 2), height - (border * 2), flags); } } /* draw label */ if(text) { int lx = DT_PIXEL_APPLY_DPI(2), ly = ((height / 2.0) - (ph / 2.0)); // if (DTGTK_TOGGLEBUTTON (widget)->icon) lx += width; // GdkRectangle t={x,y,x+width,y+height}; // gtk_paint_layout(style,gtk_widget_get_window(widget), // state,TRUE,&t,widget,"togglebutton",lx,ly,layout); cairo_translate(cr, lx, ly); pango_cairo_show_layout(cr, layout); g_object_unref(layout); } return FALSE; }
void prefsbox_open (void) { GtkWidget *notebook; GtkWidget *grid; GtkWidget *controls_list; GtkWidget *label; GtkCellRenderer *renderer; GtkListStore *model; GtkTreeIter iter; gint i; if (prefsbox != NULL) { gtk_window_present (GTK_WINDOW (prefsbox)); return; } prefsbox = gtk_dialog_new_with_buttons (_("Four-in-a-Row Preferences"), GTK_WINDOW (app), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_CLOSE, GTK_RESPONSE_ACCEPT, NULL); gtk_container_set_border_width (GTK_CONTAINER (prefsbox), 5); gtk_box_set_spacing (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (prefsbox))), 2); g_signal_connect (G_OBJECT (prefsbox), "destroy", G_CALLBACK (gtk_widget_destroyed), &prefsbox); notebook = gtk_notebook_new (); gtk_container_set_border_width (GTK_CONTAINER (notebook), 5); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (prefsbox))), notebook, TRUE, TRUE, 0); /* game tab */ grid = gtk_grid_new (); gtk_grid_set_row_spacing (GTK_GRID (grid), 6); gtk_grid_set_column_spacing (GTK_GRID (grid), 12); gtk_container_set_border_width (GTK_CONTAINER (grid), 12); label = gtk_label_new (_("Game")); gtk_notebook_append_page (GTK_NOTEBOOK (notebook), grid, label); label = gtk_label_new (_("Player One:")); gtk_widget_set_hexpand (label, TRUE); gtk_grid_attach (GTK_GRID (grid), label, 0, 0, 1, 1); combobox1 = gtk_combo_box_new (); renderer = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox1), renderer, TRUE); gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (combobox1), renderer, "text", 0); model = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_INT); gtk_combo_box_set_model (GTK_COMBO_BOX (combobox1), GTK_TREE_MODEL (model)); gtk_list_store_append (model, &iter); gtk_list_store_set (model, &iter, 0, _("Human"), 1, LEVEL_HUMAN, -1); if (p.level[PLAYER1] == LEVEL_HUMAN) gtk_combo_box_set_active_iter (GTK_COMBO_BOX (combobox1), &iter); gtk_list_store_append (model, &iter); gtk_list_store_set (model, &iter, 0, _("Level one"), 1, LEVEL_WEAK, -1); if (p.level[PLAYER1] == LEVEL_WEAK) gtk_combo_box_set_active_iter (GTK_COMBO_BOX (combobox1), &iter); gtk_list_store_append (model, &iter); gtk_list_store_set (model, &iter, 0, _("Level two"), 1, LEVEL_MEDIUM, -1); if (p.level[PLAYER1] == LEVEL_MEDIUM) gtk_combo_box_set_active_iter (GTK_COMBO_BOX (combobox1), &iter); gtk_list_store_append (model, &iter); gtk_list_store_set (model, &iter, 0, _("Level three"), 1, LEVEL_STRONG, -1); if (p.level[PLAYER1] == LEVEL_STRONG) gtk_combo_box_set_active_iter (GTK_COMBO_BOX (combobox1), &iter); g_signal_connect (combobox1, "changed", G_CALLBACK (on_select_player1), NULL); gtk_grid_attach (GTK_GRID (grid), combobox1, 1, 0, 1, 1); label = gtk_label_new (_("Player Two:")); gtk_grid_attach (GTK_GRID (grid), label, 0, 1, 1, 1); combobox2 = gtk_combo_box_new (); renderer = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox2), renderer, TRUE); gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (combobox2), renderer, "text", 0); model = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_INT); gtk_combo_box_set_model (GTK_COMBO_BOX (combobox2), GTK_TREE_MODEL (model)); gtk_list_store_append (model, &iter); gtk_list_store_set (model, &iter, 0, _("Human"), 1, LEVEL_HUMAN, -1); if (p.level[PLAYER2] == LEVEL_HUMAN) gtk_combo_box_set_active_iter (GTK_COMBO_BOX (combobox2), &iter); gtk_list_store_append (model, &iter); gtk_list_store_set (model, &iter, 0, _("Level one"), 1, LEVEL_WEAK, -1); if (p.level[PLAYER2] == LEVEL_WEAK) gtk_combo_box_set_active_iter (GTK_COMBO_BOX (combobox2), &iter); gtk_list_store_append (model, &iter); gtk_list_store_set (model, &iter, 0, _("Level two"), 1, LEVEL_MEDIUM, -1); if (p.level[PLAYER2] == LEVEL_MEDIUM) gtk_combo_box_set_active_iter (GTK_COMBO_BOX (combobox2), &iter); gtk_list_store_append (model, &iter); gtk_list_store_set (model, &iter, 0, _("Level three"), 1, LEVEL_STRONG, -1); if (p.level[PLAYER2] == LEVEL_STRONG) gtk_combo_box_set_active_iter (GTK_COMBO_BOX (combobox2), &iter); g_signal_connect (combobox2, "changed", G_CALLBACK (on_select_player2), NULL); gtk_grid_attach (GTK_GRID (grid), combobox2, 1, 1, 1, 1); label = gtk_label_new_with_mnemonic (_("_Theme:")); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_grid_attach (GTK_GRID (grid), label, 0, 2, 1, 1); combobox_theme = gtk_combo_box_text_new (); for (i = 0; i < n_themes; i++) { gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combobox_theme), _(theme_get_title (i))); } gtk_label_set_mnemonic_widget (GTK_LABEL (label), combobox_theme); gtk_grid_attach (GTK_GRID (grid), combobox_theme, 1, 2, 1, 1); checkbutton_animate = gtk_check_button_new_with_mnemonic (_("Enable _animation")); gtk_grid_attach (GTK_GRID (grid), checkbutton_animate, 0, 3, 2, 1); checkbutton_sound = gtk_check_button_new_with_mnemonic (_("E_nable sounds")); gtk_grid_attach (GTK_GRID (grid), checkbutton_sound, 0, 4, 2, 1); /* keyboard tab */ label = gtk_label_new_with_mnemonic (_("Keyboard Controls")); controls_list = games_controls_list_new (settings); games_controls_list_add_controls (GAMES_CONTROLS_LIST (controls_list), "key-left", _("Move left"), DEFAULT_KEY_LEFT, "key-right", _("Move right"), DEFAULT_KEY_RIGHT, "key-drop", _("Drop marble"), DEFAULT_KEY_DROP, NULL); gtk_container_set_border_width (GTK_CONTAINER (controls_list), 12); gtk_notebook_append_page (GTK_NOTEBOOK (notebook), controls_list, label); /* fill in initial values */ gtk_combo_box_set_active (GTK_COMBO_BOX (combobox_theme), p.theme_id); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (checkbutton_animate), p.do_animate); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (checkbutton_sound), p.do_sound); /* connect signals */ g_signal_connect (prefsbox, "response", G_CALLBACK (on_dialog_close), &prefsbox); g_signal_connect (G_OBJECT (combobox_theme), "changed", G_CALLBACK (on_select_theme), NULL); g_signal_connect (G_OBJECT (checkbutton_animate), "toggled", G_CALLBACK (on_toggle_animate), NULL); g_signal_connect (G_OBJECT (checkbutton_sound), "toggled", G_CALLBACK (on_toggle_sound), NULL); gtk_widget_show_all (prefsbox); }
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // Calibrator::calibrate // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ void Calibrator::calibrate(void) { // Bring globals into scope extern GladeXML *gui; // Locals unsigned int seq_index, count; char label_text[50]; bool skip, started, paused; Sequence *seq; GtkWidget *label, *notify, *window, *progress_bar; vector< vector<float> > temp; Template sequence_template(NUMBER_OF_CHANNELS,sequences->length()); gdk_threads_enter(); // Get GDK lock progress_bar = glade_xml_get_widget(gui, "cal_progress_bar"); window = glade_xml_get_widget(gui, "cal_progress"); label = glade_xml_get_widget(gui, "cal_label"); notify = glade_xml_get_widget(gui, "cal_notify"); username = (const char*)gtk_entry_get_text(GTK_ENTRY(glade_xml_get_widget(gui, "user_field"))); gdk_threads_leave(); // Release GDK lock for(seq_index = 0; seq_index < sequences->number(); ++seq_index) // calibrate for each sequence { // Reset calibration progress window sprintf(label_text, "Calibrate Sequence %d", seq_index+1); gdk_threads_enter(); // Get GDK lock gtk_widget_set_sensitive(glade_xml_get_widget(gui, "cal_skip"),TRUE); gtk_widget_set_sensitive(glade_xml_get_widget(gui, "cal_pause"),FALSE); gtk_label_set_text(GTK_LABEL(label),label_text); gdk_threads_leave(); // Release GDK lock update_cal_progress_window(-1); // wait for user to click start button do { gdk_threads_enter(); // Get GDK lock skip = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(glade_xml_get_widget(gui, "cal_skip"))); gdk_threads_leave(); // Release GDK lock if(skip) { gdk_threads_enter(); // Get GDK lock gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(glade_xml_get_widget(gui, "cal_skip")),FALSE); gdk_threads_leave(); ++seq_index; break; // return to beginning } gdk_threads_enter(); // Get GDK lock started = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(glade_xml_get_widget(gui, "cal_start"))); gdk_threads_leave(); // Release GDK lock }while(!started); if (seq_index < sequences->number()) { gdk_threads_enter(); // Get GDK lock gtk_widget_set_sensitive(glade_xml_get_widget(gui, "cal_start"), FALSE); gtk_widget_set_sensitive(glade_xml_get_widget(gui, "cal_skip"),FALSE); gtk_widget_set_sensitive(glade_xml_get_widget(gui, "cal_pause"),TRUE); gdk_threads_leave(); // Release GDK lock // Reset the template sequence_template.reset(); // average PERIODS_TO_AVERAGE periods of EEG signal for(count = 0; count < PERIODS_TO_AVERAGE; ++count) { // Check pause button do { gdk_threads_enter(); paused = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(glade_xml_get_widget(gui, "cal_pause"))); gdk_threads_leave(); for(unsigned i = 0; i < 10000; ++i); } while (paused); // Wait in loop temp = get_one_period(); if (!is_corrupt(temp) ) { sequence_template.add_data(temp); update_cal_progress_window(count); } else{ --count; } } sequence_template.generate_template(); seq = sequences->at(seq_index); seq->set_template(sequence_template); // Write cal file write_calibration_file(seq_index+1, sequence_template.get_template()); } // Reset toggle button gdk_threads_enter(); // Get GDK lock gtk_widget_set_sensitive(glade_xml_get_widget(gui, "cal_start"), TRUE); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(glade_xml_get_widget(gui, "cal_start")),FALSE); gdk_threads_leave(); // Release GDK lock } xval("xval.txt"); // Hide widget gdk_threads_enter(); // Get GDK lock gtk_widget_hide(window); gdk_threads_leave(); // Release GDK lock }
gint display_scroptions_dbox() { GladeXML *xml; GtkWidget *dbox; GtkWidget *data; gint result; xml = glade_xml_new (tilp_paths_build_glade("scroptions-2.glade"), "scroptions_dbox", PACKAGE); if (!xml) g_error(_("%s: GUI loading failed!\n"), __FILE__); glade_xml_signal_autoconnect(xml); dbox = glade_xml_get_widget(xml, "scroptions_dbox"); gtk_dialog_set_alternative_button_order(GTK_DIALOG(dbox), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL,-1); memcpy(&tmp_options, &options2, sizeof(ScrOptions)); tmp_options.file = g_strdup(options2.file); tmp_options.folder = g_strdup(options2.folder); frame = glade_xml_get_widget(xml, "frame5"); gtk_widget_set_sensitive(frame, tmp_options.size == IMG_LCD); switch (tmp_options.format) { case IMG_JPG: data = glade_xml_get_widget(xml, "radiobutton30"); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(data), TRUE); break; case IMG_PNG: data = glade_xml_get_widget(xml, "radiobutton31"); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(data), TRUE); break; case IMG_ICO: data = glade_xml_get_widget(xml, "radiobutton32"); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(data), TRUE); break; case IMG_EPS: data = glade_xml_get_widget(xml, "radiobutton33"); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(data), TRUE); break; case IMG_PDF: data = glade_xml_get_widget(xml, "radiobutton34"); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(data), TRUE); break; case IMG_BMP: data = glade_xml_get_widget(xml, "radiobutton35"); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(data), TRUE); break; } switch (tmp_options.type) { case IMG_BW: data = glade_xml_get_widget(xml, "radiobutton10"); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(data), TRUE); break; case IMG_COL: data = glade_xml_get_widget(xml, "radiobutton11"); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(data), TRUE); break; } switch (tmp_options.size) { case IMG_LCD: data = glade_xml_get_widget(xml, "radiobutton20"); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(data), TRUE); break; case IMG_SKIN: data = glade_xml_get_widget(xml, "radiobutton21"); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(data), TRUE); break; } data = glade_xml_get_widget(xml, "spinbutton1"); gtk_spin_button_set_value(GTK_SPIN_BUTTON(data), tmp_options.shots); data = glade_xml_get_widget(xml, "spinbutton2"); gtk_spin_button_set_value(GTK_SPIN_BUTTON(data), tmp_options.skips); label = glade_xml_get_widget(xml, "label10"); refresh_label(); data = glade_xml_get_widget(xml, "entry10"); gtk_entry_set_text(GTK_ENTRY(data), tmp_options.file); data = glade_xml_get_widget(xml, "filechooserbutton1"); gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (data), tmp_options.folder); result = gtk_dialog_run(GTK_DIALOG(dbox)); switch (result) { case GTK_RESPONSE_OK: g_free(options2.file); g_free(options2.folder); memcpy(&options2, &tmp_options, sizeof(ScrOptions)); options2.file = g_strdup(tmp_options.file); g_free(tmp_options.file); options2.folder = g_strdup(tmp_options.folder); g_free(tmp_options.folder); break; default: break; } frame = label = NULL; gtk_widget_destroy(dbox); return 0; }
void perform_uninstall_slot(GtkWidget* w, gpointer data) { GtkWidget *notebook; GtkWidget *progress; GtkWidget *widget; GList *list, *poopy, *clist; GtkWidget *button; component_list *component; size_t size, total; char text[1024]; const char *message; /* Set through environment to hide questions, and assume Yes */ int show_messages; const char *env; show_messages = 1; env = getenv("SETUP_NO_PROMPT"); if ( env && atoi(env) ) show_messages = 0; /* First switch to the next notebook page */ notebook = glade_xml_get_widget(uninstall_glade, "uninstall_notebook"); gtk_notebook_set_page(GTK_NOTEBOOK(notebook), 1); widget = glade_xml_get_widget(uninstall_glade, "finished_button"); if ( widget ) { gtk_button_set_sensitive(widget, FALSE); } /* Now uninstall all the selected components */ progress = glade_xml_get_widget(uninstall_glade, "uninstall_progress"); size = 0; total = calculate_recovered_space(); widget = glade_xml_get_widget(uninstall_glade, "uninstall_vbox"); list = gtk_container_children(GTK_CONTAINER(widget)); while ( list && ! uninstall_cancelled ) { widget = GTK_WIDGET(list->data); poopy = gtk_container_children(GTK_CONTAINER(widget)); widget = GTK_WIDGET(poopy->data); /* First do the addon components */ clist = gtk_container_children(GTK_CONTAINER(widget)); while ( clist && ! uninstall_cancelled ) { button = GTK_WIDGET(clist->data); if ( gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button)) ) { component = gtk_object_get_data(GTK_OBJECT(button), "data"); if ( loki_isdefault_component(component->component) ) { clist = clist->next; continue; } /* Put up the status */ snprintf(text, sizeof(text), "%s: %s", component->info->description, loki_getname_component(component->component)); set_status_text(text); /* See if the user wants to cancel the uninstall */ while( gtk_events_pending() ) { gtk_main_iteration(); } /* Display an optional message to the user */ message = loki_getmessage_component(component->component); if (show_messages && message && !display_message(message, BUTTON_OK|BUTTON_ABORT) ) { clist = clist->next; uninstall_cancelled = 1; break; } /* Remove the component */ if ( ! uninstall_component(component->component, component->info) ) { uninstall_cancelled = 2; snprintf(text, sizeof(text), _("Uninstallation of component %s has failed!\n" "The whole uninstallation may be incomplete.\n"), loki_getname_component(component->component)); display_message(text, BUTTON_ABORT); break; } /* Update the progress bar */ if ( total && progress ) { size += component->size/1024; gtk_progress_set_percentage(GTK_PROGRESS(progress), (float)size/total); } gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), FALSE); /* See if the user wants to cancel the uninstall */ while( gtk_events_pending() ) { gtk_main_iteration(); } } clist = clist->next; } /* Now do the primary components */ clist = gtk_container_children(GTK_CONTAINER(widget)); while ( clist && ! uninstall_cancelled ) { button = GTK_WIDGET(clist->data); if ( gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button)) ) { component = gtk_object_get_data(GTK_OBJECT(button), "data"); if ( ! loki_isdefault_component(component->component) ) { clist = clist->next; continue; } /* Put up the status */ strncpy(text, component->info->description, sizeof(text)); set_status_text(text); /* See if the user wants to cancel the uninstall */ while( gtk_events_pending() ) { gtk_main_iteration(); } /* Display an optional message to the user */ message = loki_getmessage_component(component->component); if ( message && !display_message(message, BUTTON_OK|BUTTON_ABORT) ) { clist = clist->next; uninstall_cancelled = 1; break; } /* Remove the component */ if ( ! perform_uninstall(component->product, component->info, 0) ) { uninstall_cancelled = 2; snprintf(text, sizeof(text), _("Uninstallation of product %s has failed!\n" "Aborting the rest of the uninstallation.\n"), component->info->description); display_message(text, BUTTON_ABORT); break; } remove_product(component->product); /* Update the progress bar */ if ( total && progress ) { size += component->size/1024; gtk_progress_set_percentage(GTK_PROGRESS(progress), (float)size/total); } /* See if the user wants to cancel the uninstall */ while( gtk_events_pending() ) { gtk_main_iteration(); } break; } clist = clist->next; } list = list->next; } switch ( uninstall_cancelled ) { case 1: set_status_text(_("Uninstall cancelled")); break; case 2: set_status_text(_("Uninstall aborted")); break; default: set_status_text(_("Uninstall complete")); gtk_progress_set_percentage(GTK_PROGRESS(progress), 1.0f); break; } widget = glade_xml_get_widget(uninstall_glade, "cancel_button"); if ( widget ) { gtk_button_set_sensitive(widget, FALSE); } widget = glade_xml_get_widget(uninstall_glade, "finished_button"); if ( widget ) { gtk_button_set_sensitive(widget, TRUE); } }
static void create_find_dialog(GtkWidget *htmlwidget) { GtkWidget *dialog_vbox29; GtkWidget *vbox45; GtkWidget *label180; GtkWidget *hbox66; GtkWidget *dialog_action_area29; GtkWidget *hbuttonbox8; #ifndef HAVE_GTK_310 GtkWidget *alignment; #endif GtkWidget *hbox5; GtkWidget *image; GtkWidget *label12; //gchar title[80]; //sprintf(title, "%s - %s", settings.program_title, _("Find")); dialog = g_new(FIND_DIALOG, 1); /* must be freed */ dialog->regular = FALSE; dialog->htmlwidget = htmlwidget; dialog->dialog = gtk_dialog_new(); g_object_set_data(G_OBJECT(dialog->dialog), "dialog->dialog", dialog->dialog); gtk_window_set_title(GTK_WINDOW(dialog->dialog), _("Find")); //GTK_WINDOW(dialog->dialog)->type = GTK_WINDOW_TOPLEVEL; /*gtk_window_set_policy(GTK_WINDOW(dialog->dialog), TRUE, TRUE, FALSE); */ gtk_container_set_border_width(GTK_CONTAINER(dialog->dialog), 6); gtk_window_set_resizable(GTK_WINDOW(dialog->dialog), FALSE); #ifndef USE_GTK_3 gtk_dialog_set_has_separator(GTK_DIALOG(dialog->dialog), FALSE); #endif dialog_vbox29 = gtk_dialog_get_content_area(GTK_DIALOG(dialog->dialog)); g_object_set_data(G_OBJECT(dialog->dialog), "dialog_vbox29", dialog_vbox29); gtk_widget_show(dialog_vbox29); UI_VBOX(vbox45, FALSE, 12); gtk_widget_show(vbox45); gtk_box_pack_start(GTK_BOX(dialog_vbox29), vbox45, TRUE, TRUE, 0); label180 = gtk_label_new(_("Enter Word or Phrase")); gtk_widget_show(label180); gtk_box_pack_start(GTK_BOX(vbox45), label180, FALSE, FALSE, 0); dialog->entry = gtk_entry_new(); gtk_widget_show(dialog->entry); gtk_box_pack_start(GTK_BOX(vbox45), dialog->entry, FALSE, FALSE, 0); gtk_widget_set_size_request(dialog->entry, 291, -1); UI_HBOX(hbox66, FALSE, 0); gtk_widget_show(hbox66); gtk_box_pack_start(GTK_BOX(vbox45), hbox66, TRUE, TRUE, 0); dialog->backward = gtk_check_button_new_with_label(_("Search backwards")); gtk_widget_show(dialog->backward); gtk_box_pack_start(GTK_BOX(hbox66), dialog->backward, FALSE, FALSE, 0); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dialog->backward), FALSE); dialog_action_area29 = #ifdef HAVE_GTK_312 gtk_dialog_get_content_area(GTK_DIALOG(dialog->dialog)); #else gtk_dialog_get_action_area(GTK_DIALOG(dialog->dialog)); #endif g_object_set_data(G_OBJECT(dialog->dialog), "dialog_action_area29", dialog_action_area29); gtk_widget_show(dialog_action_area29); gtk_container_set_border_width(GTK_CONTAINER(dialog_action_area29), 10); #ifdef USE_GTK_3 hbuttonbox8 = gtk_button_box_new(GTK_ORIENTATION_HORIZONTAL); #else hbuttonbox8 = gtk_hbutton_box_new(); #endif gtk_widget_show(hbuttonbox8); gtk_box_pack_start(GTK_BOX(dialog_action_area29), hbuttonbox8, TRUE, TRUE, 0); dialog->find = #ifdef HAVE_GTK_310 gtk_button_new_from_icon_name("edit-find", GTK_ICON_SIZE_BUTTON); #else gtk_button_new_from_stock(GTK_STOCK_FIND); //gtk_button_new_with_label(_("Find")); #endif gtk_widget_show(dialog->find); gtk_container_add(GTK_CONTAINER(hbuttonbox8), dialog->find); dialog->next = gtk_button_new(); gtk_widget_show(dialog->next); gtk_container_add(GTK_CONTAINER(hbuttonbox8), dialog->next); //GTK_WIDGET_SET_FLAGS(dialog->next, GTK_CAN_DEFAULT); #ifndef HAVE_GTK_310 alignment = gtk_alignment_new(0.5, 0.5, 0, 0); gtk_widget_show(alignment); gtk_container_add(GTK_CONTAINER(dialog->next), alignment); #endif UI_HBOX(hbox5, FALSE, 2); gtk_widget_show(hbox5); #ifndef HAVE_GTK_310 gtk_container_add(GTK_CONTAINER(alignment), hbox5); #endif image = #ifdef HAVE_GTK_310 gtk_image_new_from_icon_name("edit-find", GTK_ICON_SIZE_BUTTON); #else gtk_image_new_from_stock(GTK_STOCK_FIND, GTK_ICON_SIZE_BUTTON); #endif gtk_widget_show(image); gtk_box_pack_start(GTK_BOX(hbox5), image, FALSE, FALSE, 0); label12 = gtk_label_new_with_mnemonic(_("Find Next")); gtk_widget_show(label12); gtk_box_pack_start(GTK_BOX(hbox5), label12, FALSE, FALSE, 0); gtk_label_set_justify(GTK_LABEL(label12), GTK_JUSTIFY_LEFT); dialog->close = #ifdef HAVE_GTK_310 // Don't use an icon with GTK3 gtk_button_new_with_label(_("Close")); #else gtk_button_new_from_stock(GTK_STOCK_CLOSE); #endif gtk_widget_show(dialog->close); gtk_container_add(GTK_CONTAINER(hbuttonbox8), dialog->close); //GTK_WIDGET_SET_FLAGS(dialog->close, GTK_CAN_DEFAULT); gtk_widget_set_can_default(dialog->find, 1); g_signal_connect(G_OBJECT(dialog->dialog), "destroy", G_CALLBACK(dialog_destroy), dialog); g_signal_connect(G_OBJECT(dialog->find), "clicked", G_CALLBACK(find_clicked), dialog); g_signal_connect(G_OBJECT(dialog->next), "clicked", G_CALLBACK(next_clicked), dialog); g_signal_connect(G_OBJECT(dialog->close), "clicked", G_CALLBACK(close_clicked), dialog); }
static void next_clicked(GtkButton *button, FIND_DIALOG *d) { XIPHOS_HTML_FIND_AGAIN((void *)d->htmlwidget, 1); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(d->backward), 0); }
bool SettingsDialog::getCheckbox(const char * name) { XOJ_CHECK_TYPE(SettingsDialog); GtkToggleButton * b = GTK_TOGGLE_BUTTON(get(name)); return gtk_toggle_button_get_active(b); }
PidginXferDialog * pidgin_xfer_dialog_new(void) { PidginXferDialog *dialog; GtkWidget *window; GtkWidget *vbox1, *vbox2; GtkWidget *sw; GtkWidget *button; GtkWidget *expander; GtkWidget *table; GtkWidget *checkbox; dialog = g_new0(PidginXferDialog, 1); dialog->keep_open = purple_prefs_get_bool(PIDGIN_PREFS_ROOT "/filetransfer/keep_open"); dialog->auto_clear = purple_prefs_get_bool(PIDGIN_PREFS_ROOT "/filetransfer/clear_finished"); /* Create the window. */ dialog->window = window = pidgin_create_dialog(_("File Transfers"), PIDGIN_HIG_BORDER, "file transfer", TRUE); gtk_window_set_default_size(GTK_WINDOW(window), 450, 250); g_signal_connect(G_OBJECT(window), "delete_event", G_CALLBACK(delete_win_cb), dialog); /* Create the parent vbox for everything. */ vbox1 = pidgin_dialog_get_vbox_with_properties(GTK_DIALOG(window), FALSE, PIDGIN_HIG_BORDER); /* Create the main vbox for top half of the window. */ vbox2 = gtk_vbox_new(FALSE, PIDGIN_HIG_BOX_SPACE); gtk_box_pack_start(GTK_BOX(vbox1), vbox2, TRUE, TRUE, 0); gtk_widget_show(vbox2); /* Setup the listbox */ sw = setup_tree(dialog); gtk_box_pack_start(GTK_BOX(vbox2), sw, TRUE, TRUE, 0); gtk_widget_set_size_request(sw,-1, 140); /* "Close this window when all transfers finish" */ checkbox = gtk_check_button_new_with_mnemonic( _("Close this window when all transfers _finish")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbox), !dialog->keep_open); g_signal_connect(G_OBJECT(checkbox), "toggled", G_CALLBACK(toggle_keep_open_cb), dialog); gtk_box_pack_start(GTK_BOX(vbox2), checkbox, FALSE, FALSE, 0); gtk_widget_show(checkbox); /* "Clear finished transfers" */ checkbox = gtk_check_button_new_with_mnemonic( _("C_lear finished transfers")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbox), dialog->auto_clear); g_signal_connect(G_OBJECT(checkbox), "toggled", G_CALLBACK(toggle_clear_finished_cb), dialog); gtk_box_pack_start(GTK_BOX(vbox2), checkbox, FALSE, FALSE, 0); gtk_widget_show(checkbox); /* "Download Details" arrow */ expander = gtk_expander_new_with_mnemonic(_("File transfer _details")); dialog->expander = expander; gtk_box_pack_start(GTK_BOX(vbox2), expander, FALSE, FALSE, 0); gtk_widget_show(expander); gtk_widget_set_sensitive(expander, FALSE); /* The table of information. */ table = make_info_table(dialog); gtk_container_add(GTK_CONTAINER(expander), table); gtk_widget_show(table); /* Open button */ button = pidgin_dialog_add_button(GTK_DIALOG(window), GTK_STOCK_OPEN, G_CALLBACK(open_button_cb), dialog); gtk_widget_set_sensitive(button, FALSE); dialog->open_button = button; /* Remove button */ button = pidgin_dialog_add_button(GTK_DIALOG(window), GTK_STOCK_REMOVE, G_CALLBACK(remove_button_cb), dialog); gtk_widget_hide(button); dialog->remove_button = button; /* Stop button */ button = pidgin_dialog_add_button(GTK_DIALOG(window), GTK_STOCK_STOP, G_CALLBACK(stop_button_cb), dialog); gtk_widget_set_sensitive(button, FALSE); dialog->stop_button = button; /* Close button */ button = pidgin_dialog_add_button(GTK_DIALOG(window), GTK_STOCK_CLOSE, G_CALLBACK(close_button_cb), dialog); dialog->close_button = button; #ifdef _WIN32 g_signal_connect(G_OBJECT(dialog->window), "show", G_CALLBACK(winpidgin_ensure_onscreen), dialog->window); #endif return dialog; }
void DisplayDialog() { GtkWidget *dialog; int return_value; GtkWidget *msg_box, *log_box, *dump_box, *main_box; GtkWidget *msg_frame, *log_frame, *dump_frame, *main_frame; GtkWidget *msg_console_check, *msg_key_check, *msg_voice_check, *msg_dma_check; GtkWidget *msg_autodma_check, *msg_overrun_check, *msg_cache_check; GtkWidget *log_access_check, *log_dma_check, *log_wave_check; GtkWidget *dump_core_check, *dump_mem_check, *dump_reg_check; ReadSettings(); // Create the widgets dialog = gtk_dialog_new_with_buttons ( "Spu2-X Config", NULL, // parent window (GtkDialogFlags)(GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT), "OK", GTK_RESPONSE_ACCEPT, "Cancel", GTK_RESPONSE_REJECT, NULL); main_box = gtk_hbox_new(false, 5); main_frame = gtk_frame_new ("Spu2-X Config"); gtk_container_add (GTK_CONTAINER(main_frame), main_box); // Message Section msg_box = gtk_vbox_new(false, 5); msg_console_check = gtk_check_button_new_with_label("Show In Console"); msg_key_check = gtk_check_button_new_with_label("KeyOn/Off Events"); msg_voice_check = gtk_check_button_new_with_label("Voice Stop Events"); msg_dma_check = gtk_check_button_new_with_label("DMA Operations"); msg_autodma_check = gtk_check_button_new_with_label("AutoDMA Operations"); msg_overrun_check = gtk_check_button_new_with_label("Buffer Over/Underruns"); msg_cache_check = gtk_check_button_new_with_label("ADPCM Cache Statistics"); gtk_container_add(GTK_CONTAINER(msg_box), msg_console_check); gtk_container_add(GTK_CONTAINER(msg_box), msg_key_check); gtk_container_add(GTK_CONTAINER(msg_box), msg_voice_check); gtk_container_add(GTK_CONTAINER(msg_box), msg_dma_check); gtk_container_add(GTK_CONTAINER(msg_box), msg_autodma_check); gtk_container_add(GTK_CONTAINER(msg_box), msg_overrun_check); gtk_container_add(GTK_CONTAINER(msg_box), msg_cache_check); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(msg_console_check), _MsgToConsole); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(msg_key_check), _MsgKeyOnOff); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(msg_voice_check), _MsgVoiceOff); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(msg_dma_check), _MsgDMA); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(msg_autodma_check), _MsgAutoDMA); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(msg_overrun_check), _MsgOverruns); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(msg_cache_check), _MsgCache); msg_frame = gtk_frame_new ("Message/Log Options"); gtk_container_add (GTK_CONTAINER(msg_frame), msg_box); // Log Section log_box = gtk_vbox_new(false, 5); log_access_check = gtk_check_button_new_with_label("Log Register/DMA Actions"); log_dma_check = gtk_check_button_new_with_label("Log DMA Writes"); log_wave_check = gtk_check_button_new_with_label("Log Audio Output"); gtk_container_add(GTK_CONTAINER(log_box), log_access_check); gtk_container_add(GTK_CONTAINER(log_box), log_dma_check); gtk_container_add(GTK_CONTAINER(log_box), log_wave_check); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(log_access_check), _AccessLog); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(log_dma_check), _DMALog); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(log_wave_check), _WaveLog); log_frame = gtk_frame_new ("Log Options"); gtk_container_add (GTK_CONTAINER(log_frame), log_box); // Dump Section dump_box = gtk_vbox_new(false, 5); dump_core_check = gtk_check_button_new_with_label("Dump Core and Voice State"); dump_mem_check = gtk_check_button_new_with_label("Dump Memory Contents"); dump_reg_check = gtk_check_button_new_with_label("Dump Register Data"); gtk_container_add(GTK_CONTAINER(dump_box), dump_core_check); gtk_container_add(GTK_CONTAINER(dump_box), dump_mem_check); gtk_container_add(GTK_CONTAINER(dump_box), dump_reg_check); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dump_core_check), _CoresDump); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dump_mem_check), _MemDump); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dump_reg_check), _RegDump); dump_frame = gtk_frame_new ("Dumps (on close)"); gtk_container_add (GTK_CONTAINER(dump_frame), dump_box); // Add everything gtk_container_add (GTK_CONTAINER(main_box), msg_frame); gtk_container_add (GTK_CONTAINER(main_box), log_frame); gtk_container_add (GTK_CONTAINER(main_box), dump_frame); // Add all our widgets, and show everything we've added to the dialog. gtk_container_add (GTK_CONTAINER(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), main_frame); gtk_widget_show_all (dialog); return_value = gtk_dialog_run (GTK_DIALOG (dialog)); if (return_value == GTK_RESPONSE_ACCEPT) { _MsgToConsole = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(msg_console_check)); _MsgKeyOnOff = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(msg_key_check)); _MsgVoiceOff = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(msg_voice_check)); _MsgDMA = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(msg_dma_check)); _MsgAutoDMA = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(msg_autodma_check)); _MsgOverruns = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(msg_overrun_check)); _MsgCache = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(msg_cache_check)); _AccessLog = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(log_access_check)); _DMALog = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(log_dma_check)); _WaveLog = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(log_wave_check)); _CoresDump = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dump_core_check)); _MemDump = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dump_mem_check)); _RegDump = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dump_reg_check)); } gtk_widget_destroy (dialog); WriteSettings(); }
static void * file_configure (void) { GtkWidget * configure_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); GtkWidget * fileext_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5); gtk_box_pack_start(GTK_BOX(configure_vbox), fileext_hbox, FALSE, FALSE, 0); GtkWidget * fileext_label = gtk_label_new (_("Output file format:")); gtk_box_pack_start(GTK_BOX(fileext_hbox), fileext_label, FALSE, FALSE, 0); fileext_combo = gtk_combo_box_text_new (); gtk_combo_box_text_append_text ((GtkComboBoxText *) fileext_combo, "WAV"); #ifdef FILEWRITER_MP3 gtk_combo_box_text_append_text ((GtkComboBoxText *) fileext_combo, "MP3"); #endif #ifdef FILEWRITER_VORBIS gtk_combo_box_text_append_text ((GtkComboBoxText *) fileext_combo, "Vorbis"); #endif #ifdef FILEWRITER_FLAC gtk_combo_box_text_append_text ((GtkComboBoxText *) fileext_combo, "FLAC"); #endif gtk_box_pack_start(GTK_BOX(fileext_hbox), fileext_combo, FALSE, FALSE, 0); gtk_combo_box_set_active(GTK_COMBO_BOX(fileext_combo), fileext); plugin_button = gtk_button_new_with_label(_("Configure")); gtk_widget_set_sensitive(plugin_button, plugin->configure != NULL); gtk_box_pack_end(GTK_BOX(fileext_hbox), plugin_button, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(configure_vbox), gtk_separator_new(GTK_ORIENTATION_HORIZONTAL), FALSE, FALSE, 0); GtkWidget * saveplace_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5); gtk_container_add(GTK_CONTAINER(configure_vbox), saveplace_hbox); GtkWidget * saveplace1 = gtk_radio_button_new_with_label (NULL, _("Save into original directory")); gtk_box_pack_start ((GtkBox *) saveplace_hbox, saveplace1, FALSE, FALSE, 0); GtkWidget * saveplace2 = gtk_radio_button_new_with_label_from_widget ((GtkRadioButton *) saveplace1, _("Save into custom directory")); if (!save_original) gtk_toggle_button_set_active ((GtkToggleButton *) saveplace2, TRUE); gtk_box_pack_start ((GtkBox *) saveplace_hbox, saveplace2, FALSE, FALSE, 0); path_hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5); gtk_box_pack_start(GTK_BOX(configure_vbox), path_hbox, FALSE, FALSE, 0); GtkWidget * path_label = gtk_label_new (_("Output file folder:")); gtk_box_pack_start ((GtkBox *) path_hbox, path_label, FALSE, FALSE, 0); path_dirbrowser = gtk_file_chooser_button_new (_("Pick a folder"), GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER); gtk_file_chooser_set_uri ((GtkFileChooser *) path_dirbrowser, file_path); gtk_box_pack_start(GTK_BOX(path_hbox), path_dirbrowser, TRUE, TRUE, 0); if (save_original) gtk_widget_set_sensitive(path_hbox, FALSE); gtk_box_pack_start(GTK_BOX(configure_vbox), gtk_separator_new(GTK_ORIENTATION_HORIZONTAL), FALSE, FALSE, 0); filenamefrom_hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5); gtk_container_add(GTK_CONTAINER(configure_vbox), filenamefrom_hbox); filenamefrom_label = gtk_label_new(_("Get filename from:")); gtk_box_pack_start(GTK_BOX(filenamefrom_hbox), filenamefrom_label, FALSE, FALSE, 0); GtkWidget * filenamefrom_toggle1 = gtk_radio_button_new_with_label (NULL, _("original file tags")); gtk_box_pack_start ((GtkBox *) filenamefrom_hbox, filenamefrom_toggle1, FALSE, FALSE, 0); GtkWidget * filenamefrom_toggle2 = gtk_radio_button_new_with_label_from_widget ((GtkRadioButton *) filenamefrom_toggle1, _("original filename")); gtk_box_pack_start ((GtkBox *) filenamefrom_hbox, filenamefrom_toggle2, FALSE, FALSE, 0); if (!filenamefromtags) gtk_toggle_button_set_active ((GtkToggleButton *) filenamefrom_toggle2, TRUE); use_suffix_toggle = gtk_check_button_new_with_label(_("Don't strip file name extension")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(use_suffix_toggle), use_suffix); gtk_box_pack_start(GTK_BOX(configure_vbox), use_suffix_toggle, FALSE, FALSE, 0); if (filenamefromtags) gtk_widget_set_sensitive(use_suffix_toggle, FALSE); gtk_box_pack_start(GTK_BOX(configure_vbox), gtk_separator_new(GTK_ORIENTATION_HORIZONTAL), FALSE, FALSE, 0); prependnumber_toggle = gtk_check_button_new_with_label(_("Prepend track number to filename")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(prependnumber_toggle), prependnumber); gtk_box_pack_start(GTK_BOX(configure_vbox), prependnumber_toggle, FALSE, FALSE, 0); g_signal_connect (fileext_combo, "changed", (GCallback) fileext_cb, NULL); g_signal_connect (plugin_button, "clicked", (GCallback) plugin_configure_cb, NULL); g_signal_connect (saveplace1, "toggled", (GCallback) saveplace_original_cb, NULL); g_signal_connect (saveplace2, "toggled", (GCallback) saveplace_custom_cb, NULL); g_signal_connect (filenamefrom_toggle1, "toggled", (GCallback) filenamefromtags_cb, NULL); g_signal_connect (filenamefrom_toggle2, "toggled", (GCallback) filenamefromfilename_cb, NULL); return configure_vbox; }
/** * fm_app_chooser_dlg_new * @mime_type: (allow-none): MIME type for list creation * @can_set_default: %TRUE if widget can set selected item as default for @mime_type * * Creates a widget for choosing an application either from tree of * existing ones or also allows to set up own command for it. * * Returns: (transfer full): a widget. * * Since: 0.1.0 */ GtkDialog *fm_app_chooser_dlg_new(FmMimeType* mime_type, gboolean can_set_default) { GtkContainer* scroll; GtkLabel *file_type, *file_type_header; GtkTreeSelection* tree_sel; GtkBuilder* builder = gtk_builder_new(); AppChooserData* data = g_slice_new0(AppChooserData); gtk_builder_set_translation_domain(builder, GETTEXT_PACKAGE); gtk_builder_add_from_file(builder, PACKAGE_UI_DIR "/app-chooser.ui", NULL); data->dlg = GTK_DIALOG(gtk_builder_get_object(builder, "dlg")); data->notebook = GTK_NOTEBOOK(gtk_builder_get_object(builder, "notebook")); scroll = GTK_CONTAINER(gtk_builder_get_object(builder, "apps_scroll")); file_type = GTK_LABEL(gtk_builder_get_object(builder, "file_type")); file_type_header = GTK_LABEL(gtk_builder_get_object(builder, "file_type_header")); data->cmdline = GTK_ENTRY(gtk_builder_get_object(builder, "cmdline")); data->set_default = GTK_TOGGLE_BUTTON(gtk_builder_get_object(builder, "set_default")); data->use_terminal = GTK_TOGGLE_BUTTON(gtk_builder_get_object(builder, "use_terminal")); data->keep_open = GTK_TOGGLE_BUTTON(gtk_builder_get_object(builder, "keep_open")); data->browse_btn = GTK_WIDGET(gtk_builder_get_object(builder, "browse_btn")); data->app_name = GTK_ENTRY(gtk_builder_get_object(builder, "app_name")); /* FIXME: shouldn't verify if app-chooser.ui was correct? */ if(mime_type) data->mime_type = fm_mime_type_ref(mime_type); gtk_dialog_set_alternative_button_order(data->dlg, GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); if(!can_set_default) gtk_widget_hide(GTK_WIDGET(data->set_default)); if(mime_type && fm_mime_type_get_desc(mime_type)) { if (file_type_header) { char *text = g_strdup_printf(_("<b>Select an application to open \"%s\" files</b>"), fm_mime_type_get_desc(mime_type)); gtk_label_set_markup(file_type_header, text); g_free(text); } else gtk_label_set_text(file_type, fm_mime_type_get_desc(mime_type)); } else { GtkWidget* hbox = GTK_WIDGET(gtk_builder_get_object(builder, "file_type_hbox")); gtk_widget_destroy(hbox); gtk_widget_hide(GTK_WIDGET(data->set_default)); } data->apps_view = fm_app_menu_view_new(); gtk_tree_view_set_headers_visible(data->apps_view, FALSE); gtk_widget_show(GTK_WIDGET(data->apps_view)); gtk_container_add(scroll, GTK_WIDGET(data->apps_view)); gtk_widget_grab_focus(GTK_WIDGET(data->apps_view)); g_object_unref(builder); g_signal_connect(data->browse_btn, "clicked", G_CALLBACK(on_browse_btn_clicked), data); g_object_set_qdata_full(G_OBJECT(data->dlg), fm_qdata_id, data, (GDestroyNotify)on_dlg_destroy); g_signal_connect(data->notebook, "switch-page", G_CALLBACK(on_switch_page), data); on_switch_page(data->notebook, NULL, 0, data); tree_sel = gtk_tree_view_get_selection(data->apps_view); g_signal_connect(tree_sel, "changed", G_CALLBACK(on_apps_view_sel_changed), data); g_signal_connect(data->cmdline, "changed", G_CALLBACK(on_cmdline_changed), data); g_signal_connect(data->use_terminal, "toggled", G_CALLBACK(on_use_terminal_changed), data); gtk_dialog_set_response_sensitive(data->dlg, GTK_RESPONSE_OK, FALSE); return data->dlg; }
void on_startupactionbtn_toggled (GtkButton *button, gpointer user_data) { gboolean enabled = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button)); conf_set_int_value (STARTUP_FEED_ACTION, enabled?0:1); }
static void file_entry_directory_toggle(GtkWidget *w, GnomeFileEntry *fentry) { gnome_file_entry_set_directory_entry (fentry,GTK_TOGGLE_BUTTON(w)->active); }
void preferences_dialog_init (PreferencesDialog *pd) { GtkWidget *widget, *entry; GtkComboBox *combo; GtkListStore *store; GtkTreeIter treeiter; GtkAdjustment *itemCount; GtkTreeStore *treestore; GtkTreeViewColumn *column; GSList *list; gchar *proxyport; gchar *configuredBrowser, *name; gboolean enabled; static int manual; struct browser *iter; gint tmp, i, iSetting, proxy_port; gboolean bSetting; gchar *proxy_host, *proxy_user, *proxy_passwd; gchar *browser_command; prefdialog = pd; pd->priv = PREFERENCES_DIALOG_GET_PRIVATE (pd); pd->priv->dialog = liferea_dialog_new ("prefs.ui", "prefdialog"); /* Set up browser selection popup */ store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_INT); for(i = 0, iter = browser_get_all (); iter->id != NULL; iter++, i++) { gtk_list_store_append (store, &treeiter); gtk_list_store_set (store, &treeiter, 0, _(iter->display), 1, i, -1); } manual = i; /* This allows the user to choose their own browser by typing in the command. */ gtk_list_store_append (store, &treeiter); gtk_list_store_set (store, &treeiter, 0, _("Manual"), 1, i, -1); combo = GTK_COMBO_BOX (liferea_dialog_lookup (pd->priv->dialog, "browserpopup")); gtk_combo_box_set_model (combo, GTK_TREE_MODEL (store)); ui_common_setup_combo_text (combo, 0); g_signal_connect(G_OBJECT(combo), "changed", G_CALLBACK(on_browser_changed), pd); /* Create location menu */ store = gtk_list_store_new (1, G_TYPE_STRING); combo = GTK_COMBO_BOX (liferea_dialog_lookup (pd->priv->dialog, "browserlocpopup")); gtk_combo_box_set_model (combo, GTK_TREE_MODEL (store)); ui_common_setup_combo_text (combo, 0); g_signal_connect(G_OBJECT(combo), "changed", G_CALLBACK(on_browser_place_changed), pd); gtk_list_store_append (store, &treeiter); gtk_list_store_set (store, &treeiter, 0, _("Browser default"), -1); gtk_list_store_append (store, &treeiter); gtk_list_store_set (store, &treeiter, 0, _("Existing window"), -1); gtk_list_store_append (store, &treeiter); gtk_list_store_set (store, &treeiter, 0, _("New window"), -1); gtk_list_store_append (store, &treeiter); gtk_list_store_set (store, &treeiter, 0, _("New tab"), -1); /* ================== panel 1 "feeds" ==================== */ /* check box for feed startup update */ conf_get_int_value (STARTUP_FEED_ACTION, &iSetting); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (liferea_dialog_lookup (pd->priv->dialog, "startupactionbtn")), (iSetting == 0)); /* cache size setting */ widget = liferea_dialog_lookup (pd->priv->dialog, "itemCountBtn"); itemCount = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (widget)); conf_get_int_value (DEFAULT_MAX_ITEMS, &iSetting); gtk_adjustment_set_value (itemCount, iSetting); /* set default update interval spin button and unit combo box */ ui_common_setup_combo_menu (liferea_dialog_lookup (pd->priv->dialog, "globalRefreshIntervalUnitComboBox"), default_update_interval_unit_options, G_CALLBACK (on_default_update_interval_unit_changed), -1); widget = liferea_dialog_lookup (pd->priv->dialog, "globalRefreshIntervalUnitComboBox"); conf_get_int_value (DEFAULT_UPDATE_INTERVAL, &tmp); if (tmp % 1440 == 0) { /* days */ gtk_combo_box_set_active (GTK_COMBO_BOX (widget), 2); tmp /= 1440; } else if (tmp % 60 == 0) { /* hours */ gtk_combo_box_set_active (GTK_COMBO_BOX (widget), 1); tmp /= 60; } else { /* minutes */ gtk_combo_box_set_active (GTK_COMBO_BOX (widget), 0); } widget = liferea_dialog_lookup (pd->priv->dialog,"globalRefreshIntervalSpinButton"); gtk_spin_button_set_range (GTK_SPIN_BUTTON (widget), 0, 1000000000); gtk_spin_button_set_value (GTK_SPIN_BUTTON (widget), tmp); g_signal_connect (G_OBJECT (widget), "changed", G_CALLBACK (on_default_update_interval_value_changed), pd); /* ================== panel 2 "folders" ==================== */ g_signal_connect (G_OBJECT (liferea_dialog_lookup (pd->priv->dialog, "updateAllFavicons")), "clicked", G_CALLBACK(on_updateallfavicons_clicked), pd); conf_get_int_value (FOLDER_DISPLAY_MODE, &iSetting); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (liferea_dialog_lookup (pd->priv->dialog, "folderdisplaybtn")), iSetting?TRUE:FALSE); conf_get_bool_value (FOLDER_DISPLAY_HIDE_READ, &bSetting); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (liferea_dialog_lookup (pd->priv->dialog, "hidereadbtn")), bSetting?TRUE:FALSE); /* ================== panel 3 "headlines" ==================== */ conf_get_int_value (BROWSE_KEY_SETTING, &iSetting); ui_common_setup_combo_menu (liferea_dialog_lookup (pd->priv->dialog, "skimKeyCombo"), browser_skim_key_options, G_CALLBACK (on_skim_key_changed), iSetting); conf_get_int_value (DEFAULT_VIEW_MODE, &iSetting); ui_common_setup_combo_menu (liferea_dialog_lookup (pd->priv->dialog, "defaultViewModeCombo"), default_view_mode_options, G_CALLBACK (on_default_view_mode_changed), iSetting); /* Setup social bookmarking list */ i = 0; conf_get_str_value (SOCIAL_BM_SITE, &name); store = gtk_list_store_new (1, G_TYPE_STRING); list = bookmarkSites; while (list) { socialSitePtr siter = list->data; if (name && !strcmp (siter->name, name)) tmp = i; gtk_list_store_append (store, &treeiter); gtk_list_store_set (store, &treeiter, 0, siter->name, -1); list = g_slist_next (list); i++; } combo = GTK_COMBO_BOX (liferea_dialog_lookup (pd->priv->dialog, "socialpopup")); g_signal_connect (G_OBJECT (combo), "changed", G_CALLBACK (on_socialsite_changed), pd); gtk_combo_box_set_model (combo, GTK_TREE_MODEL (store)); ui_common_setup_combo_text (combo, 0); gtk_combo_box_set_active (combo, tmp); /* ================== panel 4 "browser" ==================== */ /* set the inside browsing flag */ widget = liferea_dialog_lookup(pd->priv->dialog, "browseinwindow"); conf_get_bool_value(BROWSE_INSIDE_APPLICATION, &bSetting); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget), bSetting); /* set the javascript-disabled flag */ widget = liferea_dialog_lookup(pd->priv->dialog, "disablejavascript"); conf_get_bool_value(DISABLE_JAVASCRIPT, &bSetting); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget), bSetting); /* set the enable Plugins flag */ widget = liferea_dialog_lookup(pd->priv->dialog, "enableplugins"); conf_get_bool_value(ENABLE_PLUGINS, &bSetting); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget), bSetting); tmp = 0; conf_get_str_value(BROWSER_ID, &configuredBrowser); if(!strcmp(configuredBrowser, "manual")) tmp = manual; else for(i=0, iter = browser_get_all (); iter->id != NULL; iter++, i++) if(!strcmp(configuredBrowser, iter->id)) tmp = i; gtk_combo_box_set_active(GTK_COMBO_BOX(liferea_dialog_lookup(pd->priv->dialog, "browserpopup")), tmp); g_free(configuredBrowser); conf_get_int_value (BROWSER_PLACE, &iSetting); gtk_combo_box_set_active(GTK_COMBO_BOX(liferea_dialog_lookup(pd->priv->dialog, "browserlocpopup")), iSetting); conf_get_str_value (BROWSER_COMMAND, &browser_command); entry = liferea_dialog_lookup(pd->priv->dialog, "browsercmd"); gtk_entry_set_text(GTK_ENTRY(entry), browser_command); g_free (browser_command); gtk_widget_set_sensitive (GTK_WIDGET (entry), tmp == manual); gtk_widget_set_sensitive (liferea_dialog_lookup (pd->priv->dialog, "manuallabel"), tmp == manual); gtk_widget_set_sensitive (liferea_dialog_lookup (pd->priv->dialog, "urlhintlabel"), tmp == manual); /* ================== panel 4 "GUI" ================ */ /* tool bar settings */ widget = liferea_dialog_lookup (pd->priv->dialog, "hidetoolbarbtn"); conf_get_bool_value(DISABLE_TOOLBAR, &bSetting); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), bSetting); /* select currently active toolbar style option */ conf_get_str_value (TOOLBAR_STYLE, &name); for (i = 0; gui_toolbar_style_values[i] != NULL; ++i) { if (strcmp (name, gui_toolbar_style_values[i]) == 0) break; } g_free (name); /* On invalid key value: revert to default */ if (gui_toolbar_style_values[i] == NULL) i = 0; /* create toolbar style menu */ ui_common_setup_combo_menu (liferea_dialog_lookup (pd->priv->dialog, "toolbarCombo"), gui_toolbar_style_options, G_CALLBACK (on_gui_toolbar_style_changed), i); /* ================= panel 5 "proxy" ======================== */ conf_get_str_value (PROXY_HOST, &proxy_host); gtk_entry_set_text (GTK_ENTRY (liferea_dialog_lookup (pd->priv->dialog, "proxyhostentry")), proxy_host); g_free (proxy_host); conf_get_int_value (PROXY_PORT, &proxy_port); proxyport = g_strdup_printf ("%d", proxy_port); gtk_entry_set_text (GTK_ENTRY (liferea_dialog_lookup (pd->priv->dialog, "proxyportentry")), proxyport); g_free (proxyport); conf_get_bool_value (PROXY_USEAUTH, &enabled); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (liferea_dialog_lookup (pd->priv->dialog, "useProxyAuth")), enabled); conf_get_str_value (PROXY_USER, &proxy_user); gtk_entry_set_text (GTK_ENTRY (liferea_dialog_lookup (pd->priv->dialog, "proxyusernameentry")), proxy_user); g_free (proxy_user); conf_get_str_value (PROXY_PASSWD, &proxy_passwd); gtk_entry_set_text (GTK_ENTRY (liferea_dialog_lookup (pd->priv->dialog, "proxypasswordentry")), proxy_passwd); g_free (proxy_passwd); gtk_widget_set_sensitive (GTK_WIDGET (liferea_dialog_lookup(pd->priv->dialog, "proxyauthtable")), enabled); conf_get_int_value (PROXY_DETECT_MODE, &i); switch (i) { default: case 0: /* proxy auto detect */ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (liferea_dialog_lookup (pd->priv->dialog, "proxyAutoDetectRadio")), TRUE); enabled = FALSE; break; case 1: /* no proxy */ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (liferea_dialog_lookup (pd->priv->dialog, "noProxyRadio")), TRUE); enabled = FALSE; break; case 2: /* manual proxy */ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (liferea_dialog_lookup (pd->priv->dialog, "manualProxyRadio")), TRUE); enabled = TRUE; break; } gtk_widget_set_sensitive (GTK_WIDGET (liferea_dialog_lookup (pd->priv->dialog, "proxybox")), enabled); g_signal_connect (G_OBJECT (liferea_dialog_lookup (pd->priv->dialog, "proxyAutoDetectRadio")), "clicked", G_CALLBACK (on_proxyAutoDetect_clicked), pd); g_signal_connect (G_OBJECT (liferea_dialog_lookup (pd->priv->dialog, "noProxyRadio")), "clicked", G_CALLBACK (on_noProxy_clicked), pd); g_signal_connect (G_OBJECT (liferea_dialog_lookup (pd->priv->dialog, "manualProxyRadio")), "clicked", G_CALLBACK (on_manualProxy_clicked), pd); g_signal_connect (G_OBJECT (liferea_dialog_lookup (pd->priv->dialog, "proxyhostentry")), "changed", G_CALLBACK (on_proxyhostentry_changed), pd); g_signal_connect (G_OBJECT (liferea_dialog_lookup (pd->priv->dialog, "proxyportentry")), "changed", G_CALLBACK (on_proxyportentry_changed), pd); g_signal_connect (G_OBJECT (liferea_dialog_lookup (pd->priv->dialog, "proxyusernameentry")), "changed", G_CALLBACK (on_proxyusernameentry_changed), pd); g_signal_connect (G_OBJECT (liferea_dialog_lookup (pd->priv->dialog, "proxypasswordentry")), "changed", G_CALLBACK (on_proxypasswordentry_changed), pd); /* ================= panel 6 "Enclosures" ======================== */ /* menu for download tool */ conf_get_int_value (DOWNLOAD_TOOL, &iSetting); ui_common_setup_combo_menu (liferea_dialog_lookup (pd->priv->dialog, "downloadToolCombo"), enclosure_download_tool_options, G_CALLBACK (on_enclosure_download_tool_changed), iSetting); /* set up list of configured enclosure types */ treestore = gtk_tree_store_new (FTS_LEN, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER); list = (GSList *)enclosure_mime_types_get (); while (list) { GtkTreeIter *newIter = g_new0 (GtkTreeIter, 1); gtk_tree_store_append (treestore, newIter, NULL); gtk_tree_store_set (treestore, newIter, FTS_TYPE, (NULL != ((encTypePtr)(list->data))->mime)?((encTypePtr)(list->data))->mime:((encTypePtr)(list->data))->extension, FTS_CMD, ((encTypePtr)(list->data))->cmd, FTS_PTR, list->data, -1); list = g_slist_next (list); } widget = liferea_dialog_lookup (pd->priv->dialog, "enc_action_view"); gtk_tree_view_set_model (GTK_TREE_VIEW (widget), GTK_TREE_MODEL (treestore)); column = gtk_tree_view_column_new_with_attributes (_("Type"), gtk_cell_renderer_text_new (), "text", FTS_TYPE, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (widget), column); gtk_tree_view_column_set_sort_column_id (column, FTS_TYPE); column = gtk_tree_view_column_new_with_attributes (_("Program"), gtk_cell_renderer_text_new (), "text", FTS_CMD, NULL); gtk_tree_view_column_set_sort_column_id (column, FTS_CMD); gtk_tree_view_append_column (GTK_TREE_VIEW(widget), column); gtk_tree_selection_set_mode (gtk_tree_view_get_selection (GTK_TREE_VIEW(widget)), GTK_SELECTION_SINGLE); /* ================= panel 7 "Plugins" ======================== */ pd->priv->plugins_box = liferea_dialog_lookup (pd->priv->dialog, "plugins_box"); g_assert (pd->priv->plugins_box != NULL); GtkWidget *alignment; alignment = gtk_alignment_new (0., 0., 1., 1.); gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 12, 12, 12, 12); widget = peas_gtk_plugin_manager_new (NULL); g_assert (widget != NULL); gtk_container_add (GTK_CONTAINER (alignment), widget); gtk_box_pack_start (GTK_BOX (pd->priv->plugins_box), alignment, TRUE, TRUE, 0); g_signal_connect_object (pd->priv->dialog, "destroy", G_CALLBACK (preferences_dialog_destroy_cb), pd, 0); gtk_widget_show_all (pd->priv->dialog); gtk_window_present (GTK_WINDOW (pd->priv->dialog)); }
static void refresh_widget (NemoExtensionConfigWidget *widget) { if (widget->current_extensions != NULL) { g_list_free_full (widget->current_extensions, (GDestroyNotify) extension_proxy_free); widget->current_extensions = NULL; } nemo_config_base_widget_clear_list (NEMO_CONFIG_BASE_WIDGET (widget)); detect_extensions (widget); if (widget->current_extensions == NULL) { GtkWidget *empty_label = gtk_label_new (NULL); gchar *markup = NULL; markup = g_strdup_printf ("<i>%s</i>", _("No extensions found")); gtk_label_set_markup (GTK_LABEL (empty_label), markup); g_free (markup); GtkWidget *empty_row = gtk_list_box_row_new (); gtk_container_add (GTK_CONTAINER (empty_row), empty_label); gtk_widget_show_all (empty_row); gtk_container_add (GTK_CONTAINER (NEMO_CONFIG_BASE_WIDGET (widget)->listbox), empty_row); } else { GList *l; gchar **blacklist = g_settings_get_strv (widget->settings, BLACKLIST_KEY); for (l = widget->current_extensions; l != NULL; l=l->next) { ExtensionProxy *proxy = l->data; gboolean active = TRUE; gint i = 0; for (i = 0; i < g_strv_length (blacklist); i++) { if (g_strcmp0 (blacklist[i], proxy->name) == 0) { active = FALSE; break; } } GtkWidget *w; GtkWidget *box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); GtkWidget *button = gtk_check_button_new (); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), active); g_signal_connect (button, "toggled", G_CALLBACK (on_check_toggled), proxy); gtk_box_pack_start (GTK_BOX (box), button, FALSE, FALSE, 2); w = gtk_label_new (NULL); gchar *markup = NULL; if (proxy->display_name == NULL) markup = g_strdup_printf ("%s - <i>%s</i>", proxy->name, _("no information available")); else markup = g_strdup_printf ("%s - <i>%s</i>", proxy->display_name, proxy->desc); gtk_label_set_markup (GTK_LABEL (w), markup); g_free (markup); gtk_box_pack_start (GTK_BOX (box), w, FALSE, FALSE, 2); GtkWidget *row = gtk_list_box_row_new (); gtk_container_add (GTK_CONTAINER (row), box); gtk_widget_show_all (row); gtk_container_add (GTK_CONTAINER (NEMO_CONFIG_BASE_WIDGET (widget)->listbox), row); } g_strfreev (blacklist); } update_restart_visiblity (widget); nemo_config_base_widget_set_default_buttons_sensitive (NEMO_CONFIG_BASE_WIDGET (widget), widget->current_extensions != NULL); }
void gui_init(dt_lib_module_t *self) { unsigned int i; GtkWidget *container = gtk_vbox_new(FALSE, 5); GtkWidget *output_row = gtk_hbox_new(FALSE, 2); GtkWidget *output_options = gtk_vbox_new(FALSE, 5); GtkWidget *picker_subrow = gtk_hbox_new(FALSE, 2); GtkWidget *restrict_button; GtkWidget *samples_label = dtgtk_label_new(_("live samples"), DARKTABLE_LABEL_TAB | DARKTABLE_LABEL_ALIGN_RIGHT); GtkWidget *samples_options_row = gtk_hbox_new(FALSE, 2); // Initializing self data structure dt_lib_colorpicker_t *data = (dt_lib_colorpicker_t*)malloc(sizeof(dt_lib_colorpicker_t)); self->data = (void*)data; memset(data, 0, sizeof(dt_lib_colorpicker_t)); // Initializing proxy functions and data darktable.lib->proxy.colorpicker.module = self; darktable.lib->proxy.colorpicker.size = dt_conf_get_int("ui_last/colorpicker_size"); darktable.lib->proxy.colorpicker.display_samples = dt_conf_get_int("ui_last/colorpicker_display_samples"); darktable.lib->proxy.colorpicker.live_samples = NULL; darktable.lib->proxy.colorpicker.picked_color_rgb_mean = (uint8_t*)malloc(sizeof(uint8_t) * 3); darktable.lib->proxy.colorpicker.picked_color_rgb_min = (uint8_t*)malloc(sizeof(uint8_t) * 3); darktable.lib->proxy.colorpicker.picked_color_rgb_max = (uint8_t*)malloc(sizeof(uint8_t) * 3); darktable.lib->proxy.colorpicker.picked_color_lab_mean = (float*)malloc(sizeof(float) * 3); darktable.lib->proxy.colorpicker.picked_color_lab_min = (float*)malloc(sizeof(float) * 3); darktable.lib->proxy.colorpicker.picked_color_lab_max = (float*)malloc(sizeof(float) * 3); for(i = 0; i < 3; i++) darktable.lib->proxy.colorpicker.picked_color_rgb_mean[i] = darktable.lib->proxy.colorpicker.picked_color_rgb_min[i] = darktable.lib->proxy.colorpicker.picked_color_rgb_max[i] = 0; for(i = 0; i < 3; i++) darktable.lib->proxy.colorpicker.picked_color_lab_mean[i] = darktable.lib->proxy.colorpicker.picked_color_lab_min[i] = darktable.lib->proxy.colorpicker.picked_color_lab_max[i] = 0; darktable.lib->proxy.colorpicker.update_panel = _update_picker_output; darktable.lib->proxy.colorpicker.update_samples = _update_samples_output; darktable.lib->proxy.colorpicker.set_sample_area = _set_sample_area; darktable.lib->proxy.colorpicker.set_sample_point = _set_sample_point; // Setting up the GUI self->widget = container; gtk_box_pack_start(GTK_BOX(container), output_row, TRUE, TRUE, 0); // The output button data->output_button = dtgtk_button_new(NULL, CPF_STYLE_BOX); gtk_widget_set_size_request(data->output_button, 100, 100); gtk_widget_set_sensitive(data->output_button, FALSE); gtk_box_pack_start(GTK_BOX(output_row), data->output_button, FALSE, FALSE, 0); // The picker button, output selectors and label gtk_box_pack_start(GTK_BOX(output_row), output_options, TRUE, TRUE, 0); data->size_selector = gtk_combo_box_text_new(); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(data->size_selector), _("point")); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(data->size_selector), _("area")); gtk_combo_box_set_active(GTK_COMBO_BOX(data->size_selector), dt_conf_get_int("ui_last/colorpicker_size")); gtk_widget_set_size_request(data->size_selector, 30, -1); gtk_box_pack_start(GTK_BOX(picker_subrow), data->size_selector, TRUE, TRUE, 0); g_signal_connect(G_OBJECT(data->size_selector), "changed", G_CALLBACK(_size_changed), (gpointer)self); data->picker_button = dtgtk_togglebutton_new(dtgtk_cairo_paint_colorpicker, CPF_STYLE_BOX); gtk_widget_set_size_request(data->picker_button, 50, -1); gtk_box_pack_start(GTK_BOX(picker_subrow), data->picker_button, FALSE, FALSE, 0); g_signal_connect(G_OBJECT(data->picker_button), "toggled", G_CALLBACK(_picker_button_toggled), self); gtk_box_pack_start(GTK_BOX(output_options), picker_subrow, TRUE, TRUE, 0); data->statistic_selector = gtk_combo_box_text_new(); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(data->statistic_selector), _("mean")); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(data->statistic_selector), _("min")); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(data->statistic_selector), _("max")); gtk_combo_box_set_active(GTK_COMBO_BOX(data->statistic_selector), dt_conf_get_int("ui_last/colorpicker_mode")); gtk_widget_set_sensitive(data->statistic_selector, dt_conf_get_int("ui_last/colorpicker_size")); gtk_box_pack_start(GTK_BOX(output_options), data->statistic_selector, TRUE, TRUE, 0); g_signal_connect(G_OBJECT(data->statistic_selector), "changed", G_CALLBACK(_statistic_changed), self); data->color_mode_selector = gtk_combo_box_text_new(); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(data->color_mode_selector), _("RGB")); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(data->color_mode_selector), _("Lab")); gtk_combo_box_set_active(GTK_COMBO_BOX(data->color_mode_selector), dt_conf_get_int("ui_last/colorpicker_model")); gtk_box_pack_start(GTK_BOX(output_options), data->color_mode_selector, TRUE, TRUE, 0); g_signal_connect(G_OBJECT(data->color_mode_selector), "changed", G_CALLBACK(_color_mode_changed), self); data->output_label = gtk_label_new(""); gtk_label_set_justify(GTK_LABEL(data->output_label), GTK_JUSTIFY_CENTER); gtk_widget_set_size_request(data->output_label, 80, -1); gtk_box_pack_start(GTK_BOX(output_options), data->output_label, FALSE, FALSE, 0); restrict_button = gtk_check_button_new_with_label( _("restrict histogram to selection")); gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(restrict_button), dt_conf_get_int("ui_last/colorpicker_restrict_histogram")); darktable.lib->proxy.colorpicker.restrict_histogram = dt_conf_get_int("ui_last/colorpicker_restrict_histogram"); gtk_box_pack_start(GTK_BOX(container), restrict_button, TRUE, TRUE, 0); g_signal_connect(G_OBJECT(restrict_button), "toggled", G_CALLBACK(_restrict_histogram_changed), NULL); // Adding the live samples section gtk_box_pack_start(GTK_BOX(container), samples_label, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(container), samples_options_row, TRUE, TRUE, 0); data->samples_statistic_selector = gtk_combo_box_text_new(); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(data->samples_statistic_selector), _("mean")); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(data->samples_statistic_selector), _("min")); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(data->samples_statistic_selector), _("max")); gtk_combo_box_set_active(GTK_COMBO_BOX(data->samples_statistic_selector), dt_conf_get_int("ui_last/colorsamples_mode")); gtk_box_pack_start(GTK_BOX(samples_options_row), data->samples_statistic_selector, TRUE, TRUE, 0); g_signal_connect(G_OBJECT(data->samples_statistic_selector), "changed", G_CALLBACK(_samples_statistic_changed), self); data->samples_mode_selector = gtk_combo_box_text_new(); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(data->samples_mode_selector), _("RGB")); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(data->samples_mode_selector), _("Lab")); gtk_combo_box_set_active(GTK_COMBO_BOX(data->samples_mode_selector), dt_conf_get_int("ui_last/colorsamples_model")); gtk_box_pack_start(GTK_BOX(samples_options_row), data->samples_mode_selector, TRUE, TRUE, 0); g_signal_connect(G_OBJECT(data->samples_mode_selector), "changed", G_CALLBACK(_samples_mode_changed), self); data->add_sample_button = gtk_button_new_from_stock(GTK_STOCK_ADD); gtk_widget_set_sensitive(data->add_sample_button, FALSE); gtk_box_pack_start(GTK_BOX(samples_options_row), data->add_sample_button, FALSE, FALSE, 0); g_signal_connect(G_OBJECT(data->add_sample_button), "clicked", G_CALLBACK(_add_sample), self); data->samples_container = gtk_vbox_new(FALSE, 2); gtk_box_pack_start(GTK_BOX(container), data->samples_container, TRUE, TRUE, 0); data->display_samples_check_box = gtk_check_button_new_with_label(_("display sample areas on image")); gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(data->display_samples_check_box), dt_conf_get_int("ui_last/colorpicker_display_samples")); gtk_box_pack_start(GTK_BOX(container), data->display_samples_check_box, TRUE, TRUE, 0); g_signal_connect(G_OBJECT(data->display_samples_check_box), "toggled", G_CALLBACK(_display_samples_changed), NULL); }
static void hide_items_cb (GtkToggleButton *togglebutton, GUI *appGUI) { if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (appGUI->opt->ct_hide_items_checkbutton))) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (appGUI->opt->ct_delete_items_checkbutton), FALSE); }
static void eog_preferences_dialog_init (EogPreferencesDialog *pref_dlg) { EogPreferencesDialogPrivate *priv; GtkAdjustment *scale_adjustment; pref_dlg->priv = eog_preferences_dialog_get_instance_private (pref_dlg); priv = pref_dlg->priv; gtk_widget_init_template (GTK_WIDGET (pref_dlg)); priv->view_settings = g_settings_new (EOG_CONF_VIEW); priv->fullscreen_settings = g_settings_new (EOG_CONF_FULLSCREEN); g_signal_connect (G_OBJECT (pref_dlg), "response", G_CALLBACK (eog_preferences_response_cb), pref_dlg); g_settings_bind (priv->view_settings, EOG_CONF_VIEW_INTERPOLATE, priv->interpolate_check, "active", G_SETTINGS_BIND_DEFAULT); g_settings_bind (priv->view_settings, EOG_CONF_VIEW_EXTRAPOLATE, priv->extrapolate_check, "active", G_SETTINGS_BIND_DEFAULT); g_settings_bind (priv->view_settings, EOG_CONF_VIEW_AUTOROTATE, priv->autorotate_check, "active", G_SETTINGS_BIND_DEFAULT); g_settings_bind (priv->view_settings, EOG_CONF_VIEW_USE_BG_COLOR, priv->bg_color_check, "active", G_SETTINGS_BIND_DEFAULT); g_settings_bind_with_mapping (priv->view_settings, EOG_CONF_VIEW_BACKGROUND_COLOR, priv->bg_color_button, "rgba", G_SETTINGS_BIND_DEFAULT, pd_string_to_rgba_mapping, pd_rgba_to_string_mapping, NULL, NULL); g_object_set_data (G_OBJECT (priv->color_radio), GCONF_OBJECT_VALUE, GINT_TO_POINTER (EOG_TRANSP_COLOR)); g_signal_connect (G_OBJECT (priv->color_radio), "toggled", G_CALLBACK (pd_transp_radio_toggle_cb), priv->view_settings); g_object_set_data (G_OBJECT (priv->checkpattern_radio), GCONF_OBJECT_VALUE, GINT_TO_POINTER (EOG_TRANSP_CHECKED)); g_signal_connect (G_OBJECT (priv->checkpattern_radio), "toggled", G_CALLBACK (pd_transp_radio_toggle_cb), priv->view_settings); g_object_set_data (G_OBJECT (priv->background_radio), GCONF_OBJECT_VALUE, GINT_TO_POINTER (EOG_TRANSP_BACKGROUND)); g_signal_connect (G_OBJECT (priv->background_radio), "toggled", G_CALLBACK (pd_transp_radio_toggle_cb), priv->view_settings); g_signal_connect (G_OBJECT (priv->seconds_scale), "format-value", G_CALLBACK (pd_seconds_scale_format_value_cb), NULL); switch (g_settings_get_enum (priv->view_settings, EOG_CONF_VIEW_TRANSPARENCY)) { case EOG_TRANSP_COLOR: gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->color_radio), TRUE); break; case EOG_TRANSP_CHECKED: gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->checkpattern_radio), TRUE); break; default: // Log a warning and use EOG_TRANSP_BACKGROUND as fallback g_warn_if_reached(); case EOG_TRANSP_BACKGROUND: gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->background_radio), TRUE); break; } g_settings_bind_with_mapping (priv->view_settings, EOG_CONF_VIEW_TRANS_COLOR, priv->transp_color_button, "rgba", G_SETTINGS_BIND_DEFAULT, pd_string_to_rgba_mapping, pd_rgba_to_string_mapping, NULL, NULL); g_settings_bind (priv->fullscreen_settings, EOG_CONF_FULLSCREEN_UPSCALE, priv->upscale_check, "active", G_SETTINGS_BIND_DEFAULT); g_settings_bind (priv->fullscreen_settings, EOG_CONF_FULLSCREEN_LOOP, priv->loop_check, "active", G_SETTINGS_BIND_DEFAULT); scale_adjustment = gtk_range_get_adjustment (GTK_RANGE (priv->seconds_scale)); g_settings_bind (priv->fullscreen_settings, EOG_CONF_FULLSCREEN_SECONDS, scale_adjustment, "value", G_SETTINGS_BIND_DEFAULT); gtk_widget_show_all (priv->plugin_manager); }
void search_open (session * sess) { GtkWidget *win, *hbox, *vbox, *entry, *wid; gchar *text; if (searchwin) { gtk_widget_destroy (searchwin); searchwin = NULL; } win = mg_create_generic_tab ("search", _(DISPLAY_NAME": Search"), TRUE, FALSE, search_cleanup_cb, NULL, 0, 0, &vbox, 0); gtk_container_set_border_width (GTK_CONTAINER (win), 12); gtk_box_set_spacing (GTK_BOX (vbox), 4); /* First line: _____________________ _Find */ hbox = gtk_hbox_new (0, 10); gtk_container_add (GTK_CONTAINER (vbox), hbox); gtk_widget_show (hbox); entry = gtk_entry_new (); text = GTK_XTEXT (sess->gui->xtext)->buffer->search_text; if (text) { gtk_entry_set_text (GTK_ENTRY (entry), text); gtk_editable_select_region (GTK_EDITABLE (entry), 0, -1); } g_signal_connect (G_OBJECT (entry), "activate", G_CALLBACK (search_entry_cb), sess); gtk_container_add (GTK_CONTAINER (hbox), entry); gtk_widget_show (entry); gtk_widget_grab_focus (entry); wid = gtk_hbutton_box_new (); gtk_container_add (GTK_CONTAINER (hbox), wid); gtk_widget_show (wid); wid = gtkutil_button (wid, GTK_STOCK_FIND, 0, search_find_cb, sess, _("_Find")); g_object_set_data (G_OBJECT (wid), "e", entry); /* Second line: X Match case */ wid = gtk_check_button_new_with_mnemonic (_("_Match case")); GTK_TOGGLE_BUTTON (wid)->active = prefs.text_search_case_match; g_signal_connect (G_OBJECT (wid), "toggled", G_CALLBACK (search_caseign_cb), sess); gtk_container_add (GTK_CONTAINER (vbox), wid); add_tip (wid, "Perform a case-sensitive search."); gtk_widget_show (wid); /* Third line: X Search backwards */ wid = gtk_check_button_new_with_mnemonic (_("Search _backwards")); GTK_TOGGLE_BUTTON (wid)->active = prefs.text_search_backward; g_signal_connect (G_OBJECT (wid), "toggled", G_CALLBACK (search_dirbwd_cb), sess); gtk_container_add (GTK_CONTAINER (vbox), wid); add_tip (wid, "Search from the newest text line to the oldest."); gtk_widget_show (wid); /* Fourth line: X Highlight all */ wid = gtk_check_button_new_with_mnemonic (_("_Highlight all")); GTK_TOGGLE_BUTTON (wid)->active = prefs.text_search_highlight_all; g_signal_connect (G_OBJECT (wid), "toggled", G_CALLBACK (search_highlight_cb), sess); gtk_container_add (GTK_CONTAINER (vbox), wid); add_tip (wid, "Highlight all occurrences, and underline the current occurrence."); gtk_widget_show (wid); /* Fifth line: X Regular expression */ wid = gtk_check_button_new_with_mnemonic (_("R_egular expression")); GTK_TOGGLE_BUTTON (wid)->active = prefs.text_search_regexp; g_signal_connect (G_OBJECT (wid), "toggled", G_CALLBACK (search_regexp_cb), sess); gtk_container_add (GTK_CONTAINER (vbox), wid); add_tip (wid, "Regard search string as a regular expression."); gtk_widget_show (wid); /* Sixth line: _Close Close and _Reset */ hbox = gtk_hbutton_box_new (); gtk_box_pack_start (GTK_BOX (vbox), hbox, 0, 0, 4); gtk_widget_show (hbox); wid = gtkutil_button (hbox, GTK_STOCK_CLOSE, 0, search_close_cb, win, _("_Close")); add_tip (wid, "Close this box, but continue searching new lines."); wid = gtkutil_button (hbox, "gtk-reset", 0, search_reset_cb, sess, _("Close and _Reset")); add_tip (wid, "Close this box, reset highlighted search items, and stop searching new lines."); /* Add recognition of the ESC key to close the box */ g_signal_connect (G_OBJECT (win), "key_press_event", G_CALLBACK (search_key_cb), win); /* That's all, folks */ searchwin = win; gtk_widget_show (win); }
void SettingsDialog::loadCheckbox(const char * name, gboolean value) { XOJ_CHECK_TYPE(SettingsDialog); GtkToggleButton * b = GTK_TOGGLE_BUTTON(get(name)); gtk_toggle_button_set_active(b, value); }
/** * vtable_dialog_get_replace_if_exists: */ gboolean vtable_dialog_get_replace_if_exists (VtableDialog *dlg) { g_return_val_if_fail (IS_VTABLE_DIALOG (dlg), FALSE); return gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (dlg->priv->tname_replace)); }
void esd_gtk_option_dialog() { GtkWidget *window, *label, *accept, *cancel; GtkWidget *on, *off; char *option; window = gtk_dialog_new(); accept = gtk_button_new_with_label(" Accept "); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(window)->action_area), accept, TRUE, TRUE, 0); cancel = gtk_button_new_with_label(" Cancel "); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(window)->action_area), cancel, TRUE, TRUE, 0); label = gtk_label_new(" ESD Record Mode: "); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(window)->vbox), label, TRUE, TRUE, 5); on = gtk_radio_button_new_with_label(NULL, "On"); off = gtk_radio_button_new_with_label(gtk_radio_button_group(GTK_RADIO_BUTTON(on)), "Off"); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(window)->vbox), on, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(window)->vbox), off, TRUE, TRUE, 0); option = datasrc->save_option(1); /* format will be "esdrecord=%d" */ if (option) temp_rec = option[10] - '0'; gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(on), temp_rec == 1); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(off), temp_rec == 0); gtk_signal_connect(GTK_OBJECT(on), "clicked", GTK_SIGNAL_FUNC(esdrecord), (gpointer) 1); gtk_signal_connect(GTK_OBJECT(off), "clicked", GTK_SIGNAL_FUNC(esdrecord), (gpointer) 0); gtk_signal_connect_object(GTK_OBJECT(window), "delete_event", GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT(window)); gtk_signal_connect(GTK_OBJECT(accept), "clicked", GTK_SIGNAL_FUNC(esd_save_values), NULL); gtk_signal_connect_object_after(GTK_OBJECT(accept), "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT(window)); gtk_signal_connect_object(GTK_OBJECT(cancel), "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT(window)); GTK_WIDGET_SET_FLAGS(cancel, GTK_CAN_DEFAULT); GTK_WIDGET_SET_FLAGS(accept, GTK_CAN_DEFAULT); gtk_widget_grab_default(accept); gtk_widget_show(on); gtk_widget_show(off); gtk_widget_show(accept); gtk_widget_show(cancel); gtk_widget_show(label); gtk_widget_show(window); }