/** * Format notebook format page. * \param pageNum Page (tab) number. * \param pageLbl Page (tab) label. */ static void export_html_page_format( gint pageNum, gchar *pageLbl ) { GtkWidget *vbox; GtkWidget *table; GtkWidget *label; GtkWidget *optmenuCSS; GtkWidget *optmenuName; GtkWidget *menu; GtkWidget *menuItem; GtkWidget *checkBanding; GtkWidget *checkLinkEMail; GtkWidget *checkAttributes; gint top; vbox = gtk_vbox_new(FALSE, 8); gtk_container_add( GTK_CONTAINER( exphtml_dlg.notebook ), vbox ); gtk_container_set_border_width( GTK_CONTAINER (vbox), BORDER_WIDTH ); label = gtk_label_new( pageLbl ); gtk_widget_show( label ); gtk_notebook_set_tab_label( GTK_NOTEBOOK( exphtml_dlg.notebook ), gtk_notebook_get_nth_page( GTK_NOTEBOOK( exphtml_dlg.notebook ), pageNum ), label ); table = gtk_table_new( 5, 3, FALSE ); gtk_box_pack_start(GTK_BOX(vbox), table, FALSE, FALSE, 0); gtk_container_set_border_width( GTK_CONTAINER(table), 8 ); gtk_table_set_row_spacings(GTK_TABLE(table), 8); gtk_table_set_col_spacings(GTK_TABLE(table), 8 ); /* First row */ top = 0; label = gtk_label_new( _( "Stylesheet" ) ); gtk_table_attach(GTK_TABLE(table), label, 0, 1, top, (top + 1), GTK_FILL, 0, 0, 0); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); menu = gtk_menu_new(); menuItem = gtk_menu_item_new_with_label( _( "None" ) ); gtk_object_set_user_data( GTK_OBJECT( menuItem ), GINT_TO_POINTER( EXPORT_HTML_ID_NONE ) ); gtk_menu_append( GTK_MENU(menu), menuItem ); gtk_widget_show( menuItem ); menuItem = gtk_menu_item_new_with_label( _( "Default" ) ); gtk_object_set_user_data( GTK_OBJECT( menuItem ), GINT_TO_POINTER( EXPORT_HTML_ID_DEFAULT ) ); gtk_menu_append( GTK_MENU(menu), menuItem ); gtk_widget_show( menuItem ); menuItem = gtk_menu_item_new_with_label( _( "Full" ) ); gtk_object_set_user_data( GTK_OBJECT( menuItem ), GINT_TO_POINTER( EXPORT_HTML_ID_FULL ) ); gtk_menu_append( GTK_MENU(menu), menuItem ); gtk_widget_show( menuItem ); menuItem = gtk_menu_item_new_with_label( _( "Custom" ) ); gtk_object_set_user_data( GTK_OBJECT( menuItem ), GINT_TO_POINTER( EXPORT_HTML_ID_CUSTOM ) ); gtk_menu_append( GTK_MENU(menu), menuItem ); gtk_widget_show( menuItem ); menuItem = gtk_menu_item_new_with_label( _( "Custom-2" ) ); gtk_object_set_user_data( GTK_OBJECT( menuItem ), GINT_TO_POINTER( EXPORT_HTML_ID_CUSTOM2 ) ); gtk_menu_append( GTK_MENU(menu), menuItem ); gtk_widget_show( menuItem ); menuItem = gtk_menu_item_new_with_label( _( "Custom-3" ) ); gtk_object_set_user_data( GTK_OBJECT( menuItem ), GINT_TO_POINTER( EXPORT_HTML_ID_CUSTOM3 ) ); gtk_menu_append( GTK_MENU(menu), menuItem ); gtk_widget_show( menuItem ); menuItem = gtk_menu_item_new_with_label( _( "Custom-4" ) ); gtk_object_set_user_data( GTK_OBJECT( menuItem ), GINT_TO_POINTER( EXPORT_HTML_ID_CUSTOM4 ) ); gtk_menu_append( GTK_MENU(menu), menuItem ); gtk_widget_show( menuItem ); optmenuCSS = gtk_option_menu_new(); gtk_option_menu_set_menu( GTK_OPTION_MENU( optmenuCSS ), menu ); gtk_table_attach(GTK_TABLE(table), optmenuCSS, 1, 2, top, (top + 1), GTK_FILL, 0, 0, 0); /* Second row */ top++; label = gtk_label_new( _( "Full Name Format" ) ); gtk_table_attach(GTK_TABLE(table), label, 0, 1, top, (top + 1), GTK_FILL, 0, 0, 0); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); menu = gtk_menu_new(); menuItem = gtk_menu_item_new_with_label( _( "First Name, Last Name" ) ); gtk_object_set_user_data( GTK_OBJECT( menuItem ), GINT_TO_POINTER( EXPORT_HTML_FIRST_LAST ) ); gtk_menu_append( GTK_MENU(menu), menuItem ); gtk_widget_show( menuItem ); menuItem = gtk_menu_item_new_with_label( _( "Last Name, First Name" ) ); gtk_object_set_user_data( GTK_OBJECT( menuItem ), GINT_TO_POINTER( EXPORT_HTML_LAST_FIRST ) ); gtk_menu_append( GTK_MENU(menu), menuItem ); gtk_widget_show( menuItem ); optmenuName = gtk_option_menu_new(); gtk_option_menu_set_menu( GTK_OPTION_MENU( optmenuName ), menu ); gtk_table_attach(GTK_TABLE(table), optmenuName, 1, 2, top, (top + 1), GTK_FILL, 0, 0, 0); /* Third row */ top++; checkBanding = gtk_check_button_new_with_label( _( "Color Banding" ) ); gtk_table_attach(GTK_TABLE(table), checkBanding, 1, 2, top, (top + 1), GTK_FILL, 0, 0, 0); /* Fourth row */ top++; checkLinkEMail = gtk_check_button_new_with_label( _( "Format E-Mail Links" ) ); gtk_table_attach(GTK_TABLE(table), checkLinkEMail, 1, 2, top, (top + 1), GTK_FILL, 0, 0, 0); /* Fifth row */ top++; checkAttributes = gtk_check_button_new_with_label( _( "Format User Attributes" ) ); gtk_table_attach(GTK_TABLE(table), checkAttributes, 1, 2, top, (top + 1), GTK_FILL, 0, 0, 0); gtk_widget_show_all(vbox); exphtml_dlg.optmenuCSS = optmenuCSS; exphtml_dlg.optmenuName = optmenuName; exphtml_dlg.checkBanding = checkBanding; exphtml_dlg.checkLinkEMail = checkLinkEMail; exphtml_dlg.checkAttributes = checkAttributes; }
config_dialog_t *create_event_config_dialog_content(event_config_t *event, GtkWidget *content) { if (content == NULL) content = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); //event_config_t *event = get_event_config(event_name); GtkWidget *option_table = gtk_grid_new(); gtk_grid_set_row_homogeneous(GTK_GRID(option_table), FALSE); gtk_grid_set_column_homogeneous(GTK_GRID(option_table), FALSE); gtk_grid_set_row_spacing(GTK_GRID(option_table), 2); g_object_set_data(G_OBJECT(option_table), "n-rows", (gpointer)-1); gtk_widget_set_hexpand(option_table, TRUE); gtk_widget_set_vexpand(option_table, TRUE); gtk_widget_set_halign(option_table, GTK_ALIGN_FILL); gtk_widget_set_valign(option_table, GTK_ALIGN_FILL); /* table to hold advanced options * hidden in expander which is visible only if there's at least * one advanced option */ GtkWidget *adv_option_table = gtk_grid_new(); gtk_grid_set_row_homogeneous(GTK_GRID(adv_option_table), FALSE); gtk_grid_set_column_homogeneous(GTK_GRID(adv_option_table), FALSE); gtk_grid_set_row_spacing(GTK_GRID(adv_option_table), 2); g_object_set_data(G_OBJECT(adv_option_table), "n-rows", (gpointer)-1); GtkWidget *adv_expander = gtk_expander_new(_("Advanced")); gtk_container_add(GTK_CONTAINER(adv_expander), adv_option_table); g_object_set_data(G_OBJECT(option_table), "advanced-options", adv_option_table); has_password_option = false; /* it's already stored in config_dialog_t from the previous call * we need to set it to null so we create a new list for the actual * event_config * note: say *NO* to the global variables! */ g_option_list = NULL; /* this fills the g_option_list, so we can use it for new_config_dialog */ g_list_foreach(event->options, &add_option_to_table, option_table); /* if there is at least one password option, add checkbox to disable storing passwords */ if (has_password_option) { unsigned last_row = add_one_row_to_grid(GTK_GRID(option_table)); GtkWidget *pass_store_cb = gtk_check_button_new_with_label(_("Don't store passwords")); gtk_grid_attach(GTK_GRID(option_table), pass_store_cb, /*left,top:*/ 0, last_row, /*width,height:*/ 1, 1); const char *store_passwords = get_user_setting("store_passwords"); if (store_passwords && !strcmp(store_passwords, "no")) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(pass_store_cb), 1); g_signal_connect(pass_store_cb, "toggled", G_CALLBACK(on_show_pass_store_cb), NULL); } gtk_box_pack_start(GTK_BOX(content), option_table, false, false, 20); /* add the adv_option_table to the dialog only if there is some adv option */ if (g_list_length(gtk_container_get_children(GTK_CONTAINER(adv_option_table))) > 0) gtk_box_pack_start(GTK_BOX(content), adv_expander, false, false, 0); /* add warning if secrets service is not available showing the nagging dialog * is considered "too heavy UI" be designers */ if (!is_event_config_user_storage_available()) { GtkWidget *keyring_warn_lbl = gtk_label_new( _("Secret Service is not available, your settings won't be saved!")); static const GdkColor red = { .red = 0xffff }; gtk_widget_modify_fg(keyring_warn_lbl, GTK_STATE_NORMAL, &red); gtk_box_pack_start(GTK_BOX(content), keyring_warn_lbl, false, false, 0); } gtk_widget_show_all(content); //make it all visible //g_option_list is filled on config_dialog_t *cdialog = new_config_dialog(NULL, g_option_list, (config_save_fun_t)save_data_from_event_dialog_name ); return cdialog; }
GtkWidget *create_appearance_widget() { if (appearance_widget != NULL) fprintf(stderr, "create_appearance_widget: appearance_widget was not NULL!\n"); load_settings(); GtkWidget *vbox_top = gtk_vbox_new (FALSE, 0); gtk_orientable_set_orientation(GTK_ORIENTABLE(vbox_top), GTK_ORIENTATION_VERTICAL); gtk_container_set_border_width (GTK_CONTAINER (vbox_top), 10); appearance_widget = vbox_top; GtkWidget *hbox_hime_font_size = gtk_hbox_new (FALSE, 10); gtk_box_pack_start (GTK_BOX (vbox_top), hbox_hime_font_size, FALSE, FALSE, 0); GtkWidget *label_hime_font_size = gtk_label_new(_("Main font")); gtk_box_pack_start (GTK_BOX (hbox_hime_font_size), label_hime_font_size, FALSE, FALSE, 0); char tt[128]; snprintf(tt, sizeof(tt), "%s %d", hime_font_name, hime_font_size); font_sel = gtk_font_button_new_with_font (tt); gtk_box_pack_start (GTK_BOX (hbox_hime_font_size), font_sel, FALSE, FALSE, 0); GtkWidget *hbox_hime_font_size_symbol = gtk_hbox_new (FALSE, 10); gtk_box_pack_start (GTK_BOX (vbox_top), hbox_hime_font_size_symbol, FALSE, FALSE, 0); GtkWidget *label_hime_font_size_symbol = gtk_label_new(_("Font size of symbols window")); gtk_box_pack_start (GTK_BOX (hbox_hime_font_size_symbol), label_hime_font_size_symbol, FALSE, FALSE, 0); GtkAdjustment *adj_hime_font_size_symbol = (GtkAdjustment *) gtk_adjustment_new (hime_font_size_symbol, 8.0, 32.0, 1.0, 1.0, 0.0); spinner_hime_font_size_symbol = gtk_spin_button_new (adj_hime_font_size_symbol, 0, 0); gtk_box_pack_start (GTK_BOX (hbox_hime_font_size_symbol), spinner_hime_font_size_symbol, FALSE, FALSE, 0); GtkWidget *hbox_hime_font_size_tsin_presel = gtk_hbox_new (FALSE, 10); gtk_box_pack_start (GTK_BOX (vbox_top), hbox_hime_font_size_tsin_presel, FALSE, FALSE, 0); GtkWidget *label_hime_font_size_tsin_presel = gtk_label_new(_("Font size of Tsin's and gtab's preselection window")); gtk_box_pack_start (GTK_BOX (hbox_hime_font_size_tsin_presel), label_hime_font_size_tsin_presel, FALSE, FALSE, 0); GtkAdjustment *adj_hime_font_size_tsin_presel = (GtkAdjustment *) gtk_adjustment_new (hime_font_size_tsin_presel, 8.0, 32.0, 1.0, 1.0, 0.0); spinner_hime_font_size_tsin_presel = gtk_spin_button_new (adj_hime_font_size_tsin_presel, 0, 0); gtk_box_pack_start (GTK_BOX (hbox_hime_font_size_tsin_presel), spinner_hime_font_size_tsin_presel, FALSE, FALSE, 0); GtkWidget *hbox_hime_font_size_tsin_pho_in = gtk_hbox_new (FALSE, 10); gtk_box_pack_start (GTK_BOX (vbox_top), hbox_hime_font_size_tsin_pho_in, FALSE, FALSE, 0); GtkWidget *label_hime_font_size_tsin_pho_in = gtk_label_new(_("Font size of keycodes for Bopomofo and Tsin")); gtk_box_pack_start (GTK_BOX (hbox_hime_font_size_tsin_pho_in), label_hime_font_size_tsin_pho_in, FALSE, FALSE, 0); GtkAdjustment *adj_hime_font_size_tsin_pho_in = (GtkAdjustment *) gtk_adjustment_new (hime_font_size_tsin_pho_in, 8.0, 32.0, 1.0, 1.0, 0.0); spinner_hime_font_size_tsin_pho_in = gtk_spin_button_new (adj_hime_font_size_tsin_pho_in, 0, 0); gtk_box_pack_start (GTK_BOX (hbox_hime_font_size_tsin_pho_in), spinner_hime_font_size_tsin_pho_in, FALSE, FALSE, 0); GtkWidget *hbox_hime_font_size_pho_near = gtk_hbox_new (FALSE, 10); gtk_box_pack_start (GTK_BOX (vbox_top), hbox_hime_font_size_pho_near, FALSE, FALSE, 0); GtkWidget *label_hime_font_size_pho_near = gtk_label_new(_("Font size of similar phonetic choices")); gtk_box_pack_start (GTK_BOX (hbox_hime_font_size_pho_near), label_hime_font_size_pho_near, FALSE, FALSE, 0); GtkAdjustment *adj_hime_font_size_pho_near = (GtkAdjustment *) gtk_adjustment_new (hime_font_size_pho_near, 8.0, 32.0, 1.0, 1.0, 0.0); spinner_hime_font_size_pho_near = gtk_spin_button_new (adj_hime_font_size_pho_near, 0, 0); gtk_box_pack_start (GTK_BOX (hbox_hime_font_size_pho_near), spinner_hime_font_size_pho_near, FALSE, FALSE, 0); GtkWidget *hbox_hime_font_size_gtab_in = gtk_hbox_new (FALSE, 10); gtk_box_pack_start (GTK_BOX (vbox_top), hbox_hime_font_size_gtab_in, FALSE, FALSE, 0); GtkWidget *label_hime_font_size_gtab_in = gtk_label_new(_("Font size of keycodes for gtab")); gtk_box_pack_start (GTK_BOX (hbox_hime_font_size_gtab_in), label_hime_font_size_gtab_in, FALSE, FALSE, 0); GtkAdjustment *adj_hime_font_size_gtab_in = (GtkAdjustment *) gtk_adjustment_new (hime_font_size_gtab_in, 8.0, 32.0, 1.0, 1.0, 0.0); spinner_hime_font_size_gtab_in = gtk_spin_button_new (adj_hime_font_size_gtab_in, 0, 0); gtk_box_pack_start (GTK_BOX (hbox_hime_font_size_gtab_in), spinner_hime_font_size_gtab_in, FALSE, FALSE, 0); GtkWidget *hbox_hime_font_size_win_kbm = gtk_hbox_new (FALSE, 10); gtk_box_pack_start (GTK_BOX (vbox_top), hbox_hime_font_size_win_kbm, FALSE, FALSE, 0); GtkWidget *label_hime_font_size_win_kbm = gtk_label_new(_("Font size of virtual keyboard")); gtk_box_pack_start (GTK_BOX (hbox_hime_font_size_win_kbm), label_hime_font_size_win_kbm, FALSE, FALSE, 0); GtkAdjustment *adj_hime_font_size_win_kbm = (GtkAdjustment *) gtk_adjustment_new (hime_font_size_win_kbm, 8.0, 32.0, 1.0, 1.0, 0.0); spinner_hime_font_size_win_kbm = gtk_spin_button_new (adj_hime_font_size_win_kbm, 0, 0); gtk_box_pack_start (GTK_BOX (hbox_hime_font_size_win_kbm), spinner_hime_font_size_win_kbm, FALSE, FALSE, 0); GtkWidget *label_hime_font_size_win_kbm_en = gtk_label_new(_("Alphabet-numeric")); gtk_box_pack_start (GTK_BOX (hbox_hime_font_size_win_kbm), label_hime_font_size_win_kbm_en, FALSE, FALSE, 0); GtkAdjustment *adj_hime_font_size_win_kbm_en = (GtkAdjustment *) gtk_adjustment_new (hime_font_size_win_kbm_en, 8.0, 32.0, 1.0, 1.0, 0.0); spinner_hime_font_size_win_kbm_en = gtk_spin_button_new (adj_hime_font_size_win_kbm_en, 0, 0); gtk_box_pack_start (GTK_BOX (hbox_hime_font_size_win_kbm), spinner_hime_font_size_win_kbm_en, FALSE, FALSE, 0); GtkWidget *hbox_hime_pop_up_win = gtk_hbox_new (FALSE, 10); gtk_box_pack_start (GTK_BOX(vbox_top), hbox_hime_pop_up_win, FALSE, FALSE, 0); check_button_hime_pop_up_win = gtk_check_button_new_with_label (_("Popup input window when typing")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_button_hime_pop_up_win), hime_pop_up_win); gtk_box_pack_start (GTK_BOX(hbox_hime_pop_up_win), check_button_hime_pop_up_win, FALSE, FALSE, 0); #if TRAY_ENABLED gtk_box_pack_start (GTK_BOX(vbox_top), create_hime_tray_display(), FALSE, FALSE, 0); check_button_hime_tray_hf_win_kbm = gtk_check_button_new_with_label (_("Toggle virtual keyboard by clicking shape tray")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_button_hime_tray_hf_win_kbm), hime_tray_hf_win_kbm); gtk_box_pack_start (GTK_BOX(vbox_top), check_button_hime_tray_hf_win_kbm, FALSE, FALSE, 0); #endif check_button_hime_show_win_kbm = gtk_check_button_new_with_label (_("Show virtual keyboard on initial")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_button_hime_show_win_kbm), hime_show_win_kbm); gtk_box_pack_start (GTK_BOX(vbox_top), check_button_hime_show_win_kbm, FALSE, FALSE, 0); GtkWidget *frame_root_style = gtk_frame_new(_("Fixed input window")); gtk_box_pack_start (GTK_BOX (vbox_top), frame_root_style, FALSE, FALSE, 0); gtk_container_set_border_width (GTK_CONTAINER (frame_root_style), 3); GtkWidget *vbox_root_style = gtk_vbox_new (FALSE, 10); gtk_orientable_set_orientation(GTK_ORIENTABLE(vbox_root_style), GTK_ORIENTATION_VERTICAL); gtk_container_add (GTK_CONTAINER (frame_root_style), vbox_root_style); GtkWidget *hbox_root_style_use = gtk_hbox_new (FALSE, 10); gtk_box_pack_start (GTK_BOX(vbox_root_style), hbox_root_style_use, FALSE, FALSE, 0); check_button_root_style_use = gtk_check_button_new_with_label (_("Enable")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_button_root_style_use), hime_input_style == InputStyleRoot); gtk_box_pack_start (GTK_BOX(hbox_root_style_use), check_button_root_style_use, FALSE, FALSE, 0); GtkWidget *label_fix_location = gtk_label_new(_("Fixed position:")); gtk_box_pack_start (GTK_BOX (hbox_root_style_use), label_fix_location, FALSE, FALSE, 0); GtkAdjustment *adj_root_style_x = (GtkAdjustment *) gtk_adjustment_new (hime_root_x, 0.0, 5120.0, 1.0, 1.0, 0.0); spinner_root_style_x = gtk_spin_button_new (adj_root_style_x, 0, 0); gtk_widget_set_hexpand (spinner_root_style_x, TRUE); gtk_box_pack_start (GTK_BOX(hbox_root_style_use), spinner_root_style_x, FALSE, FALSE, 0); GtkAdjustment *adj_root_style_y = (GtkAdjustment *) gtk_adjustment_new (hime_root_y, 0.0, 2880.0, 1.0, 1.0, 0.0); spinner_root_style_y = gtk_spin_button_new (adj_root_style_y, 0, 0); gtk_widget_set_hexpand (spinner_root_style_y, TRUE); gtk_box_pack_start (GTK_BOX(hbox_root_style_use), spinner_root_style_y, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX(vbox_top), create_hime_edit_display(), FALSE, FALSE, 0); GtkWidget *hbox_hime_inner_frame = gtk_hbox_new (FALSE, 10); gtk_box_pack_start (GTK_BOX(vbox_top), hbox_hime_inner_frame, FALSE, FALSE, 0); check_button_hime_inner_frame = gtk_check_button_new_with_label (_("Show frame of input window")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_button_hime_inner_frame), hime_inner_frame); gtk_box_pack_start (GTK_BOX(hbox_hime_inner_frame), check_button_hime_inner_frame, FALSE, FALSE, 0); #if 0 check_button_hime_setup_window_type_utility = gtk_check_button_new_with_label (_("Set setup windows as UTILITY")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_button_hime_setup_window_type_utility), hime_setup_window_type_utility); gtk_box_pack_start (GTK_BOX(vbox_top), check_button_hime_setup_window_type_utility, FALSE, FALSE, 0); #endif gtk_box_pack_start (GTK_BOX(vbox_top), create_hime_icon_dir_display(), FALSE, FALSE, 0); GtkWidget *frame_win_color = gtk_frame_new(_("Color selection")); gtk_box_pack_start (GTK_BOX (vbox_top), frame_win_color, FALSE, FALSE, 0); gtk_container_set_border_width (GTK_CONTAINER (frame_win_color), 1); GtkWidget *vbox_win_color = gtk_vbox_new (FALSE, 0); gtk_orientable_set_orientation(GTK_ORIENTABLE(vbox_win_color), GTK_ORIENTATION_VERTICAL); gtk_container_add (GTK_CONTAINER (frame_win_color), vbox_win_color); GtkWidget *hbox_win_color_use = gtk_hbox_new (FALSE, 10); gtk_box_pack_start (GTK_BOX(vbox_win_color), hbox_win_color_use, FALSE, FALSE, 0); check_button_hime_win_color_use = gtk_check_button_new_with_label (_("Custom theme color")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_button_hime_win_color_use), hime_win_color_use); g_signal_connect (G_OBJECT (check_button_hime_win_color_use), "clicked", G_CALLBACK (cb_hime_win_color_use), NULL); gtk_box_pack_start (GTK_BOX(hbox_win_color_use), check_button_hime_win_color_use, FALSE, FALSE, 0); event_box_win_color_test = gtk_event_box_new(); // this will make the color test failed // gtk_event_box_set_visible_window (GTK_EVENT_BOX(event_box_win_color_test), FALSE); gtk_box_pack_start (GTK_BOX(vbox_win_color), event_box_win_color_test, FALSE, FALSE, 0); label_win_color_test = gtk_label_new(NULL); gtk_container_add (GTK_CONTAINER(event_box_win_color_test), label_win_color_test); GtkWidget *hbox_win_color_fbg = gtk_hbox_new (FALSE, 10); gtk_box_pack_start (GTK_BOX(vbox_win_color), hbox_win_color_fbg, FALSE, FALSE, 0); GtkWidget *button_fg = gtk_button_new_with_label(_("Foreground color")); gtk_widget_set_hexpand (button_fg, TRUE); gtk_widget_set_halign (button_fg, GTK_ALIGN_FILL); gtk_box_pack_start (GTK_BOX(hbox_win_color_fbg), button_fg, TRUE, TRUE, 0); g_signal_connect (G_OBJECT (button_fg), "clicked", G_CALLBACK (cb_hime_win_color), &colorsel[0]); gdk_color_parse(hime_win_color_fg, &hime_win_gcolor_fg); // gtk_widget_modify_fg(label_win_color_test, GTK_STATE_NORMAL, &hime_win_gcolor_fg); gdk_color_parse(hime_win_color_bg, &hime_win_gcolor_bg); // gtk_widget_modify_bg(event_box_win_color_test, GTK_STATE_NORMAL, &hime_win_gcolor_bg); GtkWidget *button_bg = gtk_button_new_with_label(_("Background color")); gtk_widget_set_hexpand (button_bg, TRUE); gtk_widget_set_halign (button_bg, GTK_ALIGN_FILL); gtk_box_pack_start (GTK_BOX(hbox_win_color_fbg), button_bg, TRUE, TRUE, 0); g_signal_connect (G_OBJECT (button_bg), "clicked", G_CALLBACK (cb_hime_win_color), &colorsel[1]); GtkWidget *button_hime_sel_key_color = gtk_button_new_with_label(_("Color of selection key")); gtk_widget_set_hexpand (button_hime_sel_key_color, TRUE); gtk_widget_set_halign (button_hime_sel_key_color, GTK_ALIGN_FILL); g_signal_connect (G_OBJECT (button_hime_sel_key_color), "clicked", G_CALLBACK (cb_hime_win_color), &colorsel[2]); gdk_color_parse(hime_sel_key_color, &hime_sel_key_gcolor); gtk_box_pack_start (GTK_BOX(hbox_win_color_fbg), button_hime_sel_key_color, TRUE, TRUE, 0); GtkWidget *button_tsin_cursor_color = gtk_button_new_with_label(_("Cursor color")); gtk_widget_set_hexpand (button_tsin_cursor_color, TRUE); gtk_widget_set_halign (button_tsin_cursor_color, GTK_ALIGN_FILL); g_signal_connect (G_OBJECT (button_tsin_cursor_color), "clicked", G_CALLBACK (cb_hime_win_color), &colorsel[3]); gdk_color_parse(tsin_cursor_color, &tsin_cursor_gcolor); gtk_box_pack_start (GTK_BOX(hbox_win_color_fbg), button_tsin_cursor_color, TRUE, TRUE, 0); disp_win_sample(); return appearance_widget; }
void gui_init(dt_lib_module_t *self) { dt_lib_styles_t *d = (dt_lib_styles_t *)malloc(sizeof(dt_lib_styles_t)); self->data = (void *)d; d->edit_button = NULL; self->widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5); GtkWidget *w; GtkWidget *scrolled; /* list */ d->list = GTK_TREE_VIEW(gtk_tree_view_new()); gtk_tree_view_set_headers_visible(d->list, FALSE); GtkListStore *liststore = gtk_list_store_new(DT_STYLES_NUM_COLS, G_TYPE_STRING, G_TYPE_STRING); GtkTreeViewColumn *col = gtk_tree_view_column_new(); gtk_tree_view_append_column(GTK_TREE_VIEW(d->list), col); GtkCellRenderer *renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(col, renderer, TRUE); gtk_tree_view_column_add_attribute(col, renderer, "text", DT_STYLES_COL_NAME); gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(d->list)), GTK_SELECTION_SINGLE); gtk_tree_view_set_model(GTK_TREE_VIEW(d->list), GTK_TREE_MODEL(liststore)); g_object_unref(liststore); g_object_set(G_OBJECT(d->list), "tooltip-text", _("available styles,\ndoubleclick to apply"), (char *)NULL); g_signal_connect(d->list, "row-activated", G_CALLBACK(_styles_row_activated_callback), d); /* filter entry */ w = gtk_entry_new(); d->entry = GTK_ENTRY(w); g_object_set(G_OBJECT(w), "tooltip-text", _("enter style name"), (char *)NULL); g_signal_connect(d->entry, "changed", G_CALLBACK(entry_callback), d); g_signal_connect(d->entry, "activate", G_CALLBACK(entry_activated), d); dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(d->entry)); scrolled = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_min_content_height(GTK_SCROLLED_WINDOW(scrolled), DT_PIXEL_APPLY_DPI(150)); gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(d->entry), TRUE, FALSE, 0); gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(scrolled), TRUE, FALSE, 0); gtk_container_add(GTK_CONTAINER(scrolled), GTK_WIDGET(d->list)); d->duplicate = gtk_check_button_new_with_label(_("create duplicate")); gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(d->duplicate), TRUE, FALSE, 0); g_signal_connect(d->duplicate, "toggled", G_CALLBACK(duplicate_callback), d); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(d->duplicate), dt_conf_get_bool("ui_last/styles_create_duplicate")); g_object_set(d->duplicate, "tooltip-text", _("creates a duplicate of the image before applying style"), (char *)NULL); GtkWidget *hbox1 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5); GtkWidget *hbox2 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5); gtk_box_pack_start(GTK_BOX(self->widget), hbox1, TRUE, FALSE, 0); gtk_box_pack_start(GTK_BOX(self->widget), hbox2, TRUE, FALSE, 0); // create GtkWidget *cbutton = gtk_button_new_with_label(_("create")); g_signal_connect(G_OBJECT(cbutton), "clicked", G_CALLBACK(create_clicked), d); g_object_set(G_OBJECT(cbutton), "tooltip-text", _("create styles from history stack of selected images"), (char *)NULL); gtk_box_pack_start(GTK_BOX(hbox1), cbutton, TRUE, TRUE, 0); // edit GtkWidget *widget = gtk_button_new_with_label(_("edit")); d->edit_button = widget; g_signal_connect(widget, "clicked", G_CALLBACK(edit_clicked), d); g_object_set(widget, "tooltip-text", _("edit the selected style in list above"), (char *)NULL); gtk_box_pack_start(GTK_BOX(hbox1), widget, TRUE, TRUE, 0); // delete widget = gtk_button_new_with_label(_("delete")); d->delete_button = widget; g_signal_connect(widget, "clicked", G_CALLBACK(delete_clicked), d); g_object_set(widget, "tooltip-text", _("deletes the selected style in list above"), (char *)NULL); gtk_box_pack_start(GTK_BOX(hbox1), widget, TRUE, TRUE, 0); // import button GtkWidget *importButton = gtk_button_new_with_label(C_("styles", "import")); d->import_button = importButton; g_object_set(importButton, "tooltip-text", _("import style from a style file"), (char *)NULL); g_signal_connect(importButton, "clicked", G_CALLBACK(import_clicked), d); gtk_box_pack_start(GTK_BOX(hbox2), importButton, TRUE, TRUE, 0); // export button GtkWidget *exportButton = gtk_button_new_with_label(_("export")); d->export_button = exportButton; g_object_set(exportButton, "tooltip-text", _("export the selected style into a style file"), (char *)NULL); g_signal_connect(exportButton, "clicked", G_CALLBACK(export_clicked), d); gtk_box_pack_start(GTK_BOX(hbox2), exportButton, TRUE, TRUE, 0); // add entry completion GtkEntryCompletion *completion = gtk_entry_completion_new(); gtk_entry_completion_set_model(completion, gtk_tree_view_get_model(GTK_TREE_VIEW(d->list))); gtk_entry_completion_set_text_column(completion, 0); gtk_entry_completion_set_inline_completion(completion, TRUE); gtk_entry_set_completion(d->entry, completion); /* update filtered list */ _gui_styles_update_view(d); }
int main(int argc, char *argv[]) { printf("%s \nPlease report any bug to %s\n", PACKAGE_STRING, PACKAGE_BUGREPORT); //printf("number of arg = %d, argv = %s\n", argc, argv[1]); /*printf("argc = %d\n", argc); if (argv[1] != NULL) { if (strstr (argv[1],"debug") != NULL) { debug = TRUE; printf("debug = TRUE\n"); } } DEBUG("debug is true\n");*/ gchar *filename; int i = 0; gint initialWindowHeight = 170; guint timeoutEvent, intervalDisplaySpectro; GtkWidget *pVBox[4], *pHBox[13], *menuBar, *menu, *submenu, *menuItem, *submenuItem, *button, *frame, *image, *label, *widget; GdkColor color; Spectrum3dGui spectrum3dGui; GSList *radio_menu_group; GError **error; #if defined (GTKGLEXT3) || defined (GTKGLEXT1) GdkGLConfig *glconfig; #endif gst_init (NULL, NULL); gtk_init (&argc, &argv); get_saved_values(); intervalDisplaySpectro = (guint)spectrum3d.interval_display; #if defined (GTKGLEXT3) || defined (GTKGLEXT1) gtk_gl_init(NULL, NULL); glconfig = gdk_gl_config_new_by_mode (GDK_GL_MODE_RGB | GDK_GL_MODE_DEPTH | GDK_GL_MODE_DOUBLE); if (glconfig == NULL) { g_print ("\n*** Cannot find the double-buffered visual.\n"); g_print ("\n*** Trying single-buffered visual.\n"); /* Try single-buffered visual */ glconfig = gdk_gl_config_new_by_mode (GDK_GL_MODE_RGB | GDK_GL_MODE_DEPTH); if (glconfig == NULL) { g_print ("*** No appropriate OpenGL-capable visual found.\n"); exit (1); } } #endif initGstreamer(); init_audio_values(); init_display_values(&spectrum3dGui); spectrum3dGui.mainWindow = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_widget_set_size_request (spectrum3dGui.mainWindow, 700, initialWindowHeight); gtk_widget_realize(spectrum3dGui.mainWindow); gtk_window_set_title(GTK_WINDOW(spectrum3dGui.mainWindow), PACKAGE_NAME); filename = g_build_filename (G_DIR_SEPARATOR_S, DATADIR, "icons", "spectrum3d.png", NULL); gtk_window_set_icon(GTK_WINDOW(spectrum3dGui.mainWindow), gdk_pixbuf_new_from_file (filename, error)); g_signal_connect (G_OBJECT (spectrum3dGui.mainWindow), "destroy", G_CALLBACK (quit_spectrum3d), NULL); #ifdef GTK3 gtk_container_set_reallocate_redraws (GTK_CONTAINER (spectrum3dGui.mainWindow), TRUE); #endif #ifdef GTK3 for (i = 0; i < 4; i++) { pVBox[i] = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); } pHBox[0] = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0); for (i = 1; i < 12; i++) { pHBox[i] = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0); } pHBox[12] = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0); #elif defined GTK2 for (i = 0; i < 4; i++) { pVBox[i] = gtk_vbox_new(FALSE, 0); } pHBox[0] = gtk_hbox_new(TRUE, 0); for (i = 1; i < 12; i++) { pHBox[i] = gtk_hbox_new(FALSE, 0); } pHBox[12] = gtk_hbox_new(TRUE, 0); #endif gtk_container_add(GTK_CONTAINER(spectrum3dGui.mainWindow), pVBox[1]); gtk_box_pack_start(GTK_BOX(pVBox[1]), pHBox[0], FALSE, FALSE, 0); /* Menu */ menuBar = gtk_menu_bar_new(); menu = gtk_menu_new(); // 'Quit' submenu menuItem = gtk_menu_item_new_with_label("Quit"); gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuItem); g_signal_connect(G_OBJECT(menuItem), "activate", G_CALLBACK(gtk_main_quit), NULL); menuItem = gtk_menu_item_new_with_label("Quit"); gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuItem), menu); gtk_menu_shell_append(GTK_MENU_SHELL(menuBar), menuItem); menu = gtk_menu_new(); // 'Edit' submenu menuItem = gtk_menu_item_new_with_label("Preferences"); g_signal_connect(G_OBJECT(menuItem), "activate", G_CALLBACK(onPreferences), &spectrum3dGui); gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuItem); menuItem = gtk_menu_item_new_with_label("Edit"); gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuItem), menu); gtk_menu_shell_append(GTK_MENU_SHELL(menuBar), menuItem); menu = gtk_menu_new(); // 'Sound' submenu menuItem = gtk_menu_item_new_with_label("Sound"); gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuItem), menu); gtk_menu_shell_append(GTK_MENU_SHELL(menuBar), menuItem); submenu = gtk_menu_new();// 'Play test sound' sub-submenu spectrum3dGui.checkMenuTestSound = gtk_check_menu_item_new_with_label("Test Sound"); gtk_menu_shell_append(GTK_MENU_SHELL(menu), spectrum3dGui.checkMenuTestSound); g_signal_connect(G_OBJECT(spectrum3dGui.checkMenuTestSound), "activate", G_CALLBACK(menu_check_test_sound), &spectrum3dGui); menu = gtk_menu_new(); // 'View' submenu menuItem = gtk_menu_item_new_with_label("View"); gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuItem), menu); gtk_menu_shell_append(GTK_MENU_SHELL(menuBar), menuItem); submenu = gtk_menu_new();// 'viewType' sub-submenu menuItem = gtk_menu_item_new_with_label("Perspective"); gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuItem), submenu); gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuItem); spectrum3dGui.radio3D = gtk_radio_menu_item_new_with_label(NULL, "3D (D)"); radio_menu_group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(spectrum3dGui.radio3D)); g_signal_connect(G_OBJECT(spectrum3dGui.radio3D), "toggled", G_CALLBACK(change_perspective), spectrum3dGui.radio3D); gtk_menu_shell_append(GTK_MENU_SHELL(submenu), spectrum3dGui.radio3D); spectrum3dGui.radio3Dflat = gtk_radio_menu_item_new_with_label(radio_menu_group, "3D flat (F)"); radio_menu_group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(spectrum3dGui.radio3Dflat)); g_signal_connect(G_OBJECT(spectrum3dGui.radio3Dflat), "toggled", G_CALLBACK(change_perspective), spectrum3dGui.radio3Dflat); gtk_menu_shell_append(GTK_MENU_SHELL(submenu), spectrum3dGui.radio3Dflat); spectrum3dGui.radio2D = gtk_radio_menu_item_new_with_label(radio_menu_group, "2D (D)"); radio_menu_group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(spectrum3dGui.radio2D)); g_signal_connect(G_OBJECT(spectrum3dGui.radio2D), "toggled", G_CALLBACK(change_perspective), spectrum3dGui.radio2D); gtk_menu_shell_append(GTK_MENU_SHELL(submenu), spectrum3dGui.radio2D); submenu = gtk_menu_new();// 'Scale' sub-submenu menuItem = gtk_menu_item_new_with_label("Scale"); gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuItem), submenu); gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuItem); spectrum3dGui.checkMenuText = gtk_check_menu_item_new_with_label("Text (T)"); gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(spectrum3dGui.checkMenuText), TRUE); g_signal_connect(G_OBJECT(spectrum3dGui.checkMenuText), "activate", G_CALLBACK(check_menu_text), &spectrum3dGui); gtk_menu_shell_append(GTK_MENU_SHELL(submenu), spectrum3dGui.checkMenuText); spectrum3dGui.checkMenuLines = gtk_check_menu_item_new_with_label("Lines (L)"); gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(spectrum3dGui.checkMenuLines), TRUE); g_signal_connect(G_OBJECT(spectrum3dGui.checkMenuLines), "activate", G_CALLBACK(check_menu_lines), &spectrum3dGui); gtk_menu_shell_append(GTK_MENU_SHELL(submenu), spectrum3dGui.checkMenuLines); spectrum3dGui.checkMenuPointer = gtk_check_menu_item_new_with_label("Pointer (P)"); g_signal_connect(G_OBJECT(spectrum3dGui.checkMenuPointer), "activate", G_CALLBACK(check_menu_pointer), &spectrum3dGui); gtk_menu_shell_append(GTK_MENU_SHELL(submenu), spectrum3dGui.checkMenuPointer); submenu = gtk_menu_new();// 'Change/reset view' sub-submenu menuItem = gtk_menu_item_new_with_label("Change/reset view"); gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuItem), submenu); gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuItem); spectrum3dGui.reset = gtk_menu_item_new_with_label("Reset view (R)"); gtk_widget_set_tooltip_text (spectrum3dGui.reset, "Reset the view as if Spectrum3d was just started"); g_signal_connect(G_OBJECT(spectrum3dGui.reset), "activate", G_CALLBACK(reset_view), spectrum3dGui.reset); gtk_menu_shell_append(GTK_MENU_SHELL(submenu), spectrum3dGui.reset); spectrum3dGui.front = gtk_menu_item_new_with_label("Front view (O)"); gtk_widget_set_tooltip_text (spectrum3dGui.front, "2D view showing frequency versus intensity of the sound; shows a snapshot of the harmonics at a given time"); g_signal_connect(G_OBJECT(spectrum3dGui.front), "activate", G_CALLBACK(front_view), spectrum3dGui.front); gtk_menu_shell_append(GTK_MENU_SHELL(submenu), spectrum3dGui.front); submenuItem = gtk_menu_item_new_with_label("Preset view"); gtk_widget_set_tooltip_text (submenuItem, "Set the view with the chosen preset values"); g_signal_connect(G_OBJECT(submenuItem), "activate", G_CALLBACK(set_view_from_preset), submenuItem); gtk_menu_shell_append(GTK_MENU_SHELL(submenu), submenuItem); menu = gtk_menu_new(); // 'Help...' submenu menuItem = gtk_menu_item_new_with_label("Shortcuts"); g_signal_connect(G_OBJECT(menuItem), "activate", G_CALLBACK(onShortcuts), (GtkWidget*) spectrum3dGui.mainWindow); gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuItem); #ifdef HAVE_LIBGEIS menuItem = gtk_menu_item_new_with_label("Gestures Shortcuts"); g_signal_connect(G_OBJECT(menuItem), "activate", G_CALLBACK(onGesturesShortcuts), (GtkWidget*) spectrum3dGui.mainWindow); gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuItem); #endif menuItem = gtk_menu_item_new_with_label("About..."); g_signal_connect(G_OBJECT(menuItem), "activate", G_CALLBACK(onAbout), (GtkWidget*) spectrum3dGui.mainWindow); gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuItem); menuItem = gtk_menu_item_new_with_label("Quick start"); g_signal_connect(G_OBJECT(menuItem), "activate", G_CALLBACK(onQuickStart), (GtkWidget*) spectrum3dGui.mainWindow); gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuItem); menuItem = gtk_menu_item_new_with_label("Help"); gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuItem), menu); gtk_menu_shell_append(GTK_MENU_SHELL(menuBar), menuItem); gtk_box_pack_start(GTK_BOX(pHBox[0]), menuBar, FALSE, TRUE, 0); /* SourceButtons to set type of source (none, audio file, microphone) */ spectrum3dGui.stop = gtk_button_new(); filename = g_build_filename (G_DIR_SEPARATOR_S, DATADIR, "icons", "stop.png", NULL); image = gtk_image_new_from_file(filename); gtk_button_set_image(GTK_BUTTON(spectrum3dGui.stop),image); gdk_color_parse ("gold",&color); gtk_widget_set_name(spectrum3dGui.stop, "stop"); gtk_widget_modify_bg(GTK_WIDGET(spectrum3dGui.stop), GTK_STATE_NORMAL, &color); gtk_widget_modify_bg(GTK_WIDGET(spectrum3dGui.stop), GTK_STATE_PRELIGHT, &color); gtk_widget_set_tooltip_text (spectrum3dGui.stop, "Stop playing everything; no source of playing"); gtk_box_pack_start(GTK_BOX(pVBox[1]), pHBox[1], FALSE, TRUE, 2); gtk_box_pack_start(GTK_BOX(pHBox[1]), spectrum3dGui.stop, FALSE, TRUE, 2); g_signal_connect(G_OBJECT(spectrum3dGui.stop), "clicked", G_CALLBACK(change_source_button), &spectrum3dGui); filename = g_build_filename (G_DIR_SEPARATOR_S, DATADIR, "icons", "microphone_grey.png", NULL); image = gtk_image_new_from_file(filename); spectrum3dGui.mic = gtk_button_new(); gtk_button_set_image (GTK_BUTTON(spectrum3dGui.mic), image); gtk_widget_set_name(spectrum3dGui.mic, "mic"); gtk_widget_set_tooltip_text (spectrum3dGui.mic, "Source is microphone; select this to record something and then load it"); gtk_box_pack_start(GTK_BOX(pHBox[1]), spectrum3dGui.mic, FALSE, TRUE, 2); g_signal_connect(G_OBJECT(spectrum3dGui.mic), "clicked", G_CALLBACK(change_source_button), &spectrum3dGui); spectrum3dGui.file = gtk_button_new(); filename = g_build_filename (G_DIR_SEPARATOR_S, DATADIR, "icons", "file_grey.png", NULL); image = gtk_image_new_from_file(filename); gtk_button_set_image(GTK_BUTTON(spectrum3dGui.file),image); gtk_widget_set_name(spectrum3dGui.file, "file"); gtk_widget_set_tooltip_text (spectrum3dGui.file, "Source is an audio file"); gtk_box_pack_start(GTK_BOX(pHBox[1]), spectrum3dGui.file, FALSE, FALSE, 2); g_signal_connect(G_OBJECT(spectrum3dGui.file), "clicked", G_CALLBACK(change_source_button), &spectrum3dGui); spectrum3dGui.reload = gtk_button_new(); image = gtk_image_new_from_stock (GTK_STOCK_REFRESH, GTK_ICON_SIZE_LARGE_TOOLBAR); gtk_button_set_image(GTK_BUTTON(spectrum3dGui.reload),image); gtk_widget_set_sensitive (spectrum3dGui.reload, FALSE); gtk_widget_set_tooltip_text (spectrum3dGui.reload, "Reload audio file (usefull if some audio parameters like equalizer or filters have been changed)"); gtk_box_pack_start(GTK_BOX(pHBox[1]), spectrum3dGui.reload, FALSE, FALSE, 2); g_signal_connect(G_OBJECT(spectrum3dGui.reload), "clicked", G_CALLBACK(load_audio_file), NULL); widget = gtk_check_button_new_with_label("Analyse in\nrealtime"); gtk_widget_set_tooltip_text (GTK_WIDGET(widget), "If checked, harmonics will be analysed and displayed at the same time; if unchecked, harmonics will be analysed first, then displayed for the whole audio file, then it can be played afterwards"); gtk_box_pack_start(GTK_BOX(pHBox[1]), widget, FALSE, FALSE, 0); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(widget), TRUE); g_signal_connect(G_OBJECT(widget), "toggled", G_CALLBACK(set_analyse_in_rt), &spectrum3dGui); /* separator */ #ifdef GTK3 widget = gtk_separator_new(GTK_ORIENTATION_VERTICAL); #elif defined GTK2 widget = gtk_vseparator_new(); #endif gtk_box_pack_start(GTK_BOX(pHBox[1]), widget, FALSE, FALSE, 5); /* "Play/Pause" button */ playButton = gtk_button_new(); gtk_widget_set_tooltip_text (playButton, "Play/Pause the audio stream"); setPlayButtonIcon(); gtk_widget_set_size_request (playButton, 50, 20); gtk_box_pack_start(GTK_BOX(pHBox[1]), playButton, FALSE, FALSE, 2); g_signal_connect(G_OBJECT(playButton), "clicked", G_CALLBACK(playFromSource), "NO_MESSAGE"); /* "Stop" button */ button = gtk_button_new(); gtk_widget_set_tooltip_text (button, "Stop playing audio stream"); image = gtk_image_new_from_stock (GTK_STOCK_MEDIA_STOP, GTK_ICON_SIZE_SMALL_TOOLBAR); gtk_button_set_image(GTK_BUTTON(button),image); gtk_box_pack_start(GTK_BOX(pHBox[1]), button, FALSE, FALSE, 2); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(on_stop), NULL); /* "Record" button */ spectrum3dGui.record = gtk_button_new(); gtk_widget_set_tooltip_text (spectrum3dGui.record, "Record from microphone"); image = gtk_image_new_from_stock (GTK_STOCK_MEDIA_RECORD, GTK_ICON_SIZE_SMALL_TOOLBAR); gtk_button_set_image(GTK_BUTTON(spectrum3dGui.record),image); gtk_widget_set_sensitive (spectrum3dGui.record, FALSE); gtk_box_pack_start(GTK_BOX(pHBox[1]), spectrum3dGui.record, FALSE, FALSE, 2); g_signal_connect(G_OBJECT(spectrum3dGui.record), "clicked", G_CALLBACK(record_window), NULL); /* separator */ #ifdef GTK3 widget = gtk_separator_new(GTK_ORIENTATION_VERTICAL); #elif defined GTK2 widget = gtk_vseparator_new(); #endif gtk_box_pack_start(GTK_BOX(pHBox[1]), widget, FALSE, FALSE, 5); /* JACK check button */ filename = g_build_filename (G_DIR_SEPARATOR_S, DATADIR, "icons", "qjackctl.png", NULL); image = gtk_image_new_from_file(filename); widget = gtk_check_button_new (); gtk_button_set_image (GTK_BUTTON(widget), image); gtk_widget_set_tooltip_text (widget, "Use Jack-Audio-Connection-Kit (JACK)"); gtk_box_pack_start(GTK_BOX(pHBox[1]), widget, FALSE, FALSE, 2); g_signal_connect(G_OBJECT(widget), "toggled", G_CALLBACK(use_jack), &spectrum3dGui); /* separator */ #ifdef GTK3 widget = gtk_separator_new(GTK_ORIENTATION_VERTICAL); #elif defined GTK2 widget = gtk_vseparator_new(); #endif gtk_box_pack_start(GTK_BOX(pHBox[1]), widget, FALSE, FALSE, 5); /* Button to open the Filter and Equalizer window */ // create effectsWindow first without showing it effects_window(&spectrum3dGui); // then create a button that will call its display when clicked filename = g_build_filename (G_DIR_SEPARATOR_S, DATADIR, "icons", "equalizer.png", NULL); image = gtk_image_new_from_file(filename); widget = gtk_button_new(); gtk_button_set_image (GTK_BUTTON(widget), image); gtk_widget_set_tooltip_text (widget, "Show/Hide the filter and equalizer window"); gtk_box_pack_start(GTK_BOX(pHBox[1]), widget, FALSE, FALSE, 0); g_signal_connect(G_OBJECT(widget), "clicked", G_CALLBACK(show_effects_window), &spectrum3dGui); /* Time label */ label=gtk_label_new("Time : "); gtk_box_pack_start(GTK_BOX(pHBox[5]), label, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(pVBox[1]), pHBox[5], FALSE, FALSE, 2); /* Progress & seek scale */ #ifdef GTK3 scaleSeek = gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL, 0.0, 100.0, 1); #elif defined GTK2 scaleSeek = gtk_hscale_new_with_range (0.0, 100.0, 1); #endif gtk_scale_set_draw_value (GTK_SCALE (scaleSeek), FALSE); //gtk_scale_set_value_pos (GTK_SCALE (pScaleSeek), GTK_POS_TOP); gtk_range_set_value (GTK_RANGE (scaleSeek), 0); gtk_widget_set_size_request (scaleSeek, 500, 20); gtk_box_pack_start(GTK_BOX(pHBox[5]), scaleSeek, FALSE, FALSE, 0); g_signal_connect(G_OBJECT(scaleSeek), "value-changed", G_CALLBACK(on_seek), NULL); timeLabel=gtk_label_new(" 0:00 / 0:00 "); gtk_box_pack_start(GTK_BOX(pHBox[5]), timeLabel, FALSE, FALSE, 0); /* Create drawing area */ if (externalWindow == FALSE){ /* Resize spectrum3dGui.mainWindow to contain drawing_area; using gtk_window_set_defaut() allows to shrink the window (gtk_widget_set_size_request() does not allow to shrink the window below the requested size); */ gtk_window_set_default_size (GTK_WINDOW(spectrum3dGui.mainWindow), (gint)spectrum3d.width, initialWindowHeight + (gint)spectrum3d.height); //gtk_widget_realize(spectrum3dGui.mainWindow); spectrum3dGui.drawing_area = gtk_drawing_area_new (); #if defined (GTKGLEXT3) || defined (GTKGLEXT1) /* Set OpenGL-capability to the widget */ gtk_widget_set_gl_capability (spectrum3dGui.drawing_area, glconfig, NULL, TRUE, GDK_GL_RGBA_TYPE); #endif /* drawing_area has to be put in vBox AFTER the call to gtk_widget_set_gl_capability() (if GtkGlExt is used) and BEFORE the call to the sdl-gtk hack (if sdl is used)*/ gtk_box_pack_start (GTK_BOX (pVBox[1]), spectrum3dGui.drawing_area, TRUE, TRUE, 0); #ifdef HAVE_LIBSDL /* Hack to get SDL to use GTK window */ { char SDL_windowhack[32]; sprintf(SDL_windowhack,"SDL_WINDOWID=%ld", GDK_WINDOW_XID(gtk_widget_get_window(spectrum3dGui.drawing_area))); // GDK_WINDOW_XID( spectrum3dGui.drawing_area->window))); pour GTK2?? putenv(SDL_windowhack); printf("%s\n", SDL_windowhack); } if (SDL_Init(SDL_INIT_VIDEO) < 0) { fprintf(stderr, "Unable to init SDL: %s\n", SDL_GetError()); exit(1); } #endif g_signal_connect (spectrum3dGui.mainWindow, "key-press-event", G_CALLBACK (on_key_press), &spectrum3dGui); g_signal_connect (spectrum3dGui.mainWindow, "key-release-event", G_CALLBACK (on_key_release), &spectrum3dGui); g_signal_connect (spectrum3dGui.mainWindow, "motion-notify-event", G_CALLBACK (on_mouse_motion), NULL); g_signal_connect (spectrum3dGui.mainWindow, "scroll-event", G_CALLBACK (on_mouse_scroll), NULL); g_signal_connect (G_OBJECT (spectrum3dGui.drawing_area), "configure_event", G_CALLBACK (configure_event), NULL); gtk_widget_add_events (spectrum3dGui.mainWindow, gtk_widget_get_events (spectrum3dGui.mainWindow) | GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK | GDK_POINTER_MOTION_MASK | GDK_SCROLL_MASK); } else { create_external_window_drawing_area(&spectrum3dGui); } /* Starting value of the display */ frame = gtk_frame_new("Start value of display (in Hz)"); gtk_widget_set_tooltip_text (frame, "The lower displayed frequency (in herz)"); spectrum3dGui.adjustStart = gtk_adjustment_new(0, 0, 9000, ((gdouble)hzStep * (gdouble)zoomFactor), (((gdouble)hzStep * (gdouble)zoomFactor) * 10), 0); #ifdef GTK3 pScaleStart = gtk_scale_new(GTK_ORIENTATION_HORIZONTAL, GTK_ADJUSTMENT(spectrum3dGui.adjustStart)); #elif defined GTK2 pScaleStart = gtk_hscale_new(GTK_ADJUSTMENT(spectrum3dGui.adjustStart)); #endif gtk_scale_set_digits (GTK_SCALE(pScaleStart), 0); gtk_scale_set_value_pos(GTK_SCALE(pScaleStart), GTK_POS_RIGHT); gtk_box_pack_start(GTK_BOX(pVBox[1]), pHBox[11], FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(pHBox[11]), frame, FALSE, FALSE, 0); gtk_container_add(GTK_CONTAINER(frame), pScaleStart); g_signal_connect(G_OBJECT(pScaleStart), "value-changed", G_CALLBACK(change_start), &spectrum3dGui); g_signal_connect(G_OBJECT(pScaleStart), "format-value", G_CALLBACK(format_value_start), NULL); g_signal_connect(G_OBJECT(pScaleStart), "value-changed", G_CALLBACK(getTextDisplayLabel), &spectrum3dGui); /* Range of display */ frame = gtk_frame_new("Range of display (in Hz)"); gtk_widget_set_tooltip_text (frame, "The range of the displayed frequency (in herz)"); spectrum3dGui.adjustBands = gtk_adjustment_new(1000, 20, 1000, 10, 50, 0); #ifdef GTK3 spectrum3dGui.scaleBands = gtk_scale_new(GTK_ORIENTATION_HORIZONTAL, GTK_ADJUSTMENT(spectrum3dGui.adjustBands)); #elif defined GTK2 spectrum3dGui.scaleBands = gtk_hscale_new(GTK_ADJUSTMENT(spectrum3dGui.adjustBands)); #endif gtk_scale_set_digits (GTK_SCALE(spectrum3dGui.scaleBands), 0); gtk_scale_set_value_pos(GTK_SCALE(spectrum3dGui.scaleBands), GTK_POS_RIGHT); gtk_container_add(GTK_CONTAINER(frame), spectrum3dGui.scaleBands); gtk_box_pack_start(GTK_BOX(pHBox[11]), frame, FALSE, FALSE, 0); g_signal_connect(G_OBJECT(spectrum3dGui.scaleBands), "value-changed", G_CALLBACK(change_bands), &spectrum3dGui); g_signal_connect(G_OBJECT(spectrum3dGui.scaleBands), "format-value", G_CALLBACK(format_value_bands), NULL); g_signal_connect(G_OBJECT(spectrum3dGui.scaleBands), "value-changed", G_CALLBACK(getTextDisplayLabel), &spectrum3dGui); /* "x" label */ label=gtk_label_new("x"); gtk_container_add(GTK_CONTAINER(pHBox[11]), label); /* Factor that multiplies the range of display */ frame = gtk_frame_new(""); gtk_widget_set_tooltip_text (frame, "Factor that multiplies the frequency range, to make it larger"); spectrum3dGui.cbRange = gtk_combo_box_text_new(); gtk_container_add(GTK_CONTAINER(frame), spectrum3dGui.cbRange); gtk_box_pack_start(GTK_BOX(pHBox[11]), frame, FALSE, FALSE, 0); for (i = 1; i <= 20; i++){ gchar text[4]; sprintf(text, "%d", i); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(spectrum3dGui.cbRange), text); } gtk_combo_box_set_active(GTK_COMBO_BOX(spectrum3dGui.cbRange), 0); g_signal_connect( G_OBJECT(spectrum3dGui.cbRange), "changed", G_CALLBACK( cb_range_changed ), &spectrum3dGui ); g_signal_connect( G_OBJECT(spectrum3dGui.cbRange), "changed", G_CALLBACK(getTextDisplayLabel), &spectrum3dGui ); /* Label that shows starting value, ending value and range of display */ frame = gtk_frame_new("Values displayed"); gtk_widget_set_tooltip_text (frame, "The lower and the highest displayed value (in herz), and their range"); displayLabel=gtk_label_new(""); gtk_container_add(GTK_CONTAINER(frame), displayLabel); getTextDisplayLabel(NULL, &spectrum3dGui); gtk_box_pack_start(GTK_BOX(pHBox[11]), frame, FALSE, FALSE, 0); /* 'Gain' Gtk Scale */ frame = gtk_frame_new("Display Gain"); gtk_box_pack_start(GTK_BOX(pHBox[11]), frame, FALSE, FALSE, 10); filename = g_build_filename (G_DIR_SEPARATOR_S, DATADIR, "icons", "gain.png", NULL); image = gtk_image_new_from_file(filename); spectrum3dGui.scaleGain = gtk_scale_button_new (GTK_ICON_SIZE_LARGE_TOOLBAR, 0, 1, 0.01, NULL); gtk_button_set_image(GTK_BUTTON(spectrum3dGui.scaleGain),image); //gtk_button_set_label (GTK_BUTTON(spectrum3dGui.scaleGain), "GAIN"); gtk_container_add(GTK_CONTAINER(frame), spectrum3dGui.scaleGain); //gtk_box_pack_start(GTK_BOX(pHBox[11]), pScaleGain, FALSE, FALSE, 0); //gtk_widget_set_size_request (pScaleGain, 200, 20); //gtk_scale_set_value_pos(GTK_SCALE(pScaleGain), GTK_POS_RIGHT); gtk_widget_set_tooltip_text (spectrum3dGui.scaleGain, "Adjust the displayed level of the intensity of the sound"); gtk_scale_button_set_value(GTK_SCALE_BUTTON(spectrum3dGui.scaleGain), 0.2); // FIXME error message here with the previous line : gtk_image_set_from_stock: assertion `GTK_IS_IMAGE (image)' failed; it could be a bug in Gtk //g_object_set (pScaleGain, "update-policy", GTK_UPDATE_DISCONTINUOUS, NULL); g_signal_connect(G_OBJECT(spectrum3dGui.scaleGain), "value-changed", G_CALLBACK(change_gain), NULL); #ifdef HAVE_LIBGEIS setupGeis(); #endif gtk_widget_show_all (spectrum3dGui.mainWindow); //timeoutEvent = g_timeout_add (100, (GSourceFunc)sdl_event, &spectrum3dGui); spectrum3d.timeoutExpose = g_timeout_add (intervalDisplaySpectro, (GSourceFunc)display_spectro, &spectrum3dGui); printf("Showing Gtk GUI\n"); gtk_main (); /* Quit everything */ #ifdef HAVE_LIBGEIS geisQuit(); #endif on_stop(); g_source_remove(spectrum3d.timeoutExpose); #ifdef HAVE_LIBSDL //g_source_remove(timeoutEvent); SDL_Quit(); #endif print_rc_file(); printf("Quit everything\nGood Bye!\n"); return 0; }
void on_make_xml_clicked(GtkButton *clicked_button, gpointer user_data) { ASGtkImageDir *id = ASGTK_IMAGE_DIR(user_data); ASGtkMakeXMLDlg *mx = safecalloc( 1, sizeof( ASGtkMakeXMLDlg ) ); GtkWidget *frame, *box, *box2 ; Bool files_added = False; int response ; const char *name ; mx->entry = asgtk_image_dir_get_selection( id ); if( mx->entry == NULL ) { free( mx ); return; } mx->dlg = gtk_dialog_new_with_buttons( "Making new XML based on selected image", GTK_WINDOW(WallpaperState.main_window), GTK_DIALOG_MODAL|GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, NULL ); // g_signal_connect_swapped ( GTK_OBJECT (mx->dlg), "response", // G_CALLBACK (gtk_widget_destroy), GTK_OBJECT (mx->dlg)); gtk_container_set_border_width (GTK_CONTAINER (mx->dlg), 5); //gtk_widget_set_size_request (mx->dlg, 400, 300); mx->scale_check_box = gtk_check_button_new_with_label( "Scale image to screen size" ); gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(mx->scale_check_box), TRUE ); colorize_gtk_widget( mx->scale_check_box, get_colorschemed_style_normal() ); gtk_box_pack_start (GTK_BOX (GTK_DIALOG(mx->dlg)->vbox), mx->scale_check_box, FALSE, FALSE, 0); mx->color_check_box = gtk_check_button_new_with_label( "Adjust image color based on selected Color Scheme." ); gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(mx->color_check_box), TRUE ); //colorize_gtk_widget( mx->color_check_box, get_colorschemed_style_normal() ); //gtk_box_pack_start (GTK_BOX (GTK_DIALOG(mx->dlg)->vbox), mx->color_check_box, FALSE, FALSE, 0); g_signal_connect ((gpointer) mx->color_check_box, "clicked", G_CALLBACK (set_make_xml_widgets_sensitive), mx); frame = gtk_frame_new(NULL); gtk_box_pack_start (GTK_BOX (GTK_DIALOG(mx->dlg)->vbox), frame, FALSE, FALSE, 5); gtk_frame_set_label_widget( GTK_FRAME(frame), mx->color_check_box ); box = gtk_vbox_new( TRUE, 5 ); gtk_container_add (GTK_CONTAINER (frame), box); gtk_container_set_border_width (GTK_CONTAINER (box), 5); mx->tint_radio = gtk_radio_button_new_with_label( NULL, "Use Tinting (suitable for mostly grayscale images)" ); gtk_box_pack_start (GTK_BOX (box), mx->tint_radio, FALSE, FALSE, 0); mx->hsv_radio = gtk_radio_button_new_with_label_from_widget( GTK_RADIO_BUTTON(mx->tint_radio), "Use Hue rotation (suitable for colorfull images)" ); gtk_box_pack_start (GTK_BOX (box), mx->hsv_radio, FALSE, FALSE, 0); colorize_gtk_widget( frame, get_colorschemed_style_normal() ); gtk_widget_show_all (box); gtk_widget_show (box); mx->border_check_box = gtk_check_button_new_with_label( "Draw Border around the image" ); gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(mx->border_check_box), TRUE ); colorize_gtk_widget( mx->border_check_box, get_colorschemed_style_normal() ); g_signal_connect ((gpointer) mx->border_check_box, "clicked", G_CALLBACK (set_make_xml_widgets_sensitive), mx); frame = gtk_frame_new(NULL); gtk_box_pack_start (GTK_BOX (GTK_DIALOG(mx->dlg)->vbox), frame, FALSE, FALSE, 5); gtk_frame_set_label_widget( GTK_FRAME(frame), mx->border_check_box ); box = gtk_vbox_new( TRUE, 5 ); gtk_container_set_border_width (GTK_CONTAINER (box), 5); gtk_container_add (GTK_CONTAINER (frame), box); mx->solid_check_box = gtk_check_button_new_with_label( "Draw solid bevel" ); gtk_box_pack_start (GTK_BOX (box), mx->solid_check_box, FALSE, FALSE, 0); box2 = gtk_hbox_new( FALSE, 5 ); gtk_box_pack_start (GTK_BOX (box), box2, TRUE, TRUE, 0); mx->single_color_check_box = gtk_check_button_new_with_label( "Use single color" ); gtk_box_pack_start (GTK_BOX (box2), mx->single_color_check_box, FALSE, FALSE, 0); mx->outline_check_box = gtk_check_button_new_with_label( "Outline image" ); gtk_box_pack_start (GTK_BOX (box2), mx->outline_check_box, FALSE, FALSE, 0); ; gtk_widget_show_all (box2); box2 = gtk_hbox_new( FALSE, 5 ); gtk_box_pack_start (GTK_BOX (box), box2, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (box2), gtk_label_new("Border width : "), FALSE, FALSE, 0); mx->border_width = gtk_spin_button_new_with_range( 1.0, Scr.MyDisplayWidth/2, 1.0 ); gtk_box_pack_start (GTK_BOX (box2), mx->border_width, FALSE, FALSE, 0); gtk_widget_show_all (box2); colorize_gtk_widget( frame, get_colorschemed_style_normal() ); gtk_widget_show_all (box); gtk_widget_show (box); box2 = gtk_hbox_new( FALSE, 5 ); gtk_container_set_border_width (GTK_CONTAINER (box2), 5); gtk_box_pack_start (GTK_BOX (GTK_DIALOG(mx->dlg)->vbox), box2, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (box2), gtk_label_new("New Background name : "), FALSE, FALSE, 0); mx->back_name = gtk_entry_new(); gtk_box_pack_start (GTK_BOX (box2), mx->back_name, TRUE, TRUE, 0); gtk_widget_show_all (box2); gtk_widget_show_all (mx->dlg); do { response = gtk_dialog_run( GTK_DIALOG(mx->dlg) ); if( response == GTK_RESPONSE_ACCEPT ) { name = gtk_entry_get_text( GTK_ENTRY(mx->back_name) ); if( name == NULL || strlen(name) == 0 ) asgtk_warning2( WallpaperState.main_window, "Empty name specified for a new background.", NULL, NULL ); else break; } }while( response == GTK_RESPONSE_ACCEPT ); if( response == GTK_RESPONSE_ACCEPT ) { if( make_xml_from_image( mx, id ) ) { files_added = True ; make_minixml_from_image( mx, id ); } } if( files_added ) asgtk_info2( WallpaperState.main_window, "New background \"%s\" file created.", name, NULL ); make_xml_dlg_destroy( mx ); if( files_added ) asgtk_image_dir_refresh( id ); }
static void do_constructed (GObject *obj) { EmpathyAccountWidget *self = EMPATHY_ACCOUNT_WIDGET (obj); EmpathyAccountWidgetPriv *priv = GET_PRIV (self); TpAccount *account; const gchar *protocol, *cm_name; guint i = 0; struct { const gchar *cm_name; const gchar *protocol; const char *file; void (*func)(EmpathyAccountWidget *self, const gchar *filename); } widgets [] = { { "salut", "local-xmpp", "empathy-account-widget-local-xmpp.ui", account_widget_build_salut }, WIDGET (gabble, jabber), WIDGET (butterfly, msn), WIDGET (haze, icq), WIDGET (haze, aim), WIDGET (haze, yahoo), WIDGET (haze, groupwise), WIDGET (idle, irc), WIDGET (sofiasip, sip), }; cm_name = empathy_account_settings_get_cm (priv->settings); protocol = empathy_account_settings_get_protocol (priv->settings); for (i = 0 ; i < G_N_ELEMENTS (widgets); i++) { if (!tp_strdiff (widgets[i].cm_name, cm_name) && !tp_strdiff (widgets[i].protocol, protocol)) { gchar *filename; filename = empathy_file_lookup (widgets[i].file, "libempathy-gtk"); widgets[i].func (self, filename); g_free (filename); break; } } if (i == G_N_ELEMENTS (widgets)) { gchar *filename = empathy_file_lookup ( "empathy-account-widget-generic.ui", "libempathy-gtk"); account_widget_build_generic (self, filename); g_free (filename); } /* handle default focus */ if (self->ui_details->default_focus != NULL) { GObject *default_focus_entry; default_focus_entry = gtk_builder_get_object (self->ui_details->gui, self->ui_details->default_focus); g_signal_connect (default_focus_entry, "realize", G_CALLBACK (gtk_widget_grab_focus), NULL); } /* handle forget button */ if (self->ui_details->add_forget) { const gchar *password = NULL; priv->button_forget = GTK_WIDGET (gtk_builder_get_object (self->ui_details->gui, "button_forget")); priv->entry_password = GTK_WIDGET (gtk_builder_get_object (self->ui_details->gui, "entry_password")); password = empathy_account_settings_get_string (priv->settings, "password"); gtk_widget_set_sensitive (priv->button_forget, !EMP_STR_EMPTY (password)); g_signal_connect (priv->button_forget, "clicked", G_CALLBACK (account_widget_forget_clicked_cb), self); g_signal_connect (priv->entry_password, "changed", G_CALLBACK (account_widget_password_changed_cb), self); } /* handle apply and cancel button */ if (!priv->simple) { GtkWidget *hbox = gtk_hbox_new (TRUE, 3); priv->cancel_button = gtk_button_new_from_stock (GTK_STOCK_CANCEL); if (priv->creating_account) { TpConnectionPresenceType state; priv->idle = empathy_idle_dup_singleton (); empathy_signal_connect_weak (priv->idle, "notify::state", G_CALLBACK (idle_state_change_cb), obj); state = empathy_idle_get_state (priv->idle); if (state > TP_CONNECTION_PRESENCE_TYPE_OFFLINE) { /* We are online, display a Login button */ GtkWidget *image; priv->apply_button = gtk_button_new_with_mnemonic (_("L_og in")); image = gtk_image_new_from_stock (GTK_STOCK_CONNECT, GTK_ICON_SIZE_BUTTON); gtk_button_set_image (GTK_BUTTON (priv->apply_button), image); } else { /* We are offline, display a Save button */ priv->apply_button = gtk_button_new_from_stock (GTK_STOCK_SAVE); } } else { /* We are editing an existing account, display an Apply button */ priv->apply_button = gtk_button_new_from_stock (GTK_STOCK_APPLY); } gtk_box_pack_end (GTK_BOX (hbox), priv->apply_button, TRUE, TRUE, 3); gtk_box_pack_end (GTK_BOX (hbox), priv->cancel_button, TRUE, TRUE, 3); gtk_box_pack_end (GTK_BOX (self->ui_details->widget), hbox, FALSE, FALSE, 3); g_signal_connect (priv->cancel_button, "clicked", G_CALLBACK (account_widget_cancel_clicked_cb), self); g_signal_connect (priv->apply_button, "clicked", G_CALLBACK (account_widget_apply_clicked_cb), self); gtk_widget_show_all (hbox); if (priv->creating_account) /* When creating an account, the user might have nothing to enter. * That means that no control interaction might occur, * so we update the control button sensitivity manually. */ account_widget_handle_control_buttons_sensitivity (self); else account_widget_set_control_buttons_sensitivity (self, FALSE); } account = empathy_account_settings_get_account (priv->settings); if (account != NULL) { g_signal_connect (account, "notify::enabled", G_CALLBACK (empathy_account_widget_enabled_cb), self); } /* handle the "Enabled" checkbox. We only add it when modifying an account */ if (!priv->creating_account && priv->table_common_settings != NULL) { #ifdef HAVE_MOBLIN GtkWidget *w; #endif guint nb_rows, nb_columns; gboolean is_enabled; is_enabled = tp_account_is_enabled (account); #ifndef HAVE_MOBLIN priv->enabled_checkbox = gtk_check_button_new_with_label (_("Enabled")); gtk_toggle_button_set_active ( GTK_TOGGLE_BUTTON (priv->enabled_checkbox), is_enabled); #else /* Translators: this is used only when built on a moblin platform */ w = gtk_label_new (_("Account:")); gtk_misc_set_alignment (GTK_MISC (w), 0, 0.5); priv->enabled_checkbox = nbtk_gtk_light_switch_new (); nbtk_gtk_light_switch_set_active ( NBTK_GTK_LIGHT_SWITCH (priv->enabled_checkbox), is_enabled); gtk_widget_show (w); #endif /* HAVE_MOBLIN */ g_object_get (priv->table_common_settings, "n-rows", &nb_rows, "n-columns", &nb_columns, NULL); gtk_table_resize (GTK_TABLE (priv->table_common_settings), ++nb_rows, nb_columns); #ifndef HAVE_MOBLIN gtk_table_attach (GTK_TABLE (priv->table_common_settings), priv->enabled_checkbox, 0, nb_columns, nb_rows - 1, nb_rows, GTK_EXPAND | GTK_FILL, 0, 0, 0); #else gtk_table_attach (GTK_TABLE (priv->table_common_settings), w, 0, 1, nb_rows - 1, nb_rows, GTK_FILL, 0, 0, 0); gtk_table_attach (GTK_TABLE (priv->table_common_settings), priv->enabled_checkbox, 1, nb_columns, nb_rows - 1, nb_rows, GTK_EXPAND | GTK_FILL, 0, 0, 0); #endif /* HAVE_MOBLIN */ gtk_widget_show (priv->enabled_checkbox); #ifndef HAVE_MOBLIN g_signal_connect (G_OBJECT (priv->enabled_checkbox), "released", G_CALLBACK (account_widget_enabled_released_cb), self); #else g_signal_connect (G_OBJECT (priv->enabled_checkbox), "switch-flipped", G_CALLBACK (account_widget_switch_flipped_cb), self); #endif /* HAVE_MOBLIN */ } /* hook up to widget destruction to unref ourselves */ g_signal_connect (self->ui_details->widget, "destroy", G_CALLBACK (account_widget_destroy_cb), self); empathy_builder_unref_and_keep_widget (self->ui_details->gui, self->ui_details->widget); self->ui_details->gui = NULL; }
static void create_window (void) { GtkWidget *window; GtkWidget *hgrid; GtkWidget *panel_grid; GtkWidget *scrolled_window; GtkWidget *gsv_checkbutton; GtkWidget *tag_set_checkbutton; GtkWidget *tag_checkbutton; GtkSourceView *view; GtkSourceBuffer *buffer; GtkTextTag *tag; window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_default_size (GTK_WINDOW (window), 800, 600); g_signal_connect (window, "destroy", gtk_main_quit, NULL); hgrid = gtk_grid_new (); gtk_orientable_set_orientation (GTK_ORIENTABLE (hgrid), GTK_ORIENTATION_HORIZONTAL); view = GTK_SOURCE_VIEW (gtk_source_view_new ()); g_object_set (view, "expand", TRUE, NULL); gtk_text_view_set_monospace (GTK_TEXT_VIEW (view), TRUE); buffer = GTK_SOURCE_BUFFER (gtk_text_view_get_buffer (GTK_TEXT_VIEW (view))); tag = gtk_source_buffer_create_source_tag (buffer, NULL, "draw-spaces", FALSE, NULL); fill_buffer (GTK_TEXT_BUFFER (buffer), tag); gtk_source_view_set_draw_spaces (view, GTK_SOURCE_DRAW_SPACES_ALL); panel_grid = gtk_grid_new (); gtk_orientable_set_orientation (GTK_ORIENTABLE (panel_grid), GTK_ORIENTATION_VERTICAL); gtk_container_add (GTK_CONTAINER (hgrid), panel_grid); gtk_grid_set_row_spacing (GTK_GRID (panel_grid), 6); g_object_set (panel_grid, "margin", 6, NULL); gsv_checkbutton = gtk_check_button_new_with_label ("GtkSourceView draw-spaces"); gtk_container_add (GTK_CONTAINER (panel_grid), gsv_checkbutton); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (gsv_checkbutton), TRUE); g_signal_connect (gsv_checkbutton, "toggled", G_CALLBACK (gsv_checkbutton_toggled_cb), view); tag_set_checkbutton = gtk_check_button_new_with_label ("GtkSourceTag draw-spaces-set"); gtk_container_add (GTK_CONTAINER (panel_grid), tag_set_checkbutton); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (tag_set_checkbutton), TRUE); g_object_bind_property (tag_set_checkbutton, "active", tag, "draw-spaces-set", G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE); tag_checkbutton = gtk_check_button_new_with_label ("GtkSourceTag draw-spaces"); gtk_container_add (GTK_CONTAINER (panel_grid), tag_checkbutton); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (tag_checkbutton), FALSE); g_object_bind_property (tag_checkbutton, "active", tag, "draw-spaces", G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE); scrolled_window = gtk_scrolled_window_new (NULL, NULL); gtk_container_add (GTK_CONTAINER (scrolled_window), GTK_WIDGET (view)); gtk_container_add (GTK_CONTAINER (hgrid), scrolled_window); gtk_container_add (GTK_CONTAINER (window), hgrid); gtk_widget_show_all (window); }
void banlist_opengui (struct session *sess) { banlist_info *banl; int i; GtkWidget *table, *vbox, *bbox; char tbuf[256]; if (sess->type != SESS_CHANNEL || sess->channel[0] == 0) { fe_message (_("You can only open the Ban List window while in a channel tab."), FE_MSG_ERROR); return; } if (sess->res->banlist == NULL) { sess->res->banlist = g_new0 (banlist_info, 1); } banl = sess->res->banlist; if (banl->window) { mg_bring_tofront (banl->window); return; } /* New banlist for this session -- Initialize it */ banl->sess = sess; /* For each mode set its bit in capable/readable/writeable */ for (i = 0; i < MODE_CT; i++) modes[i].tester (banl, i); /* Force on the checkmark in the "Bans" box */ banl->checked = 1<<MODE_BAN; g_snprintf (tbuf, sizeof tbuf, _(DISPLAY_NAME": Ban List (%s)"), sess->server->servername); banl->window = mg_create_generic_tab ("BanList", tbuf, FALSE, TRUE, banlist_closegui, banl, 700, 300, &vbox, sess->server); gtkutil_destroy_on_esc (banl->window); gtk_container_set_border_width (GTK_CONTAINER (banl->window), 3); gtk_box_set_spacing (GTK_BOX (vbox), 3); /* create banlist view */ banl->treeview = banlist_treeview_new (vbox, banl); table = gtk_table_new (1, MODE_CT, FALSE); gtk_table_set_col_spacings (GTK_TABLE (table), 16); gtk_box_pack_start (GTK_BOX (vbox), table, 0, 0, 0); for (i = 0; i < MODE_CT; i++) { if (!(banl->capable & 1<<i)) continue; banl->checkboxes[i] = gtk_check_button_new_with_label (_(modes[i].name)); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (banl->checkboxes[i]), (banl->checked & 1<<i? TRUE: FALSE)); g_signal_connect (G_OBJECT (banl->checkboxes[i]), "toggled", G_CALLBACK (banlist_toggle), banl); gtk_table_attach (GTK_TABLE (table), banl->checkboxes[i], i+1, i+2, 0, 1, GTK_FILL, GTK_FILL, 0, 0); } bbox = gtk_hbutton_box_new (); gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), GTK_BUTTONBOX_SPREAD); gtk_container_set_border_width (GTK_CONTAINER (bbox), 5); gtk_box_pack_end (GTK_BOX (vbox), bbox, 0, 0, 0); gtk_widget_show (bbox); banl->but_remove = gtkutil_button (bbox, GTK_STOCK_REMOVE, 0, banlist_unban, banl, _("Remove")); banl->but_crop = gtkutil_button (bbox, GTK_STOCK_REMOVE, 0, banlist_crop, banl, _("Crop")); banl->but_clear = gtkutil_button (bbox, GTK_STOCK_CLEAR, 0, banlist_clear, banl, _("Clear")); banl->but_refresh = gtkutil_button (bbox, GTK_STOCK_REFRESH, 0, banlist_refresh, banl, _("Refresh")); banlist_do_refresh (banl); gtk_widget_show_all (banl->window); }
static void update_view(vx_gtk_buffer_manager_t * gtk) { // This order of these two mutex locks should prevent deadloc // even if a user sends op codes while the user holds the GDK mutex gdk_threads_enter(); pthread_mutex_lock(>k->mutex); // Clear XXX Double buffered? GList * children = gtk_container_get_children(GTK_CONTAINER(gtk->window)); for(GList * iter = children; iter != NULL; iter = g_list_next(iter)) gtk_widget_destroy(GTK_WIDGET(iter->data)); g_list_free(children); // Rebuild from scratch GtkWidget * box = gtk_vbox_new(0, 10); GtkWidget * widget = NULL; zarray_t *layers = zhash_values(gtk->layers); // contents: layer_info_t* zarray_sort(layers, layer_info_compare); for (int lidx = 0; lidx < zarray_size(layers); lidx++) { layer_info_t *linfo = NULL; zarray_get(layers, lidx, &linfo); // Draw the layer name: widget = gtk_label_new(""); char * text = sprintf_alloc("<b>Layer %d</b>", linfo->layer_id); gtk_label_set_markup(GTK_LABEL(widget), text); free(text); //gtk_container_add(GTK_CONTAINER(box), widget); gtk_box_pack_start(GTK_BOX(box), widget, FALSE, FALSE, 0); // Make a checkbox for each buffer zarray_t *buffers = zhash_values(linfo->buffers); // contents: buffer_info_t* zarray_sort(buffers, buffer_info_compare); for (int i = 0; i < zarray_size(buffers); i++) { buffer_info_t * buffer = NULL; zarray_get(buffers, i, &buffer); assert(buffer != NULL); widget = gtk_check_button_new_with_label(buffer->name); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget), buffer->enabled); g_signal_connect (G_OBJECT(widget), "toggled", G_CALLBACK (buffer_checkbox_changed), buffer); //gtk_container_add(GTK_CONTAINER(box), widget); gtk_box_pack_start(GTK_BOX(box), widget, FALSE, FALSE, 0); } zarray_destroy(buffers); } gtk_container_add(GTK_CONTAINER(gtk->window), box); gtk_widget_show_all(box); zarray_destroy(layers); pthread_mutex_unlock(>k->mutex); gdk_threads_leave(); }
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*)calloc(1, sizeof(dt_lib_colorpicker_t)); self->data = (void*)data; // 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, DT_PIXEL_APPLY_DPI(100), DT_PIXEL_APPLY_DPI(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, DT_PIXEL_APPLY_DPI(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, DT_PIXEL_APPLY_DPI(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, DT_PIXEL_APPLY_DPI(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_with_label(_("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); }
GtkWidget* ctk_gvo_sync_new(NvCtrlAttributeHandle *handle, GtkWidget *parent_window, CtkConfig *ctk_config, CtkEvent *ctk_event, CtkGvo *gvo_parent) { GObject *object; CtkGvoSync *ctk_gvo_sync; GtkWidget *frame; GtkWidget *hbox; GtkWidget *label; GtkWidget *alignment; GtkWidget *button; GtkWidget *table, *menu; gint val, i; NVCTRLAttributeValidValuesRec valid; ReturnStatus ret; gint row; const char *help_text; /* make sure we have a handle */ g_return_val_if_fail(handle != NULL, NULL); /* create and initialize the object */ object = g_object_new(CTK_TYPE_GVO_SYNC, NULL); ctk_gvo_sync = CTK_GVO_SYNC(object); ctk_gvo_sync->handle = handle; ctk_gvo_sync->parent_window = parent_window; ctk_gvo_sync->ctk_config = ctk_config; ctk_gvo_sync->ctk_event = ctk_event; ctk_gvo_sync->gvo_parent = gvo_parent; /* Query the current GVO state */ if ( !query_init_gvo_sync_state(ctk_gvo_sync) ) { // Free the object g_object_ref(object); gtk_object_sink(GTK_OBJECT(object)); g_object_unref(object); return NULL; } /* set container properties for the widget */ gtk_box_set_spacing(GTK_BOX(object), 10); /* banner */ hbox = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(object), hbox, FALSE, FALSE, 0); ctk_gvo_sync->banner_box = hbox; /* * Sync options */ frame = gtk_frame_new("Sync Options"); ctk_gvo_sync->frame = frame; gtk_box_pack_start(GTK_BOX(object), frame, FALSE, FALSE, 0); table = gtk_table_new(6, 2, FALSE); gtk_table_set_row_spacings(GTK_TABLE(table), 0); gtk_table_set_col_spacings(GTK_TABLE(table), 0); gtk_container_add(GTK_CONTAINER(frame), table); /* input video format */ label = gtk_label_new("Input Video Format: "); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); gtk_table_attach(GTK_TABLE(table), label, 0, 1, 0, 1, GTK_FILL, GTK_FILL, TABLE_PADDING, TABLE_PADDING); hbox = gtk_hbox_new(FALSE, 5); ctk_gvo_sync->input_video_format_text_entry = gtk_entry_new(); ctk_config_set_tooltip(ctk_config, ctk_gvo_sync->input_video_format_text_entry, __input_video_format_help); gtk_entry_set_width_chars (GTK_ENTRY(ctk_gvo_sync->input_video_format_text_entry), max_input_video_format_text_entry_length()); gtk_widget_set_sensitive(ctk_gvo_sync->input_video_format_text_entry, FALSE); update_input_video_format_text_entry(ctk_gvo_sync); gtk_box_pack_start(GTK_BOX(hbox), ctk_gvo_sync->input_video_format_text_entry, TRUE, TRUE, 0); /* Input video format detect button */ button = gtk_toggle_button_new_with_label("Detect"); alignment = gtk_alignment_new(1, 1, 0, 0); gtk_container_add(GTK_CONTAINER(alignment), button); ctk_gvo_sync->input_video_format_detect_button = button; ctk_config_set_tooltip(ctk_config, button, __input_video_format_detect_help); g_signal_connect(G_OBJECT(button), "toggled", G_CALLBACK(detect_input_toggled), ctk_gvo_sync); gtk_box_pack_start(GTK_BOX(hbox), alignment, FALSE, FALSE, 0); gtk_table_attach(GTK_TABLE(table), hbox, 1, 2, 0, 1, GTK_FILL | GTK_EXPAND, GTK_FILL, TABLE_PADDING, TABLE_PADDING); /* Composite Termination */ if (ctk_gvo_sync->caps & NV_CTRL_GVO_CAPABILITIES_COMPOSITE_TERMINATION) { button = gtk_check_button_new_with_label("Enable Composite Termination"); ctk_config_set_tooltip(ctk_config, button, __composite_termination_help); alignment = gtk_alignment_new(1, 1, 0, 0); gtk_container_add(GTK_CONTAINER(alignment), button); gtk_table_attach(GTK_TABLE(table), alignment, 0, 2, 2, 3, GTK_FILL | GTK_EXPAND, GTK_FILL, TABLE_PADDING, TABLE_PADDING); ctk_gvo_sync->composite_termination_button = button; init_composite_termination(ctk_gvo_sync); g_signal_connect(G_OBJECT(button), "toggled", G_CALLBACK(composite_termination_toggled), ctk_gvo_sync); row = 3; } else { ctk_gvo_sync->composite_termination_button = NULL; row = 2; } /* Sync Mode */ menu = start_menu("Sync Mode: ", table, row); ctk_drop_down_menu_append_item(CTK_DROP_DOWN_MENU(menu), "Free Running", NV_CTRL_GVO_SYNC_MODE_FREE_RUNNING); ctk_drop_down_menu_append_item(CTK_DROP_DOWN_MENU(menu), "GenLock", NV_CTRL_GVO_SYNC_MODE_GENLOCK); ctk_drop_down_menu_append_item(CTK_DROP_DOWN_MENU(menu), "FrameLock", NV_CTRL_GVO_SYNC_MODE_FRAMELOCK); finish_menu(menu, table, row); row++; ctk_gvo_sync->sync_mode_menu = menu; ctk_drop_down_menu_set_tooltip(ctk_config, CTK_DROP_DOWN_MENU(menu), __sync_mode_help); ctk_drop_down_menu_set_current_value (CTK_DROP_DOWN_MENU(ctk_gvo_sync->sync_mode_menu), ctk_gvo_sync->sync_mode); g_signal_connect(G_OBJECT(ctk_gvo_sync->sync_mode_menu), "changed", G_CALLBACK(sync_mode_changed), (gpointer) ctk_gvo_sync); /* Sync Format */ menu = start_menu("Sync Format: ", table, row); for (i = 0; syncFormatNames[i].name; i++) { ctk_drop_down_menu_append_item(CTK_DROP_DOWN_MENU(menu), syncFormatNames[i].name, syncFormatNames[i].format); } finish_menu(menu, table, row); row++; ctk_gvo_sync->sync_format_menu = menu; ctk_drop_down_menu_set_tooltip(ctk_config, CTK_DROP_DOWN_MENU(menu), __sync_format_help); init_sync_format_menu(ctk_gvo_sync); g_signal_connect(G_OBJECT(ctk_gvo_sync->sync_format_menu), "changed", G_CALLBACK(sync_format_changed), (gpointer) ctk_gvo_sync); /* Sync Status */ label = gtk_label_new("Sync Status:"); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); gtk_table_attach(GTK_TABLE(table), label, 0, 1, row, row+1, GTK_FILL, GTK_FILL, TABLE_PADDING, TABLE_PADDING); ctk_gvo_sync->sync_lock_status_text = gtk_label_new(""); update_sync_lock_status_text(ctk_gvo_sync); hbox = gtk_hbox_new(FALSE, 5); gtk_box_pack_start(GTK_BOX(hbox), ctk_gvo_sync->sync_lock_status_text, FALSE, FALSE, 0); gtk_table_attach(GTK_TABLE(table), hbox, 1, 2, row, row+1, GTK_FILL /*| GTK_EXPAND*/, GTK_FILL, TABLE_PADDING, TABLE_PADDING); row++; /* * Synchronization Skew (Delay/Advance) */ /* NV_CTRL_GVO_SYNC_DELAY_PIXELS */ ret = NvCtrlGetValidAttributeValues(handle, NV_CTRL_GVO_SYNC_DELAY_PIXELS, &valid); if ((ret == NvCtrlSuccess) && (valid.type == ATTRIBUTE_TYPE_RANGE)) { ret = NvCtrlGetAttribute(handle, NV_CTRL_GVO_SYNC_DELAY_PIXELS, &val); if (ret != NvCtrlSuccess) val = 0; if (ctk_gvo_sync->caps & NV_CTRL_GVO_CAPABILITIES_ADVANCE_SYNC_SKEW) { label = gtk_label_new("HSync Advance:"); help_text = __hsync_advance_help; } else { label = gtk_label_new("HSync Delay:"); help_text = __hsync_delay_help; } gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); gtk_table_attach(GTK_TABLE(table), label, 0, 1, row, row+1, GTK_FILL, GTK_FILL, TABLE_PADDING, TABLE_PADDING); ctk_gvo_sync->hsync_delay_spin_button = gtk_spin_button_new_with_range(valid.u.range.min, valid.u.range.max, 1); ctk_config_set_tooltip(ctk_config, ctk_gvo_sync->hsync_delay_spin_button, help_text); gtk_spin_button_set_value (GTK_SPIN_BUTTON(ctk_gvo_sync->hsync_delay_spin_button), val); g_signal_connect(G_OBJECT(ctk_gvo_sync->hsync_delay_spin_button), "value-changed", G_CALLBACK(hsync_delay_changed), ctk_gvo_sync); hbox = gtk_hbox_new(FALSE, 5); gtk_box_pack_start(GTK_BOX(hbox), ctk_gvo_sync->hsync_delay_spin_button, FALSE, FALSE, 0); label = gtk_label_new("(pixels)"); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0); gtk_table_attach(GTK_TABLE(table), hbox, 1, 2, row, row+1, GTK_FILL /*| GTK_EXPAND*/, GTK_FILL, TABLE_PADDING, TABLE_PADDING); row++; } /* NV_CTRL_GVO_SYNC_DELAY_LINES */ ret = NvCtrlGetValidAttributeValues(handle, NV_CTRL_GVO_SYNC_DELAY_LINES, &valid); if ((ret == NvCtrlSuccess) && (valid.type == ATTRIBUTE_TYPE_RANGE)) { ret = NvCtrlGetAttribute(handle, NV_CTRL_GVO_SYNC_DELAY_LINES, &val); if (ret != NvCtrlSuccess) val = 0; if (ctk_gvo_sync->caps & NV_CTRL_GVO_CAPABILITIES_ADVANCE_SYNC_SKEW) { label = gtk_label_new("VSync Advance:"); help_text = __vsync_advance_help; } else { label = gtk_label_new("VSync Delay:"); help_text = __vsync_delay_help; } gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); gtk_table_attach(GTK_TABLE(table), label, 0, 1, row, row+1, GTK_FILL, GTK_FILL, TABLE_PADDING, TABLE_PADDING); ctk_gvo_sync->vsync_delay_spin_button = gtk_spin_button_new_with_range(valid.u.range.min, valid.u.range.max, 1); ctk_config_set_tooltip(ctk_config, ctk_gvo_sync->vsync_delay_spin_button, help_text); gtk_spin_button_set_value (GTK_SPIN_BUTTON(ctk_gvo_sync->vsync_delay_spin_button), val); g_signal_connect(G_OBJECT(ctk_gvo_sync->vsync_delay_spin_button), "value-changed", G_CALLBACK(vsync_delay_changed), ctk_gvo_sync); hbox = gtk_hbox_new(FALSE, 5); gtk_box_pack_start(GTK_BOX(hbox), ctk_gvo_sync->vsync_delay_spin_button, FALSE, FALSE, 0); label = gtk_label_new("(lines)"); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0); gtk_table_attach(GTK_TABLE(table), hbox, 1, 2, row, row+1, GTK_FILL /*| GTK_EXPAND*/, GTK_FILL, TABLE_PADDING, TABLE_PADDING); row++; } /* create the watch cursor (for use when the "Detect" button is toggled" */ ctk_gvo_sync->wait_cursor = gdk_cursor_new(GDK_WATCH); /* Set UI sensitivity */ update_gvo_sync_sensitivity(ctk_gvo_sync); /* Start listening for events */ register_for_gvo_sync_events(ctk_gvo_sync); /* show the page */ gtk_widget_show_all(GTK_WIDGET(object)); return GTK_WIDGET(object); } /* ctk_gvo_sync_new() */
/** * Creates the "Fonts & logo" tab. This function creates some buttons * that are borrowed from applications like gedit. * * \returns A newly allocated vbox */ GtkWidget * onglet_display_fonts ( void ) { GtkWidget *hbox, *vbox_pref, *label, *paddingbox, *font_button; GtkWidget *check_button, *vbox; GdkPixbuf * pixbuf = NULL; GtkWidget *button; GtkWidget *color_combobox; GtkWidget *color_button; vbox_pref = new_vbox_with_title_and_icon ( _("Fonts & logo"), "fonts.png" ); /* Change Grisbi Logo */ paddingbox = new_paddingbox_with_title ( vbox_pref, FALSE, _("Grisbi logo") ); hbox = gtk_hbox_new ( FALSE, 5 ); gtk_box_pack_start ( GTK_BOX ( paddingbox ), hbox, FALSE, FALSE, 0 ); check_button = gtk_check_button_new_with_label ( _("Display a logo")); gtk_box_pack_start ( GTK_BOX ( hbox ), check_button, FALSE, FALSE, 0 ); gtk_toggle_button_set_active ( GTK_TOGGLE_BUTTON ( check_button ), etat.utilise_logo ); hbox = gtk_hbox_new ( FALSE, 5 ); gtk_box_pack_start ( GTK_BOX ( paddingbox ), hbox, FALSE, FALSE, 0 ); /* le logo est grisé ou non suivant qu'on l'utilise ou pas */ gtk_widget_set_sensitive ( hbox, etat.utilise_logo ); g_signal_connect ( G_OBJECT ( check_button ), "toggled", G_CALLBACK ( change_choix_utilise_logo ), hbox ); logo_button = gtk_button_new (); gtk_button_set_relief ( GTK_BUTTON ( logo_button ), GTK_RELIEF_NONE ); pixbuf = gsb_select_icon_get_logo_pixbuf ( ); if (!pixbuf) { preview = gtk_image_new_from_pixbuf ( gsb_select_icon_get_default_logo_pixbuf ( ) ); } else { if ( gdk_pixbuf_get_width(pixbuf) > 64 || gdk_pixbuf_get_height(pixbuf) > 64 ) { GdkPixbuf * tmp; tmp = gdk_pixbuf_new ( GDK_COLORSPACE_RGB, TRUE, 8, gdk_pixbuf_get_width(pixbuf)/2, gdk_pixbuf_get_height(pixbuf)/2 ); gdk_pixbuf_scale ( pixbuf, tmp, 0, 0, gdk_pixbuf_get_width(pixbuf)/2, gdk_pixbuf_get_height(pixbuf)/2, 0, 0, 0.5, 0.5, GDK_INTERP_HYPER ); pixbuf = tmp; } preview = gtk_image_new_from_pixbuf (pixbuf); } gtk_container_add (GTK_CONTAINER(logo_button), preview); g_signal_connect_swapped ( G_OBJECT ( logo_button ), "clicked", G_CALLBACK ( modification_logo_accueil ), NULL ); gtk_box_pack_start ( GTK_BOX ( hbox ), logo_button, FALSE, FALSE, 0 ); label = gtk_label_new ( _("Click on preview to change logo") ); gtk_box_pack_start ( GTK_BOX ( hbox ), label, FALSE, FALSE, 0 ); /* Change fonts */ paddingbox = new_paddingbox_with_title ( vbox_pref, FALSE, _("Fonts") ); hbox = gtk_hbox_new ( FALSE, 10 ); gtk_box_pack_start ( GTK_BOX ( paddingbox ), hbox, FALSE, FALSE, 0 ); check_button = gtk_check_button_new_with_label ( _("Use a custom font for the transactions: ")); gtk_box_pack_start ( GTK_BOX ( hbox ), check_button, FALSE, FALSE, 0 ); gtk_toggle_button_set_active ( GTK_TOGGLE_BUTTON ( check_button ), conf.utilise_fonte_listes ); /* on crée la vbox qui contiendra la font button et le raz */ vbox = gtk_vbox_new ( FALSE, 10 ); gtk_box_pack_start ( GTK_BOX ( hbox ), vbox, FALSE, FALSE, 0 ); gtk_widget_set_sensitive ( vbox, conf.utilise_fonte_listes ); g_signal_connect ( G_OBJECT ( check_button ), "toggled", G_CALLBACK ( change_choix_utilise_fonte_liste ), vbox ); /* Create font button */ font_button = utils_font_create_button ( &conf.font_string, G_CALLBACK (update_fonte_listes), NULL); gtk_box_pack_start ( GTK_BOX (vbox), font_button, FALSE, FALSE, 0 ); if ( !gsb_data_account_get_accounts_amount () ) { gtk_widget_set_sensitive ( vbox_pref, FALSE ); } /* change colors */ paddingbox = new_paddingbox_with_title ( vbox_pref, FALSE, _("Colors") ); vbox = gtk_vbox_new ( FALSE, 10 ); gtk_box_pack_start ( GTK_BOX ( paddingbox ), vbox, FALSE, FALSE, 10 ); hbox = gtk_hbox_new ( FALSE, 10 ); gtk_box_pack_start ( GTK_BOX ( vbox ), hbox, FALSE, FALSE, 10 ); color_combobox = gsb_color_create_color_combobox ( ); gtk_box_pack_start ( GTK_BOX (hbox), color_combobox, FALSE, FALSE, 0); color_button = gtk_color_button_new (); gtk_color_button_set_title ( GTK_COLOR_BUTTON(color_button), _("Choosing color") ); g_signal_connect ( G_OBJECT (color_button), "color-set", G_CALLBACK (preferences_view_color_changed), G_OBJECT (color_combobox)); gtk_box_pack_start ( GTK_BOX (hbox), color_button, FALSE, FALSE, 0); /* connect the color button to the combobox if changed */ g_signal_connect ( G_OBJECT (color_combobox), "changed", G_CALLBACK (preferences_view_color_combobox_changed), G_OBJECT (color_button)); button = gtk_button_new_with_label (_("Back to default")); g_signal_connect ( G_OBJECT (button), "clicked", G_CALLBACK (preferences_view_color_default), G_OBJECT (color_combobox)); gtk_box_pack_start ( GTK_BOX (vbox), button, FALSE, FALSE, 0); gtk_combo_box_set_active ( GTK_COMBO_BOX (color_combobox), 0); return vbox_pref; }
/* Add a check_button or radio_button to control a particular option This function makes particular use of the current... variables at the top of this file. */ static void xkb_options_add_option (XklConfigRegistry * config_registry, XklConfigItem * config_item, GtkBuilder * dialog) { GtkWidget *option_check; gchar *utf_option_name = xci_desc_to_utf8 (config_item); /* Copy this out because we'll load it into the widget with set_data */ gchar *full_option_name = g_strdup (gkbd_keyboard_config_merge_items (current1st_level_id, config_item->name)); gboolean initial_state; if (current_multi_select) option_check = gtk_check_button_new_with_label (utf_option_name); else { if (current_radio_group == NULL) { /* The first radio in a group is to be "Default", meaning none of the below options are to be included in the selected list. This is a HIG-compliant alternative to allowing no selection in the group. */ option_check = gtk_radio_button_new_with_label (current_radio_group, _("Default")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (option_check), TRUE); /* Make option name underscore - to enforce its first position in the list */ g_object_set_data_full (G_OBJECT (option_check), "utfOptionName", g_strdup (" "), g_free); option_checks_list = g_slist_append (option_checks_list, option_check); current_radio_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (option_check)); current_none_radio = option_check; g_signal_connect (option_check, "focus-in-event", G_CALLBACK (option_focused_cb), WID ("options_scroll")); } option_check = gtk_radio_button_new_with_label (current_radio_group, utf_option_name); current_radio_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (option_check)); g_object_set_data (G_OBJECT (option_check), "NoneRadio", current_none_radio); } initial_state = xkb_options_is_selected (full_option_name); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (option_check), initial_state); g_object_set_data_full (G_OBJECT (option_check), OPTION_ID_PROP, full_option_name, g_free); g_object_set_data_full (G_OBJECT (option_check), "utfOptionName", utf_option_name, g_free); g_signal_connect (option_check, "toggled", G_CALLBACK (option_toggled_cb), NULL); option_checks_list = g_slist_append (option_checks_list, option_check); g_signal_connect (option_check, "focus-in-event", G_CALLBACK (option_focused_cb), WID ("options_scroll")); xkb_options_expander_selcounter_add (initial_state); g_object_set_data (G_OBJECT (option_check), GCONFSTATE_PROP, GINT_TO_POINTER (initial_state)); }
static void create_rssyl_prefs_page(PrefsPage *page, GtkWindow *window, gpointer data) { RSSylPrefsPage *prefs_page = (RSSylPrefsPage *) page; GtkWidget *table; GtkWidget *refresh; GtkWidget *expired; GtkWidget *refresh_on_startup; GtkWidget *cookies_path; GtkWidget *label; GtkObject *refresh_adj, *expired_adj; table = gtk_table_new(RSSYL_NUM_PREFS, 2, FALSE); gtk_container_set_border_width(GTK_CONTAINER(table), 5); gtk_table_set_row_spacings(GTK_TABLE(table), VSPACING_NARROW); gtk_table_set_col_spacings(GTK_TABLE(table), 8); label = gtk_label_new(_("Default refresh interval in minutes")); gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5); gtk_table_attach(GTK_TABLE(table), label, 0, 1, 0, 1, GTK_FILL, 0, 0, 0); refresh_adj = gtk_adjustment_new(rssyl_prefs.refresh, 0, 100000, 1, 10, 0); refresh = gtk_spin_button_new(GTK_ADJUSTMENT(refresh_adj), 1, 0); gtk_table_attach(GTK_TABLE(table), refresh, 1, 2, 0, 1, GTK_FILL, 0, 0, 0); CLAWS_SET_TIP(refresh, _("Set to 0 to disable automatic refreshing")); label = gtk_label_new(_("Default number of expired items to keep")); gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5); gtk_table_attach(GTK_TABLE(table), label, 0, 1, 1, 2, GTK_FILL, 0, 0, 0); expired_adj = gtk_adjustment_new(rssyl_prefs.expired, -1, 100000, 1, 10, 0); expired = gtk_spin_button_new(GTK_ADJUSTMENT(expired_adj), 1, 0); gtk_table_attach(GTK_TABLE(table), expired, 1, 2, 1, 2, GTK_FILL, 0, 0, 0); CLAWS_SET_TIP(expired, _("Set to -1 to keep expired items")); refresh_on_startup = gtk_check_button_new_with_label( _("Refresh all feeds on application start")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(refresh_on_startup), rssyl_prefs.refresh_on_startup); gtk_table_attach(GTK_TABLE(table), refresh_on_startup, 0, 2, 3, 4, GTK_FILL | GTK_EXPAND, 0, 0, 0); label = gtk_label_new(_("Path to cookies file")); gtk_table_attach(GTK_TABLE(table), label, 0, 1, 4, 5, GTK_FILL, 0, 0, 0); gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5); cookies_path = gtk_entry_new (); gtk_entry_set_text(GTK_ENTRY(cookies_path), rssyl_prefs.cookies_path); gtk_table_attach(GTK_TABLE(table), cookies_path, 1, 2, 4, 5, GTK_FILL | GTK_EXPAND, 0, 0, 0); CLAWS_SET_TIP(cookies_path, _("Path to Netscape-style cookies.txt file containing your cookies")); gtk_widget_show_all(table); prefs_page->page.widget = table; prefs_page->refresh = refresh; prefs_page->expired = expired; prefs_page->refresh_on_startup = refresh_on_startup; prefs_page->cookies_path = cookies_path; }
/* Show the preferences dialog */ static void command_settings_callback (GtkAction *action, CommandApplet *command_applet) { GtkDialog *dialog; GtkGrid *grid; GtkWidget *widget; GtkWidget *command; GtkWidget *interval; GtkWidget *width; GtkWidget *showicon; dialog = GTK_DIALOG (gtk_dialog_new_with_buttons(_("Command Applet Preferences"), NULL, GTK_DIALOG_MODAL, GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, NULL)); grid = GTK_GRID (gtk_grid_new ()); gtk_grid_set_row_spacing (grid, 12); gtk_grid_set_column_spacing (grid, 12); gtk_window_set_default_size (GTK_WINDOW (dialog), 350, 150); gtk_container_set_border_width (GTK_CONTAINER (dialog), 10); widget = gtk_label_new (_("Command:")); #if GTK_CHECK_VERSION (3, 16, 0) gtk_label_set_xalign (GTK_LABEL (widget), 1.0); gtk_label_set_yalign (GTK_LABEL (widget), 0.5); #else gtk_misc_set_alignment (GTK_MISC (widget), 1.0, 0.5); #endif gtk_grid_attach (grid, widget, 1, 0, 1, 1); command = gtk_entry_new (); gtk_grid_attach (grid, command, 2, 0, 1, 1); widget = gtk_label_new (_("Interval (seconds):")); #if GTK_CHECK_VERSION (3, 16, 0) gtk_label_set_xalign (GTK_LABEL (widget), 1.0); gtk_label_set_yalign (GTK_LABEL (widget), 0.5); #else gtk_misc_set_alignment (GTK_MISC (widget), 1.0, 0.5); #endif gtk_grid_attach (grid, widget, 1, 1, 1, 1); interval = gtk_spin_button_new_with_range (1.0, 600.0, 1.0); gtk_grid_attach (grid, interval, 2, 1, 1, 1); widget = gtk_label_new (_("Maximum width (chars):")); #if GTK_CHECK_VERSION (3, 16, 0) gtk_label_set_xalign (GTK_LABEL (widget), 1.0); gtk_label_set_yalign (GTK_LABEL (widget), 0.5); #else gtk_misc_set_alignment (GTK_MISC (widget), 1.0, 0.5); #endif gtk_grid_attach (grid, widget, 1, 2, 1, 1); width = gtk_spin_button_new_with_range(1.0, 100.0, 1.0); gtk_grid_attach (grid, width, 2, 2, 1, 1); showicon = gtk_check_button_new_with_label (_("Show icon")); gtk_grid_attach (grid, showicon, 2, 3, 1, 1); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (dialog)), GTK_WIDGET (grid), TRUE, TRUE, 0); g_signal_connect (dialog, "response", G_CALLBACK (gtk_widget_destroy), dialog); /* use g_settings_bind to manage settings */ g_settings_bind (command_applet->settings, COMMAND_KEY, command, "text", G_SETTINGS_BIND_DEFAULT); g_settings_bind (command_applet->settings, INTERVAL_KEY, interval, "value", G_SETTINGS_BIND_DEFAULT); g_settings_bind (command_applet->settings, WIDTH_KEY, width, "value", G_SETTINGS_BIND_DEFAULT); g_settings_bind (command_applet->settings, SHOW_ICON_KEY, showicon, "active", G_SETTINGS_BIND_DEFAULT); gtk_widget_show_all (GTK_WIDGET (dialog)); }
static void pref_construct(GtkWidget *con) { GtkWidget *frame,*vbox; GtkWidget *a_a_ck, *a_b_ck, *a_s_ck, *c_a_ck, *a_i_ck, *s_s_ck, *s_g_ck; /** * Enable/Disable checkbox */ frame = gtk_frame_new(""); gtk_label_set_markup(GTK_LABEL(gtk_frame_get_label_widget(GTK_FRAME(frame))), "<b>Fetch</b>"); gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_NONE); vbox = gtk_vbox_new(FALSE,6); gtk_container_set_border_width(GTK_CONTAINER(vbox), 12); gtk_container_add(GTK_CONTAINER(frame), vbox); /* Fetch artist art */ a_a_ck = gtk_check_button_new_with_label(_("Artist images")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(a_a_ck), cfg_get_single_value_as_int_with_default(config, "cover-lastfm", "fetch-art-artist", TRUE)); gtk_box_pack_start(GTK_BOX(vbox), a_a_ck, FALSE, TRUE, 0); g_signal_connect(G_OBJECT(a_a_ck), "toggled", G_CALLBACK(pref_enable_fetch), GINT_TO_POINTER(META_ARTIST_ART)); /* Fetch artist text*/ a_b_ck = gtk_check_button_new_with_label(_("Artist biography")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(a_b_ck), cfg_get_single_value_as_int_with_default(config, "cover-lastfm", "fetch-biography-artist", TRUE)); gtk_box_pack_start(GTK_BOX(vbox), a_b_ck, FALSE, TRUE, 0); g_signal_connect(G_OBJECT(a_b_ck), "toggled", G_CALLBACK(pref_enable_fetch), GINT_TO_POINTER(META_ARTIST_TXT)); /* Fetch similar artists */ a_s_ck = gtk_check_button_new_with_label(_("Similar artists")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(a_s_ck), cfg_get_single_value_as_int_with_default(config, "cover-lastfm", "fetch-similar-artist", TRUE)); gtk_box_pack_start(GTK_BOX(vbox), a_s_ck, FALSE, TRUE, 0); g_signal_connect(G_OBJECT(a_s_ck), "toggled", G_CALLBACK(pref_enable_fetch), GINT_TO_POINTER(META_ARTIST_SIMILAR)); /* Fetch album art */ c_a_ck = gtk_check_button_new_with_label(_("Album cover")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(c_a_ck), cfg_get_single_value_as_int_with_default(config, "cover-lastfm", "fetch-art-album", TRUE)); gtk_box_pack_start(GTK_BOX(vbox), c_a_ck, FALSE, TRUE, 0); g_signal_connect(G_OBJECT(c_a_ck), "toggled", G_CALLBACK(pref_enable_fetch), GINT_TO_POINTER(META_ALBUM_ART)); /* Fetch album info */ a_i_ck = gtk_check_button_new_with_label(_("Album information")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(a_i_ck), cfg_get_single_value_as_int_with_default(config, "cover-lastfm", "fetch-album-info", TRUE)); gtk_box_pack_start(GTK_BOX(vbox), a_i_ck, FALSE, TRUE, 0); g_signal_connect(G_OBJECT(c_a_ck), "toggled", G_CALLBACK(pref_enable_fetch), GINT_TO_POINTER(META_ALBUM_TXT)); /* Fetch similar songs */ s_s_ck = gtk_check_button_new_with_label(_("Similar songs")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(s_s_ck), cfg_get_single_value_as_int_with_default(config, "cover-lastfm", "fetch-similar-song", TRUE)); gtk_box_pack_start(GTK_BOX(vbox), s_s_ck, FALSE, TRUE, 0); g_signal_connect(G_OBJECT(s_s_ck), "toggled", G_CALLBACK(pref_enable_fetch), GINT_TO_POINTER(META_SONG_SIMILAR)); /* Fetch similar genre */ s_g_ck = gtk_check_button_new_with_label(_("Similar genres")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(s_g_ck), cfg_get_single_value_as_int_with_default(config, "cover-lastfm", "fetch-similar-genre", TRUE)); gtk_box_pack_start(GTK_BOX(vbox), s_g_ck, FALSE, TRUE, 0); g_signal_connect(G_OBJECT(s_g_ck), "toggled", G_CALLBACK(pref_enable_fetch), GINT_TO_POINTER(META_GENRE_SIMILAR)); if(!lastfm_get_enabled()) { gtk_widget_set_sensitive(GTK_WIDGET(vbox), FALSE); } gtk_widget_show_all(frame); gtk_container_add(GTK_CONTAINER(con), frame); }
static void ugtk_download_form_init_page2 (UgtkDownloadForm* dform) { GtkWidget* widget; GtkGrid* grid; dform->page2 = gtk_grid_new (); grid = (GtkGrid*) dform->page2; gtk_container_set_border_width (GTK_CONTAINER (grid), 2); // label - cookie file widget = gtk_label_new (_("Cookie file:")); gtk_misc_set_alignment (GTK_MISC (widget), 0.0, 0.5); // left, center g_object_set (widget, "margin-left", 2, "margin-right", 2, NULL); g_object_set (widget, "margin-top", 1, "margin-bottom", 1, NULL); gtk_grid_attach (grid, widget, 0, 0, 1, 1); dform->cookie_label = widget; // entry - cookie file widget = gtk_entry_new (); gtk_entry_set_activates_default (GTK_ENTRY (widget), TRUE); #if GTK_MAJOR_VERSION >= 3 && GTK_MINOR_VERSION >= 10 gtk_entry_set_icon_from_icon_name (GTK_ENTRY (widget), GTK_ENTRY_ICON_SECONDARY, "text-x-generic"); #else gtk_entry_set_icon_from_stock (GTK_ENTRY (widget), GTK_ENTRY_ICON_SECONDARY, GTK_STOCK_FILE); #endif gtk_entry_set_icon_tooltip_text (GTK_ENTRY (widget), GTK_ENTRY_ICON_SECONDARY, _("Select Cookie File")); g_object_set (widget, "margin", 1, "hexpand", TRUE, NULL); gtk_grid_attach (grid, widget, 1, 0, 3, 1); g_signal_connect (widget, "icon-release", G_CALLBACK (on_select_cookie), dform); g_signal_connect (GTK_EDITABLE (widget), "changed", G_CALLBACK (on_http_entry_changed), dform); dform->cookie_entry = widget; // label - post file widget = gtk_label_new (_("Post file:")); gtk_misc_set_alignment (GTK_MISC (widget), 0.0, 0.5); // left, center g_object_set (widget, "margin-left", 2, "margin-right", 2, NULL); g_object_set (widget, "margin-top", 1, "margin-bottom", 1, NULL); gtk_grid_attach (grid, widget, 0, 1, 1, 1); dform->post_label = widget; // entry - post file widget = gtk_entry_new (); gtk_entry_set_activates_default (GTK_ENTRY (widget), TRUE); #if GTK_MAJOR_VERSION >= 3 && GTK_MINOR_VERSION >= 10 gtk_entry_set_icon_from_icon_name (GTK_ENTRY (widget), GTK_ENTRY_ICON_SECONDARY, "text-x-generic"); #else gtk_entry_set_icon_from_stock (GTK_ENTRY (widget), GTK_ENTRY_ICON_SECONDARY, GTK_STOCK_FILE); #endif gtk_entry_set_icon_tooltip_text (GTK_ENTRY (widget), GTK_ENTRY_ICON_SECONDARY, _("Select Post File")); g_object_set (widget, "margin", 1, "hexpand", TRUE, NULL); gtk_grid_attach (grid, widget, 1, 1, 3, 1); g_signal_connect (widget, "icon-release", G_CALLBACK (on_select_post), dform); g_signal_connect (GTK_EDITABLE (widget), "changed", G_CALLBACK (on_http_entry_changed), dform); dform->post_entry = widget; // label - user agent widget = gtk_label_new (_("User Agent:")); gtk_misc_set_alignment (GTK_MISC (widget), 0.0, 0.5); // left, center g_object_set (widget, "margin-left", 2, "margin-right", 2, NULL); g_object_set (widget, "margin-top", 1, "margin-bottom", 1, NULL); gtk_grid_attach (grid, widget, 0, 2, 1, 1); dform->agent_label = widget; // entry - user agent widget = gtk_entry_new (); gtk_entry_set_activates_default (GTK_ENTRY (widget), TRUE); g_object_set (widget, "margin", 1, "hexpand", TRUE, NULL); gtk_grid_attach (grid, widget, 1, 2, 3, 1); g_signal_connect (GTK_EDITABLE (widget), "changed", G_CALLBACK (on_http_entry_changed), dform); dform->agent_entry = widget; // Retry limit - label widget = gtk_label_new_with_mnemonic (_("Retry _limit:")); gtk_label_set_mnemonic_widget (GTK_LABEL (widget), dform->spin_retry); g_object_set (widget, "margin-left", 2, "margin-right", 2, NULL); g_object_set (widget, "margin-top", 1, "margin-bottom", 1, NULL); gtk_grid_attach (grid, widget, 0, 3, 2, 1); // Retry limit - spin button widget = gtk_spin_button_new_with_range (0.0, 99.0, 1.0); gtk_entry_set_activates_default (GTK_ENTRY (widget), TRUE); g_object_set (widget, "margin-left", 2, "margin-right", 2, NULL); g_object_set (widget, "margin-top", 1, "margin-bottom", 1, NULL); gtk_grid_attach (grid, widget, 2, 3, 1, 1); g_signal_connect (GTK_EDITABLE (widget), "changed", G_CALLBACK (on_spin_changed), dform); dform->spin_retry = widget; // counts - label widget = gtk_label_new (_("counts")); gtk_misc_set_alignment (GTK_MISC (widget), 0.0, 0.5); g_object_set (widget, "margin-left", 2, "margin-right", 2, NULL); g_object_set (widget, "margin-top", 1, "margin-bottom", 1, NULL); gtk_grid_attach (grid, widget, 3, 3, 1, 1); // Retry delay - label widget = gtk_label_new_with_mnemonic (_("Retry _delay:")); gtk_label_set_mnemonic_widget (GTK_LABEL (widget), dform->spin_delay); g_object_set (widget, "margin-left", 2, "margin-right", 2, NULL); g_object_set (widget, "margin-top", 1, "margin-bottom", 1, NULL); gtk_grid_attach (grid, widget, 0, 4, 2, 1); // Retry delay - spin button widget = gtk_spin_button_new_with_range (0.0, 600.0, 1.0); gtk_entry_set_activates_default (GTK_ENTRY (widget), TRUE); g_object_set (widget, "margin-left", 2, "margin-right", 2, NULL); g_object_set (widget, "margin-top", 1, "margin-bottom", 1, NULL); gtk_grid_attach (grid, widget, 2, 4, 1, 1); g_signal_connect (GTK_EDITABLE (widget), "changed", G_CALLBACK (on_spin_changed), dform); dform->spin_delay = widget; // seconds - label widget = gtk_label_new (_("seconds")); gtk_misc_set_alignment (GTK_MISC (widget), 0.0, 0.5); g_object_set (widget, "margin-left", 2, "margin-right", 2, NULL); g_object_set (widget, "margin-top", 1, "margin-bottom", 1, NULL); gtk_grid_attach (grid, widget, 3, 4, 1, 1); // label - Max upload speed widget = gtk_label_new (_("Max upload speed:")); g_object_set (widget, "margin-left", 2, "margin-right", 2, NULL); g_object_set (widget, "margin-top", 1, "margin-bottom", 1, NULL); gtk_grid_attach (grid, widget, 0, 5, 2, 1); // spin - Max upload speed widget = gtk_spin_button_new_with_range (0, 99999999, 1); gtk_entry_set_activates_default (GTK_ENTRY (widget), TRUE); gtk_entry_set_width_chars (GTK_ENTRY (widget), 8); g_object_set (widget, "margin", 1, NULL); gtk_grid_attach (grid, widget, 2, 5, 1, 1); dform->spin_upload_speed = (GtkSpinButton*) widget; // label - "KiB/s" widget = gtk_label_new (_("KiB/s")); gtk_misc_set_alignment (GTK_MISC (widget), 0.0, 0.5); // left, center g_object_set (widget, "margin", 2, "hexpand", TRUE, NULL); gtk_grid_attach (grid, widget, 3, 5, 1, 1); // label - Max download speed widget = gtk_label_new (_("Max download speed:")); g_object_set (widget, "margin-left", 2, "margin-right", 2, NULL); g_object_set (widget, "margin-top", 1, "margin-bottom", 1, NULL); gtk_grid_attach (grid, widget, 0, 6, 2, 1); // spin - Max download speed widget = gtk_spin_button_new_with_range (0, 99999999, 1); gtk_entry_set_activates_default (GTK_ENTRY (widget), TRUE); gtk_entry_set_width_chars (GTK_ENTRY (widget), 8); g_object_set (widget, "margin", 1, NULL); gtk_grid_attach (grid, widget, 2, 6, 1, 1); dform->spin_download_speed = (GtkSpinButton*) widget; // label - "KiB/s" widget = gtk_label_new (_("KiB/s")); gtk_misc_set_alignment (GTK_MISC (widget), 0.0, 0.5); // left, center g_object_set (widget, "margin", 2, "hexpand", TRUE, NULL); gtk_grid_attach (grid, widget, 3, 6, 1, 1); // Retrieve timestamp widget = gtk_check_button_new_with_label (_("Retrieve timestamp")); gtk_grid_attach (grid, widget, 0, 7, 3, 1); dform->timestamp = (GtkToggleButton*) widget; }
static void file_configure(void) { if (!configure_win) { configure_win = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_type_hint(GTK_WINDOW(configure_win), GDK_WINDOW_TYPE_HINT_DIALOG); g_signal_connect (configure_win, "destroy", (GCallback) configure_destroy, NULL); g_signal_connect (configure_win, "destroy", (GCallback) gtk_widget_destroyed, & configure_win); gtk_window_set_title(GTK_WINDOW(configure_win), _("File Writer Configuration")); gtk_window_set_position(GTK_WINDOW(configure_win), GTK_WIN_POS_MOUSE); gtk_container_set_border_width(GTK_CONTAINER(configure_win), 10); configure_vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 10); gtk_container_add(GTK_CONTAINER(configure_win), configure_vbox); fileext_hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5); gtk_box_pack_start(GTK_BOX(configure_vbox), fileext_hbox, FALSE, FALSE, 0); 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); g_signal_connect(G_OBJECT(fileext_combo), "changed", G_CALLBACK(fileext_cb), NULL); plugin_button = gtk_button_new_with_label(_("Configure")); gtk_widget_set_sensitive(plugin_button, plugin->configure != NULL); g_signal_connect(G_OBJECT(plugin_button), "clicked", G_CALLBACK(plugin_configure_cb), 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); saveplace_hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5); gtk_container_add(GTK_CONTAINER(configure_vbox), saveplace_hbox); saveplace = gtk_radio_button_new_with_label(NULL, _("Save into original directory")); g_signal_connect(G_OBJECT(saveplace), "toggled", G_CALLBACK(saveplace_original_cb), NULL); gtk_box_pack_start(GTK_BOX(saveplace_hbox), saveplace, FALSE, FALSE, 0); saveplace = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(saveplace), _("Save into custom directory")); if (!save_original) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(saveplace), TRUE); g_signal_connect(G_OBJECT(saveplace), "toggled", G_CALLBACK(saveplace_custom_cb), NULL); gtk_box_pack_start(GTK_BOX(saveplace_hbox), saveplace, 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); path_label = gtk_label_new(_("Output file folder:")); gtk_box_pack_start(GTK_BOX(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); filenamefrom_toggle = gtk_radio_button_new_with_label(NULL, _("original file tags")); g_signal_connect(G_OBJECT(filenamefrom_toggle), "toggled", G_CALLBACK(filenamefromtags_cb), NULL); gtk_box_pack_start(GTK_BOX(filenamefrom_hbox), filenamefrom_toggle, FALSE, FALSE, 0); filenamefrom_toggle = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(filenamefrom_toggle), _("original filename")); g_signal_connect(G_OBJECT(filenamefrom_toggle), "toggled", G_CALLBACK(filenamefromfilename_cb), NULL); gtk_box_pack_start(GTK_BOX(filenamefrom_hbox), filenamefrom_toggle, FALSE, FALSE, 0); if (!filenamefromtags) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(filenamefrom_toggle), 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); configure_bbox = gtk_button_box_new(GTK_ORIENTATION_HORIZONTAL); gtk_button_box_set_layout(GTK_BUTTON_BOX(configure_bbox), GTK_BUTTONBOX_END); gtk_box_pack_start(GTK_BOX(configure_vbox), configure_bbox, FALSE, FALSE, 0); configure_cancel = gtk_button_new_from_stock(GTK_STOCK_CANCEL); g_signal_connect_swapped (configure_cancel, "clicked", (GCallback) gtk_widget_destroy, configure_win); gtk_box_pack_start(GTK_BOX(configure_bbox), configure_cancel, TRUE, TRUE, 0); configure_ok = gtk_button_new_from_stock(GTK_STOCK_OK); g_signal_connect (configure_ok, "clicked", (GCallback) configure_ok_cb, NULL); gtk_box_pack_start(GTK_BOX(configure_bbox), configure_ok, TRUE, TRUE, 0); gtk_widget_show_all(configure_win); } }
void showSetupWindow(struct Context *context) { GtkWidget *browseb, *cancelButton, *applyButton, *quitButton, *check, *erasetoggle, *whitetoggle, *dumpcheck, *sortrtoggle; GtkWidget *dumptifcheck, *dumpjpgcheck; GtkWidget *vbox_main, *hbox_main, *vbox, *hbox1, *hbox2, *hbox3, *vboxright, *vboxmostright, *vboxleft, *hboxcube; GtkWidget *vboxcubel, *vboxcuber, *vboxcuberm, *hboxxc, *vboxxcl, *vboxxcr, *hboxssize, *hboxsleep, *hboxd, *vbox_header; GtkWidget *hbox_cube, *hboxsc, *scoltoggle; GtkWidget *file_label, *column_label, *ff_label, *cxyz_label, *separator; GtkWidget *cube_label, *x_label, *y_label, *z_label, *xcol_label, *ycol_label, *zcol_label, *tcol_label, *ssize_label; GtkWidget *ssx_label, *ssy_label, *sleep_label, *d_label, *header, *col_label, *misc_label, *draw_label, *empty_label; GtkWidget *hboxtd; GSList *group; setupConfig.mode = context->config->mode; setupConfig.erasePreviousFrame = context->config->erasePreviousFrame; setupConfig.backgroundWhite = context->config->backgroundWhite; setupConfig.colorset = context->config->colorset; setupConfig.inputFormatXYZ = context->config->inputFormatXYZ; setupConfig.sort = context->config->sort; setupConfig.vary = context->config->vary; setupConfig.dumpnum = context->config->dumpnum; setupConfig.tifjpg = context->config->tifjpg; setupConfig.dumpnum = context->config->dumpnum; setupConfig.useTypesForColoring = context->config->useTypesForColoring; usedump = FALSE; usescol = FALSE; setupwin = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW (setupwin), "gdpc Setup"); gtk_container_set_border_width(GTK_CONTAINER (setupwin), 5); g_signal_connect(G_OBJECT (setupwin), "destroy", G_CALLBACK (destroy), &setupwin); /* Create boxes for layout. */ vbox_main = gtk_box_new(GTK_ORIENTATION_VERTICAL, 10); vbox_header = gtk_box_new(GTK_ORIENTATION_VERTICAL, 10); hbox_main = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 30); vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 3); hbox1 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3); hbox2 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 30); hbox3 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 30); hboxssize = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0); hboxd = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0); hboxsc = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0); hbox_cube = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3); hboxcube = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3); vboxcubel = gtk_box_new(GTK_ORIENTATION_VERTICAL, 3); vboxcuber = gtk_box_new(GTK_ORIENTATION_VERTICAL, 3); vboxcuberm = gtk_box_new(GTK_ORIENTATION_VERTICAL, 3); hboxxc = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0); vboxxcl = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); vboxxcr = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); hboxsleep = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0); hboxtd = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0); vboxleft = gtk_box_new(GTK_ORIENTATION_VERTICAL, 3); vboxright = gtk_box_new(GTK_ORIENTATION_VERTICAL, 3); vboxmostright = gtk_box_new(GTK_ORIENTATION_VERTICAL, 3); gtk_container_add(GTK_CONTAINER (setupwin), vbox_main); gtk_box_pack_start(GTK_BOX (vbox_main), vbox_header, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX (vbox_main), hbox_main, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX (vbox_main), hbox3, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX (hbox_main), vbox, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX (hbox_main), vboxmostright, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX (vbox), hbox1, FALSE, FALSE, 0); separator = gtk_separator_new(GTK_ORIENTATION_HORIZONTAL); gtk_box_pack_start(GTK_BOX (vbox), separator, FALSE, TRUE, 3); gtk_box_pack_start(GTK_BOX (vbox), hbox2, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX (hbox2), vboxleft, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX (hbox2), vboxright, FALSE, FALSE, 0); header = gtk_label_new(" Setup "); gtk_box_pack_start(GTK_BOX (vbox_header), header, FALSE, TRUE, 0); separator = gtk_separator_new(GTK_ORIENTATION_HORIZONTAL); gtk_box_pack_start(GTK_BOX (vbox_header), separator, FALSE, TRUE, 3); file_label = gtk_label_new("Input file : "); file_entry = gtk_entry_new(); gtk_entry_set_max_length(GTK_ENTRY(file_entry), 160); g_signal_connect(G_OBJECT (file_entry), "changed", G_CALLBACK (filechange), G_OBJECT (setupwin)); if (context->config->file != NULL) { gtk_entry_set_text(GTK_ENTRY (file_entry), context->config->file); } gtk_widget_set_tooltip_text(file_entry, inputfilett); browseb = gtk_button_new_with_mnemonic("_Browse"); g_signal_connect(G_OBJECT (browseb), "clicked", G_CALLBACK (filebrowser), G_OBJECT (setupwin)); gtk_box_pack_start(GTK_BOX (hbox1), file_label, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX (hbox1), file_entry, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX (hbox1), browseb, FALSE, FALSE, 0); ssize_label = gtk_label_new("Drawingboard size [pixels]"); ssx_label = gtk_label_new(" X : "); ssy_label = gtk_label_new(" Y : "); adjssizex = (GtkAdjustment *) gtk_adjustment_new(context->config->absxsize, 0.0, 3000.0, 10.0, 5.0, 0.0); adjssizey = (GtkAdjustment *) gtk_adjustment_new(context->config->absysize, 0.0, 3000.0, 10.0, 5.0, 0.0); ssxspinner = gtk_spin_button_new(adjssizex, 0, 0); gtk_spin_button_set_wrap(GTK_SPIN_BUTTON (ssxspinner), FALSE); ssyspinner = gtk_spin_button_new(adjssizey, 0, 0); gtk_spin_button_set_wrap(GTK_SPIN_BUTTON (ssyspinner), FALSE); gtk_box_pack_start(GTK_BOX (vboxleft), ssize_label, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX (hboxssize), ssx_label, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX (hboxssize), ssxspinner, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX (hboxssize), ssy_label, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX (hboxssize), ssyspinner, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX (vboxleft), hboxssize, TRUE, TRUE, 0); separator = gtk_separator_new(GTK_ORIENTATION_HORIZONTAL); gtk_box_pack_start(GTK_BOX (vboxleft), separator, FALSE, TRUE, 3); cxyz_label = gtk_label_new("Simulation box size"); gtk_box_pack_start(GTK_BOX (vboxleft), cxyz_label, TRUE, TRUE, 3); gtk_box_pack_start(GTK_BOX (vboxleft), hbox_cube, TRUE, TRUE, 3); gtk_box_pack_start(GTK_BOX (vboxleft), hboxcube, TRUE, TRUE, 3); gtk_box_pack_start(GTK_BOX (hboxcube), vboxcubel, TRUE, TRUE, 3); gtk_box_pack_start(GTK_BOX (hboxcube), vboxcuber, TRUE, TRUE, 3); gtk_box_pack_start(GTK_BOX (hboxcube), vboxcuberm, TRUE, TRUE, 3); cube_label = gtk_label_new("Cube : "); adjcube = (GtkAdjustment *) gtk_adjustment_new(0.0, 0.0, 10000.0, 1.0, 5.0, 0.0); cubespinner = gtk_spin_button_new(adjcube, 0, 2); gtk_spin_button_set_wrap(GTK_SPIN_BUTTON (cubespinner), FALSE); // gtk_spin_button_set_shadow_type (GTK_SPIN_BUTTON (cubespinner), // GTK_SHADOW_OUT); gtk_box_pack_start(GTK_BOX (hbox_cube), cube_label, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX (hbox_cube), cubespinner, TRUE, TRUE, 0); gtk_widget_set_tooltip_text(cubespinner, cubett); x_label = gtk_label_new("X : "); if (context->config->xmin == 65535.0) { adjx = (GtkAdjustment *) gtk_adjustment_new(0.0, -10000.0, 0.0, 1.0, 5.0, 0.0); adjx2 = (GtkAdjustment *) gtk_adjustment_new(0.0, 0.0, 10000.0, 1.0, 5.0, 0.0); } else { adjx = (GtkAdjustment *) gtk_adjustment_new(context->config->xmin, -10000.0, context->config->xmax, 1.0, 5.0, 0.0); adjx2 = (GtkAdjustment *) gtk_adjustment_new(context->config->xmax, context->config->xmin, 10000.0, 1.0, 5.0, 0.0); } xspinner = gtk_spin_button_new(adjx, 0, 2); gtk_spin_button_set_wrap(GTK_SPIN_BUTTON (xspinner), FALSE); g_signal_connect(G_OBJECT (adjx), "value_changed", G_CALLBACK (setspinlimits), G_OBJECT (setupwin)); x2spinner = gtk_spin_button_new(adjx2, 0, 2); gtk_spin_button_set_wrap(GTK_SPIN_BUTTON (x2spinner), FALSE); g_signal_connect(G_OBJECT (adjx2), "value_changed", G_CALLBACK (setspinlimits), G_OBJECT (setupwin)); gtk_box_pack_start(GTK_BOX (vboxcubel), x_label, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX (vboxcuber), xspinner, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX (vboxcuberm), x2spinner, TRUE, TRUE, 0); y_label = gtk_label_new("Y : "); if (context->config->ymin == 65535.0) { adjy = (GtkAdjustment *) gtk_adjustment_new(0.0, -10000.0, 0.0, 1.0, 5.0, 0.0); adjy2 = (GtkAdjustment *) gtk_adjustment_new(0.0, 0.0, 10000.0, 1.0, 5.0, 0.0); } else { adjy = (GtkAdjustment *) gtk_adjustment_new(context->config->ymin, -10000.0, context->config->ymax, 1.0, 5.0, 0.0); adjy2 = (GtkAdjustment *) gtk_adjustment_new(context->config->ymax, context->config->ymin, 10000.0, 1.0, 5.0, 0.0); } yspinner = gtk_spin_button_new(adjy, 0, 2); gtk_spin_button_set_wrap(GTK_SPIN_BUTTON (yspinner), FALSE); g_signal_connect(G_OBJECT (adjy), "value_changed", G_CALLBACK (setspinlimits), G_OBJECT (setupwin)); y2spinner = gtk_spin_button_new(adjy2, 0, 2); gtk_spin_button_set_wrap(GTK_SPIN_BUTTON (y2spinner), FALSE); g_signal_connect(G_OBJECT (adjy2), "value_changed", G_CALLBACK (setspinlimits), G_OBJECT (setupwin)); gtk_box_pack_start(GTK_BOX (vboxcubel), y_label, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX (vboxcuber), yspinner, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX (vboxcuberm), y2spinner, TRUE, TRUE, 0); z_label = gtk_label_new("Z : "); if (context->config->zmin == 65535.0) { adjz = (GtkAdjustment *) gtk_adjustment_new(0.0, -10000.0, 0.0, 1.0, 5.0, 0.0); adjz2 = (GtkAdjustment *) gtk_adjustment_new(0.0, 0.0, 10000.0, 1.0, 5.0, 0.0); } else { adjz = (GtkAdjustment *) gtk_adjustment_new(context->config->zmin, -10000.0, context->config->zmax, 1.0, 5.0, 0.0); adjz2 = (GtkAdjustment *) gtk_adjustment_new(context->config->zmax, context->config->zmin, 10000.0, 1.0, 5.0, 0.0); } zspinner = gtk_spin_button_new(adjz, 0, 2); gtk_spin_button_set_wrap(GTK_SPIN_BUTTON (zspinner), FALSE); g_signal_connect(G_OBJECT (adjz), "value_changed", G_CALLBACK (setspinlimits), G_OBJECT (setupwin)); z2spinner = gtk_spin_button_new(adjz2, 0, 2); gtk_spin_button_set_wrap(GTK_SPIN_BUTTON (z2spinner), FALSE); g_signal_connect(G_OBJECT (adjz2), "value_changed", G_CALLBACK (setspinlimits), G_OBJECT (setupwin)); gtk_box_pack_start(GTK_BOX (vboxcubel), z_label, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX (vboxcuber), zspinner, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX (vboxcuberm), z2spinner, TRUE, TRUE, 0); gtk_widget_set_tooltip_text(xspinner, mintt); gtk_widget_set_tooltip_text(yspinner, mintt); gtk_widget_set_tooltip_text(zspinner, mintt); gtk_widget_set_tooltip_text(x2spinner, maxtt); gtk_widget_set_tooltip_text(y2spinner, maxtt); gtk_widget_set_tooltip_text(z2spinner, maxtt); separator = gtk_separator_new(GTK_ORIENTATION_HORIZONTAL); gtk_box_pack_start(GTK_BOX (vboxleft), separator, FALSE, TRUE, 3); column_label = gtk_label_new("Input data column representations"); gtk_box_pack_start(GTK_BOX (vboxleft), column_label, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX (vboxleft), hboxxc, TRUE, TRUE, 3); gtk_box_pack_start(GTK_BOX (hboxxc), vboxxcl, TRUE, TRUE, 3); gtk_box_pack_start(GTK_BOX (hboxxc), vboxxcr, TRUE, TRUE, 3); xcol_label = gtk_label_new("X column : "); adjxc = (GtkAdjustment *) gtk_adjustment_new(context->config->xcolumn, 1.0, 100.0, 1.0, 5.0, 0.0); xcspinner = gtk_spin_button_new(adjxc, 0, 0); gtk_spin_button_set_wrap(GTK_SPIN_BUTTON (xcspinner), FALSE); gtk_box_pack_start(GTK_BOX (vboxxcl), xcol_label, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX (vboxxcr), xcspinner, TRUE, TRUE, 0); gtk_widget_set_tooltip_text(xcspinner, xcoltt); ycol_label = gtk_label_new("Y column : "); adjyc = (GtkAdjustment *) gtk_adjustment_new(context->config->ycolumn, 1.0, 100.0, 1.0, 5.0, 0.0); ycspinner = gtk_spin_button_new(adjyc, 0, 0); gtk_spin_button_set_wrap(GTK_SPIN_BUTTON (ycspinner), FALSE); gtk_box_pack_start(GTK_BOX (vboxxcl), ycol_label, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX (vboxxcr), ycspinner, TRUE, TRUE, 0); gtk_widget_set_tooltip_text(ycspinner, ycoltt); zcol_label = gtk_label_new("Z column : "); adjzc = (GtkAdjustment *) gtk_adjustment_new(context->config->zcolumn, 1.0, 100.0, 1.0, 5.0, 0.0); zcspinner = gtk_spin_button_new(adjzc, 0, 0); gtk_spin_button_set_wrap(GTK_SPIN_BUTTON (zcspinner), FALSE); gtk_box_pack_start(GTK_BOX (vboxxcl), zcol_label, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX (vboxxcr), zcspinner, TRUE, TRUE, 0); gtk_widget_set_tooltip_text(zcspinner, zcoltt); tcol_label = gtk_label_new("t column : "); adjtc = (GtkAdjustment *) gtk_adjustment_new(context->config->tcolumn, 1.0, 100.0, 1.0, 5.0, 0.0); tcspinner = gtk_spin_button_new(adjtc, 0, 0); gtk_spin_button_set_wrap(GTK_SPIN_BUTTON (tcspinner), FALSE); gtk_box_pack_start(GTK_BOX (vboxxcl), tcol_label, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX (vboxxcr), tcspinner, TRUE, TRUE, 0); gtk_widget_set_tooltip_text(tcspinner, tcoltt); separator = gtk_separator_new(GTK_ORIENTATION_HORIZONTAL); gtk_box_pack_start(GTK_BOX (vboxleft), separator, FALSE, TRUE, 3); timedel_entry = gtk_entry_new(); gtk_entry_set_max_length(GTK_ENTRY(timedel_entry), 160); gtk_entry_set_text(GTK_ENTRY (timedel_entry), context->config->timedelim); timedel_label = gtk_label_new("Time unit : "); gtk_box_pack_start(GTK_BOX (hboxtd), timedel_label, FALSE, TRUE, 0); gtk_box_pack_start(GTK_BOX (hboxtd), timedel_entry, FALSE, TRUE, 0); gtk_box_pack_start(GTK_BOX (vboxleft), hboxtd, FALSE, TRUE, 0); if (!context->config->inputFormatXYZ) { gtk_widget_set_sensitive(timedel_entry, FALSE); gtk_widget_set_sensitive(timedel_label, FALSE); } else { gtk_widget_set_sensitive(timedel_entry, TRUE); gtk_widget_set_sensitive(timedel_label, TRUE); } gtk_widget_set_tooltip_text(timedel_entry, timedeltt); ff_label = gtk_label_new("Input file format"); gtk_box_pack_start(GTK_BOX (vboxright), ff_label, TRUE, TRUE, 0); usetypescheck = gtk_check_button_new_with_label(" Use coloring by type"); check = gtk_radio_button_new_with_label(NULL, "XYZ file format"); gtk_box_pack_start(GTK_BOX (vboxright), check, TRUE, TRUE, 0); g_signal_connect(G_OBJECT (check), "clicked", G_CALLBACK (toggle_checkxyz), G_OBJECT (setupwin)); group = gtk_radio_button_get_group(GTK_RADIO_BUTTON (check)); if (context->config->inputFormatXYZ) { gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (check), TRUE); } check = gtk_radio_button_new_with_label(group, "Arbitrary file format"); gtk_box_pack_start(GTK_BOX (vboxright), check, TRUE, TRUE, 0); g_signal_connect(G_OBJECT (check), "clicked", G_CALLBACK (toggle_checkaff), G_OBJECT (setupwin)); if (!context->config->inputFormatXYZ) { gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (check), TRUE); } g_signal_connect(G_OBJECT (usetypescheck), "toggled", G_CALLBACK (toggle_usetypes), G_OBJECT (setupwin)); gtk_box_pack_start(GTK_BOX (vboxright), usetypescheck, TRUE, TRUE, 0); if (context->config->useTypesForColoring) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (usetypescheck), TRUE); else gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (usetypescheck), FALSE); gtk_widget_set_tooltip_text(usetypescheck, coltypett); separator = gtk_separator_new(GTK_ORIENTATION_HORIZONTAL); gtk_box_pack_start(GTK_BOX (vboxright), separator, FALSE, TRUE, 3); draw_label = gtk_label_new(" Drawing options "); gtk_box_pack_start(GTK_BOX (vboxright), draw_label, TRUE, TRUE, 0); d_label = gtk_label_new("Size of drawn polygons :"); adjd = (GtkAdjustment *) gtk_adjustment_new(context->config->radius, 1.0, 100.0, 1.0, 5.0, 0.0); dspinner = gtk_spin_button_new(adjd, 0, 0); gtk_spin_button_set_wrap(GTK_SPIN_BUTTON (dspinner), FALSE); gtk_box_pack_start(GTK_BOX (hboxd), d_label, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX (hboxd), dspinner, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX (vboxright), hboxd, TRUE, TRUE, 0); check = gtk_radio_button_new_with_label(NULL, "Draw as rectangles"); gtk_box_pack_start(GTK_BOX (vboxright), check, TRUE, TRUE, 0); g_signal_connect(G_OBJECT (check), "toggled", G_CALLBACK (toggle_checkm0), G_OBJECT (setupwin)); if (context->config->mode == 0) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (check), TRUE); group = gtk_radio_button_get_group(GTK_RADIO_BUTTON (check)); check = gtk_radio_button_new_with_label(group, "Draw as circles"); gtk_box_pack_start(GTK_BOX (vboxright), check, TRUE, TRUE, 0); g_signal_connect(G_OBJECT (check), "toggled", G_CALLBACK (toggle_checkm1), G_OBJECT (setupwin)); if (context->config->mode == 1) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (check), TRUE); group = gtk_radio_button_get_group(GTK_RADIO_BUTTON (check)); check = gtk_radio_button_new_with_label(group, "Draw as rendered balls"); gtk_box_pack_start(GTK_BOX (vboxright), check, TRUE, TRUE, 0); g_signal_connect(G_OBJECT (check), "toggled", G_CALLBACK (toggle_checkm2), G_OBJECT (setupwin)); if (context->config->mode == 2) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (check), TRUE); empty_label = gtk_label_new(" "); gtk_box_pack_start(GTK_BOX (vboxright), empty_label, TRUE, TRUE, 0); check = gtk_radio_button_new_with_label(NULL, "Dont vary size with z"); gtk_box_pack_start(GTK_BOX (vboxright), check, TRUE, TRUE, 0); g_signal_connect(G_OBJECT (check), "toggled", G_CALLBACK (toggle_checkv0), G_OBJECT (setupwin)); if (context->config->vary == 0) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (check), TRUE); group = gtk_radio_button_get_group(GTK_RADIO_BUTTON (check)); check = gtk_radio_button_new_with_label(group, "Vary size with z, decreasing"); gtk_box_pack_start(GTK_BOX (vboxright), check, TRUE, TRUE, 0); g_signal_connect(G_OBJECT (check), "toggled", G_CALLBACK (toggle_checkv1), G_OBJECT (setupwin)); if (context->config->vary == 1) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (check), TRUE); group = gtk_radio_button_get_group(GTK_RADIO_BUTTON (check)); check = gtk_radio_button_new_with_label(group, "Vary size with z, increasing"); gtk_box_pack_start(GTK_BOX (vboxright), check, TRUE, TRUE, 0); g_signal_connect(G_OBJECT (check), "toggled", G_CALLBACK (toggle_checkv2), G_OBJECT (setupwin)); if (context->config->vary == 2) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (check), TRUE); separator = gtk_separator_new(GTK_ORIENTATION_HORIZONTAL); gtk_box_pack_start(GTK_BOX (vboxright), separator, FALSE, TRUE, 3); scoltoggle = gtk_check_button_new_with_label( "Only use inputlines with string :"); g_signal_connect(G_OBJECT (scoltoggle), "toggled", G_CALLBACK (toggle_scol), G_OBJECT (setupwin)); gtk_box_pack_start(GTK_BOX (vboxright), scoltoggle, TRUE, TRUE, 0); scol_entry = gtk_entry_new(); gtk_entry_set_max_length(GTK_ENTRY(scol_entry), 60); g_signal_connect(G_OBJECT (scol_entry), "changed", G_CALLBACK (filechange), G_OBJECT (setupwin)); gtk_box_pack_start(GTK_BOX (vboxright), scol_entry, TRUE, TRUE, 0); scol_label = gtk_label_new(" in column "); adjscol = (GtkAdjustment *) gtk_adjustment_new(1.0, 1.0, 100.0, 1.0, 5.0, 0.0); scolspinner = gtk_spin_button_new(adjscol, 0, 0); gtk_spin_button_set_wrap(GTK_SPIN_BUTTON (scolspinner), FALSE); gtk_box_pack_start(GTK_BOX (hboxsc), scol_label, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX (hboxsc), scolspinner, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX (vboxright), hboxsc, TRUE, TRUE, 0); gtk_widget_set_sensitive(scol_label, FALSE); gtk_widget_set_sensitive(scol_entry, FALSE); gtk_widget_set_sensitive(scolspinner, FALSE); col_label = gtk_label_new(" Color settings "); gtk_box_pack_start(GTK_BOX (vboxmostright), col_label, TRUE, TRUE, 0); check = gtk_radio_button_new_with_label(NULL, "Use default colors"); gtk_box_pack_start(GTK_BOX (vboxmostright), check, TRUE, TRUE, 0); g_signal_connect(G_OBJECT (check), "toggled", G_CALLBACK (toggle_checkc0), G_OBJECT (setupwin)); group = gtk_radio_button_get_group(GTK_RADIO_BUTTON (check)); if (context->config->colorset == 0) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (check), TRUE); check = gtk_radio_button_new_with_label(group, "Use inverted colors"); gtk_box_pack_start(GTK_BOX (vboxmostright), check, TRUE, TRUE, 0); g_signal_connect(G_OBJECT (check), "toggled", G_CALLBACK (toggle_checkc1), G_OBJECT (setupwin)); group = gtk_radio_button_get_group(GTK_RADIO_BUTTON (check)); if (context->config->colorset == 1) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (check), TRUE); check = gtk_radio_button_new_with_label(group, "Use cold colors"); gtk_box_pack_start(GTK_BOX (vboxmostright), check, TRUE, TRUE, 0); g_signal_connect(G_OBJECT (check), "toggled", G_CALLBACK (toggle_checkc2), G_OBJECT (setupwin)); group = gtk_radio_button_get_group(GTK_RADIO_BUTTON (check)); if (context->config->colorset == 2) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (check), TRUE); check = gtk_radio_button_new_with_label(group, "Use cold colors 2"); gtk_box_pack_start(GTK_BOX (vboxmostright), check, TRUE, TRUE, 0); g_signal_connect(G_OBJECT (check), "toggled", G_CALLBACK (toggle_checkc3), G_OBJECT (setupwin)); group = gtk_radio_button_get_group(GTK_RADIO_BUTTON (check)); if (context->config->colorset == 3) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (check), TRUE); check = gtk_radio_button_new_with_label(group, "Use greyscale colors"); gtk_box_pack_start(GTK_BOX (vboxmostright), check, TRUE, TRUE, 0); g_signal_connect(G_OBJECT (check), "toggled", G_CALLBACK (toggle_checkc4), G_OBJECT (setupwin)); if (context->config->colorset == 4) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (check), TRUE); separator = gtk_separator_new(GTK_ORIENTATION_HORIZONTAL); gtk_box_pack_start(GTK_BOX (vboxmostright), separator, FALSE, TRUE, 3); misc_label = gtk_label_new("Misc. settings"); gtk_box_pack_start(GTK_BOX (vboxmostright), misc_label, TRUE, TRUE, 0); erasetoggle = gtk_check_button_new_with_label( " Erase before drawing next frame"); g_signal_connect(G_OBJECT (erasetoggle), "toggled", G_CALLBACK (toggle_erase), G_OBJECT (setupwin)); gtk_box_pack_start(GTK_BOX (vboxmostright), erasetoggle, TRUE, TRUE, 0); if (context->config->erasePreviousFrame) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (erasetoggle), TRUE); whitetoggle = gtk_check_button_new_with_label( " Use white as backgroundcolor"); g_signal_connect(G_OBJECT (whitetoggle), "toggled", G_CALLBACK (toggle_white), G_OBJECT (setupwin)); gtk_box_pack_start(GTK_BOX (vboxmostright), whitetoggle, TRUE, TRUE, 0); if (context->config->backgroundWhite) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (whitetoggle), TRUE); sortrtoggle = gtk_check_button_new_with_label(" Reverse sorting"); g_signal_connect(G_OBJECT (sortrtoggle), "toggled", G_CALLBACK (toggle_sortr), G_OBJECT (setupwin)); gtk_box_pack_start(GTK_BOX (vboxmostright), sortrtoggle, TRUE, TRUE, 0); if (context->config->sort == 2) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (sortrtoggle), TRUE); sleep_label = gtk_label_new("Delay between frames [s] : "); adjsleep = (GtkAdjustment *) gtk_adjustment_new((context->config->interval / 1000.0), 0.0, 100.0, 0.1, 5.0, 0.0); sleepspinner = gtk_spin_button_new(adjsleep, 0, 1); gtk_spin_button_set_wrap(GTK_SPIN_BUTTON (sleepspinner), FALSE); gtk_box_pack_start(GTK_BOX (hboxsleep), sleep_label, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX (hboxsleep), sleepspinner, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX (vboxmostright), hboxsleep, TRUE, TRUE, 0); separator = gtk_separator_new(GTK_ORIENTATION_HORIZONTAL); gtk_box_pack_start(GTK_BOX (vboxmostright), separator, FALSE, TRUE, 3); dump_label = gtk_label_new(" Dumped pictures name (no extension) : "); dump_entry = gtk_entry_new(); gtk_entry_set_max_length(GTK_ENTRY(dump_entry), 60); gtk_widget_set_sensitive(dump_label, FALSE); gtk_widget_set_sensitive(dump_entry, FALSE); dtcheck = gtk_radio_button_new_with_label(NULL, " Add frame time"); group = gtk_radio_button_get_group(GTK_RADIO_BUTTON (dtcheck)); gtk_widget_set_sensitive(dtcheck, FALSE); dncheck = gtk_radio_button_new_with_label(group, " Add frame number"); gtk_widget_set_sensitive(dncheck, FALSE); okButton = gtk_button_new_from_stock(GTK_STOCK_OK); dumpcheck = gtk_radio_button_new_with_label(NULL, " Do not dump images"); gtk_box_pack_start(GTK_BOX (vboxmostright), dumpcheck, TRUE, TRUE, 0); g_signal_connect(G_OBJECT (dumpcheck), "toggled", G_CALLBACK (toggle_checkdump), G_OBJECT (setupwin)); group = gtk_radio_button_get_group(GTK_RADIO_BUTTON (dumpcheck)); if (strlen(context->config->dumpname) == 0) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (dumpcheck), TRUE); dumptifcheck = gtk_radio_button_new_with_label(group, " Dump a .png of each frame"); gtk_box_pack_start(GTK_BOX (vboxmostright), dumptifcheck, TRUE, TRUE, 0); g_signal_connect(G_OBJECT (dumptifcheck), "toggled", G_CALLBACK (toggle_checkdumptif), G_OBJECT (setupwin)); group = gtk_radio_button_get_group(GTK_RADIO_BUTTON (dumptifcheck)); if (strlen(context->config->dumpname) > 0 && context->config->tifjpg) { gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (dumptifcheck), TRUE); gtk_entry_set_text(GTK_ENTRY (dump_entry), context->config->dumpname); } dumpjpgcheck = gtk_radio_button_new_with_label(group, " Dump a .jpg of each frame"); gtk_box_pack_start(GTK_BOX (vboxmostright), dumpjpgcheck, TRUE, TRUE, 0); g_signal_connect(G_OBJECT (dumpjpgcheck), "toggled", G_CALLBACK (toggle_checkdumpjpg), G_OBJECT (setupwin)); if (strlen(context->config->dumpname) > 0 && !context->config->tifjpg) { gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (dumpjpgcheck), TRUE); } gtk_box_pack_start(GTK_BOX (vboxmostright), dump_label, TRUE, TRUE, 0); g_signal_connect(G_OBJECT (dump_entry), "changed", G_CALLBACK (filechange), G_OBJECT (setupwin)); gtk_box_pack_start(GTK_BOX (vboxmostright), dump_entry, TRUE, TRUE, 0); g_signal_connect(G_OBJECT (dtcheck), "toggled", G_CALLBACK (toggle_checkdt), G_OBJECT (setupwin)); gtk_box_pack_start(GTK_BOX (vboxmostright), dtcheck, TRUE, TRUE, 0); g_signal_connect(G_OBJECT (dncheck), "toggled", G_CALLBACK (toggle_checkdn), G_OBJECT (setupwin)); gtk_box_pack_start(GTK_BOX (vboxmostright), dncheck, TRUE, TRUE, 0); if (setupConfig.dumpnum) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (dncheck), TRUE); else gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (dtcheck), TRUE); g_signal_connect(G_OBJECT (okButton), "clicked", G_CALLBACK (okeyPressed), (gpointer) context); gtk_box_pack_start(GTK_BOX (hbox3), okButton, TRUE, TRUE, 0); if (!context->StartedAlready) gtk_widget_set_sensitive(okButton, FALSE); cancelButton = gtk_button_new_from_stock(GTK_STOCK_CANCEL); g_signal_connect(G_OBJECT (cancelButton), "clicked", G_CALLBACK (cancelPressed), (gpointer) context); gtk_box_pack_start(GTK_BOX (hbox3), cancelButton, TRUE, TRUE, 0); if (!context->StartedAlready) gtk_widget_set_sensitive(cancelButton, FALSE); applyButton = gtk_button_new_from_stock(GTK_STOCK_APPLY); g_signal_connect(G_OBJECT (applyButton), "clicked", G_CALLBACK (applyPressed), (gpointer) context); gtk_box_pack_start(GTK_BOX (hbox3), applyButton, TRUE, TRUE, 0); if (!context->StartedAlready) gtk_widget_set_sensitive(applyButton, FALSE); quitButton = gtk_button_new_from_stock(GTK_STOCK_QUIT); g_signal_connect(G_OBJECT (quitButton), "clicked", G_CALLBACK (quitPressed), (gpointer) context); gtk_box_pack_start(GTK_BOX (hbox3), quitButton, TRUE, TRUE, 0); gtk_widget_show_all(setupwin); }
static void accounts_widget_generic_setup (EmpathyAccountWidget *self, GtkWidget *table_common_settings, GtkWidget *table_advanced_settings) { TpConnectionManagerParam *params, *param; EmpathyAccountWidgetPriv *priv = GET_PRIV (self); params = empathy_account_settings_get_tp_params (priv->settings); for (param = params; param != NULL && param->name != NULL; param++) { GtkWidget *table_settings; guint n_rows = 0; GtkWidget *widget = NULL; gchar *param_name_formatted; if (param->flags & TP_CONN_MGR_PARAM_FLAG_REQUIRED) table_settings = table_common_settings; else if (priv->simple) return; else table_settings = table_advanced_settings; param_name_formatted = account_widget_generic_format_param_name (param->name); g_object_get (table_settings, "n-rows", &n_rows, NULL); gtk_table_resize (GTK_TABLE (table_settings), ++n_rows, 2); if (param->dbus_signature[0] == 's') { gchar *str; str = g_strdup_printf (_("%s:"), param_name_formatted); widget = gtk_label_new (str); gtk_misc_set_alignment (GTK_MISC (widget), 0, 0.5); g_free (str); gtk_table_attach (GTK_TABLE (table_settings), widget, 0, 1, n_rows - 1, n_rows, GTK_FILL, 0, 0, 0); gtk_widget_show (widget); widget = gtk_entry_new (); if (strcmp (param->name, "account") == 0) { g_signal_connect (widget, "realize", G_CALLBACK (gtk_widget_grab_focus), NULL); } gtk_table_attach (GTK_TABLE (table_settings), widget, 1, 2, n_rows - 1, n_rows, GTK_FILL | GTK_EXPAND, 0, 0, 0); gtk_widget_show (widget); } /* int types: ynqiuxt. double type is 'd' */ else if (param->dbus_signature[0] == 'y' || param->dbus_signature[0] == 'n' || param->dbus_signature[0] == 'q' || param->dbus_signature[0] == 'i' || param->dbus_signature[0] == 'u' || param->dbus_signature[0] == 'x' || param->dbus_signature[0] == 't' || param->dbus_signature[0] == 'd') { gchar *str = NULL; gdouble minint = 0; gdouble maxint = 0; gdouble step = 1; switch (param->dbus_signature[0]) { case 'y': minint = G_MININT8; maxint = G_MAXINT8; break; case 'n': minint = G_MININT16; maxint = G_MAXINT16; break; case 'q': minint = 0; maxint = G_MAXUINT16; break; case 'i': minint = G_MININT32; maxint = G_MAXINT32; break; case 'u': minint = 0; maxint = G_MAXUINT32; break; case 'x': minint = G_MININT64; maxint = G_MAXINT64; break; case 't': minint = 0; maxint = G_MAXUINT64; break; case 'd': minint = G_MININT32; maxint = G_MAXINT32; step = 0.1; break; } str = g_strdup_printf (_("%s:"), param_name_formatted); widget = gtk_label_new (str); gtk_misc_set_alignment (GTK_MISC (widget), 0, 0.5); g_free (str); gtk_table_attach (GTK_TABLE (table_settings), widget, 0, 1, n_rows - 1, n_rows, GTK_FILL, 0, 0, 0); gtk_widget_show (widget); widget = gtk_spin_button_new_with_range (minint, maxint, step); gtk_table_attach (GTK_TABLE (table_settings), widget, 1, 2, n_rows - 1, n_rows, GTK_FILL | GTK_EXPAND, 0, 0, 0); gtk_widget_show (widget); } else if (param->dbus_signature[0] == 'b') { widget = gtk_check_button_new_with_label (param_name_formatted); gtk_table_attach (GTK_TABLE (table_settings), widget, 0, 2, n_rows - 1, n_rows, GTK_FILL | GTK_EXPAND, 0, 0, 0); gtk_widget_show (widget); } else { DEBUG ("Unknown signature for param %s: %s", param_name_formatted, param->dbus_signature); } if (widget) account_widget_setup_widget (self, widget, param->name); g_free (param_name_formatted); } }
void aifp_transfer_files(gint mode) { GtkWidget * vbox1; GtkWidget * vbox2; GtkWidget * vbox3; GtkWidget * vbox4; GtkWidget * hbox1; GtkWidget * hbox2; GtkWidget * alignment; GtkWidget * table; GtkWidget * label; GtkWidget * frame; GtkWidget * scrolledwindow; GtkWidget * hseparator; GtkWidget * vseparator; GtkWidget * hbuttonbox; GtkTreeSelection * list_selection; GtkCellRenderer * renderer; GtkTreeViewColumn * column; gchar temp[MAXLEN]; if (aifp_window != NULL) { return; } transfer_mode = mode; songs_size = 0; transfer_active = 0; strcpy(remote_path, "\\"); if (transfer_mode == UPLOAD_MODE) { number_of_songs = aifp_get_number_of_songs(); if (!number_of_songs) { message_dialog(_("Warning"), options.playlist_is_embedded ? GTK_WIDGET(main_window) : GTK_WIDGET(playlist_window), GTK_MESSAGE_WARNING, GTK_BUTTONS_CLOSE, NULL, _("Please select at least one valid song from playlist.")); return; } } if (aifp_check_and_init_device() == -1) { return; } if (transfer_mode == UPLOAD_MODE) { gint k = aifp_check_files(); if (k != number_of_songs) { if (k) { if((number_of_songs-k) == 1) { sprintf(temp, _("One song has format unsupported by your player.\n\nDo you want to proceed?")); } else { sprintf(temp, _("%d of %d songs have format unsupported by your player.\n\nDo you want to proceed?"), number_of_songs-k, number_of_songs); } } else { if (number_of_songs == 1) { sprintf(temp, _("The selected song has format unsupported by your player.\n\nDo you want to proceed?")); } else { sprintf(temp, _("None of the selected songs has format supported by your player.\n\nDo you want to proceed?")); } } gint ret = message_dialog(_("Warning"), options.playlist_is_embedded ? GTK_WIDGET(main_window) : GTK_WIDGET(playlist_window), GTK_MESSAGE_WARNING, GTK_BUTTONS_YES_NO, NULL, temp); if (ret == GTK_RESPONSE_NO || ret == GTK_RESPONSE_DELETE_EVENT) { aifp_close_device(); return; } } } aifp_window = gtk_window_new(GTK_WINDOW_TOPLEVEL); if (transfer_mode == UPLOAD_MODE) { gtk_window_set_title(GTK_WINDOW(aifp_window), _("iFP device manager (upload mode)")); } else { gtk_window_set_title(GTK_WINDOW(aifp_window), _("iFP device manager (download mode)")); } gtk_window_set_position(GTK_WINDOW(aifp_window), GTK_WIN_POS_CENTER_ALWAYS); gtk_window_set_transient_for(GTK_WINDOW(aifp_window), options.playlist_is_embedded ? GTK_WINDOW(main_window) : GTK_WINDOW(playlist_window)); gtk_window_set_modal(GTK_WINDOW(aifp_window), TRUE); g_signal_connect(G_OBJECT(aifp_window), "delete_event", G_CALLBACK(aifp_window_close), NULL); g_signal_connect(G_OBJECT(aifp_window), "key_press_event", G_CALLBACK(aifp_window_key_pressed), NULL); gtk_container_set_border_width(GTK_CONTAINER(aifp_window), 5); gtk_window_set_default_size(GTK_WINDOW(aifp_window), options.ifpmanager_size_x, options.ifpmanager_size_y); vbox1 = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox1); gtk_container_add (GTK_CONTAINER (aifp_window), vbox1); vbox2 = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox2); gtk_box_pack_start (GTK_BOX (vbox1), vbox2, TRUE, TRUE, 0); frame = gtk_frame_new (NULL); gtk_widget_show (frame); gtk_box_pack_start (GTK_BOX (vbox2), frame, FALSE, FALSE, 0); gtk_container_set_border_width (GTK_CONTAINER (frame), 2); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE); alignment = gtk_alignment_new (0.5, 0.5, 1, 1); gtk_widget_show (alignment); gtk_container_add (GTK_CONTAINER (frame), alignment); gtk_container_set_border_width (GTK_CONTAINER (alignment), 4); gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 0, 12, 0); if (transfer_mode == UPLOAD_MODE) { hbox1 = gtk_hbox_new (FALSE, 0); gtk_widget_show (hbox1); gtk_container_add (GTK_CONTAINER (alignment), hbox1); label = gtk_label_new (_("Selected files:")); gtk_widget_show (label); gtk_box_pack_start (GTK_BOX (hbox1), label, FALSE, FALSE, 0); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); label_songs = gtk_label_new ("label_songs"); gtk_widget_show (label_songs); gtk_box_pack_start (GTK_BOX (hbox1), label_songs, FALSE, FALSE, 0); gtk_misc_set_alignment (GTK_MISC (label_songs), 0, 0.5); gtk_misc_set_padding (GTK_MISC (label_songs), 5, 0); label = gtk_label_new (_("<b>Songs info</b>")); gtk_widget_show (label); gtk_frame_set_label_widget (GTK_FRAME (frame), label); gtk_label_set_use_markup (GTK_LABEL (label), TRUE); frame = gtk_frame_new (NULL); gtk_widget_show (frame); gtk_box_pack_start (GTK_BOX (vbox2), frame, FALSE, FALSE, 0); gtk_container_set_border_width (GTK_CONTAINER (frame), 2); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE); alignment = gtk_alignment_new (0.5, 0.5, 1, 1); gtk_widget_show (alignment); gtk_container_add (GTK_CONTAINER (frame), alignment); gtk_container_set_border_width (GTK_CONTAINER (alignment), 4); gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 0, 12, 0); } vbox3 = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox3); gtk_container_add (GTK_CONTAINER (alignment), vbox3); hbox1 = gtk_hbox_new (FALSE, 0); gtk_widget_show (hbox1); gtk_box_pack_start (GTK_BOX (vbox3), hbox1, TRUE, TRUE, 2); label = gtk_label_new (_("Model:")); gtk_widget_show (label); gtk_box_pack_start (GTK_BOX (hbox1), label, FALSE, FALSE, 0); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); label_model = gtk_label_new (NULL); gtk_widget_show (label_model); gtk_box_pack_start (GTK_BOX (hbox1), label_model, FALSE, FALSE, 0); gtk_misc_set_alignment (GTK_MISC (label_model), 0, 0.5); gtk_misc_set_padding (GTK_MISC (label_model), 5, 0); hbox1 = gtk_hbox_new (FALSE, 0); gtk_widget_show (hbox1); gtk_box_pack_start (GTK_BOX (vbox3), hbox1, TRUE, TRUE, 2); progressbar_battery = gtk_progress_bar_new (); gtk_widget_show (progressbar_battery); gtk_box_pack_start (GTK_BOX (hbox1), progressbar_battery, TRUE, TRUE, 2); gtk_widget_set_size_request (progressbar_battery, 70, -1); gtk_progress_bar_set_text (GTK_PROGRESS_BAR (progressbar_battery), _("Battery")); progressbar_freespace = gtk_progress_bar_new (); gtk_widget_show (progressbar_freespace); gtk_box_pack_start (GTK_BOX (hbox1), progressbar_freespace, TRUE, TRUE, 2); gtk_progress_bar_set_text (GTK_PROGRESS_BAR (progressbar_freespace), _("Free space")); label = gtk_label_new (_("<b>Device status</b>")); gtk_widget_show (label); gtk_frame_set_label_widget (GTK_FRAME (frame), label); gtk_label_set_use_markup (GTK_LABEL (label), TRUE); frame = gtk_frame_new (NULL); gtk_widget_show (frame); gtk_box_pack_start (GTK_BOX (vbox2), frame, TRUE, TRUE, 0); gtk_container_set_border_width (GTK_CONTAINER (frame), 2); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE); alignment = gtk_alignment_new (0.5, 0.5, 1, 1); gtk_widget_show (alignment); gtk_container_add (GTK_CONTAINER (frame), alignment); gtk_container_set_border_width (GTK_CONTAINER (alignment), 4); gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 0, 12, 0); hbox1 = gtk_hbox_new (FALSE, 0); gtk_widget_show (hbox1); gtk_container_add (GTK_CONTAINER (alignment), hbox1); scrolledwindow = gtk_scrolled_window_new (NULL, NULL); gtk_widget_show (scrolledwindow); gtk_box_pack_start (GTK_BOX (hbox1), scrolledwindow, TRUE, TRUE, 0); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow), GTK_SHADOW_IN); list_store = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_STRING); list = gtk_tree_view_new_with_model(GTK_TREE_MODEL(list_store)); gtk_widget_show (list); g_signal_connect(G_OBJECT(list), "button_press_event", G_CALLBACK(aifp_list_dbclick_cb), NULL); list_selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (list)); g_signal_connect(G_OBJECT(list_selection), "changed", G_CALLBACK(directory_selected_cb), NULL); gtk_container_add (GTK_CONTAINER (scrolledwindow), list); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(list), TRUE); gtk_tree_view_set_enable_search (GTK_TREE_VIEW(list), FALSE); if (transfer_mode == DOWNLOAD_MODE) { gtk_tree_selection_set_mode(list_selection, GTK_SELECTION_MULTIPLE); } renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes(_("Name"), renderer, "text", COLUMN_NAME, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(list), column); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes(_("Size"), renderer, "text", COLUMN_TYPE_SIZE, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(list), column); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE); vseparator = gtk_vseparator_new (); gtk_widget_show (vseparator); gtk_box_pack_start (GTK_BOX (hbox1), vseparator, FALSE, TRUE, 2); vbox4 = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox4); gtk_box_pack_start (GTK_BOX (hbox1), vbox4, FALSE, FALSE, 0); if (transfer_mode == UPLOAD_MODE) { mkdir_button = gui_stock_label_button(NULL, GTK_STOCK_NEW); gtk_button_set_relief (GTK_BUTTON (mkdir_button), GTK_RELIEF_NONE); gtk_widget_set_can_focus(mkdir_button, FALSE); gtk_widget_show (mkdir_button); g_signal_connect(mkdir_button, "clicked", G_CALLBACK(aifp_create_directory_cb), NULL); gtk_box_pack_start (GTK_BOX (vbox4), mkdir_button, FALSE, FALSE, 0); } rndir_button = gui_stock_label_button(NULL, GTK_STOCK_EDIT); gtk_widget_set_can_focus(rndir_button, FALSE); gtk_button_set_relief (GTK_BUTTON (rndir_button), GTK_RELIEF_NONE); gtk_widget_show (rndir_button); g_signal_connect(rndir_button, "clicked", G_CALLBACK(aifp_rename_item_cb), NULL); gtk_box_pack_start (GTK_BOX (vbox4), rndir_button, FALSE, FALSE, 0); rmdir_button = gui_stock_label_button(NULL, GTK_STOCK_DELETE); gtk_widget_set_can_focus(rmdir_button, FALSE); gtk_button_set_relief (GTK_BUTTON (rmdir_button), GTK_RELIEF_NONE); gtk_widget_show (rmdir_button); g_signal_connect(rmdir_button, "clicked", G_CALLBACK(aifp_remove_item_cb), NULL); gtk_box_pack_start (GTK_BOX (vbox4), rmdir_button, FALSE, FALSE, 0); if (options.enable_tooltips) { if (transfer_mode == UPLOAD_MODE) { aqualung_widget_set_tooltip_text(mkdir_button, _("Create a new directory")); } aqualung_widget_set_tooltip_text(rndir_button, _("Rename")); aqualung_widget_set_tooltip_text(rmdir_button, _("Remove")); } label = gtk_label_new (_("<b>Remote directory</b>")); gtk_widget_show (label); gtk_frame_set_label_widget (GTK_FRAME (frame), label); gtk_label_set_use_markup (GTK_LABEL (label), TRUE); frame = gtk_frame_new (NULL); gtk_widget_show (frame); gtk_box_pack_start (GTK_BOX (vbox2), frame, FALSE, FALSE, 0); gtk_container_set_border_width (GTK_CONTAINER (frame), 2); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE); if (transfer_mode == DOWNLOAD_MODE) { label = gtk_label_new (_("<b>Local directory</b>")); gtk_widget_show (label); gtk_frame_set_label_widget (GTK_FRAME (frame), label); gtk_label_set_use_markup (GTK_LABEL (label), TRUE); frame = gtk_frame_new (NULL); gtk_widget_show (frame); gtk_box_pack_start (GTK_BOX (vbox2), frame, FALSE, FALSE, 0); gtk_container_set_border_width (GTK_CONTAINER (frame), 2); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE); alignment = gtk_alignment_new (0.5, 0.5, 1, 1); gtk_widget_show (alignment); gtk_container_add (GTK_CONTAINER (frame), alignment); gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 0, 12, 0); hbox2 = gtk_hbox_new(FALSE, FALSE); gtk_container_add (GTK_CONTAINER (alignment), hbox2); gtk_widget_show (hbox2); local_path_entry = gtk_entry_new(); gtk_widget_show (local_path_entry); gtk_widget_set_can_focus(local_path_entry, FALSE); gtk_box_pack_start(GTK_BOX(hbox2), local_path_entry, TRUE, TRUE, 2); gtk_editable_set_editable (GTK_EDITABLE(local_path_entry), FALSE); strncpy(dest_dir, options.home, MAXLEN-1); gtk_entry_set_text(GTK_ENTRY(local_path_entry), dest_dir); local_path_browse_button = gui_stock_label_button(_("Browse"), GTK_STOCK_OPEN); gtk_widget_set_can_focus(local_path_browse_button, FALSE); gtk_widget_show (local_path_browse_button); gtk_container_set_border_width(GTK_CONTAINER(local_path_browse_button), 2); g_signal_connect (G_OBJECT(local_path_browse_button), "clicked", G_CALLBACK(local_path_selected_cb), (gpointer)local_path_entry); gtk_box_pack_end(GTK_BOX(hbox2), local_path_browse_button, FALSE, FALSE, 0); } frame = gtk_frame_new (NULL); gtk_widget_show (frame); gtk_box_pack_start (GTK_BOX (vbox2), frame, FALSE, FALSE, 0); gtk_container_set_border_width (GTK_CONTAINER (frame), 2); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE); alignment = gtk_alignment_new (0.5, 0.5, 1, 1); gtk_widget_show (alignment); gtk_container_add (GTK_CONTAINER (frame), alignment); gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 0, 12, 0); table = gtk_table_new (3, 2, FALSE); gtk_widget_show (table); gtk_container_add (GTK_CONTAINER (alignment), table); gtk_container_set_border_width (GTK_CONTAINER (table), 8); gtk_table_set_row_spacings (GTK_TABLE (table), 4); gtk_table_set_col_spacings (GTK_TABLE (table), 4); label = gtk_label_new (_("File name: ")); gtk_widget_show (label); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); label = gtk_label_new (_("Current file: ")); gtk_widget_show (label); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); label = gtk_label_new (_("Overall: ")); gtk_widget_show (label); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); aifp_file_entry = gtk_entry_new(); gtk_widget_set_can_focus(aifp_file_entry, FALSE); gtk_widget_show (aifp_file_entry); gtk_editable_set_editable(GTK_EDITABLE(aifp_file_entry), FALSE); gtk_table_attach (GTK_TABLE (table), aifp_file_entry, 1, 2, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_entry_set_text(GTK_ENTRY(aifp_file_entry), _("None")); progressbar_cf = gtk_progress_bar_new (); gtk_widget_show (progressbar_cf); gtk_progress_bar_set_text (GTK_PROGRESS_BAR (progressbar_cf), _("Idle")); gtk_table_attach (GTK_TABLE (table), progressbar_cf, 1, 2, 1, 2, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); progressbar_op = gtk_progress_bar_new (); gtk_widget_show (progressbar_op); gtk_progress_bar_set_text (GTK_PROGRESS_BAR (progressbar_op), _("Idle")); gtk_table_attach (GTK_TABLE (table), progressbar_op, 1, 2, 2, 3, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); label = gtk_label_new (_("<b>Transfer progress</b>")); gtk_widget_show (label); gtk_frame_set_label_widget (GTK_FRAME (frame), label); gtk_label_set_use_markup (GTK_LABEL (label), TRUE); aifp_close_when_ready_check = gtk_check_button_new_with_label(_("Close window when transfer complete")); gtk_widget_set_can_focus(aifp_close_when_ready_check, FALSE); gtk_widget_set_name(aifp_close_when_ready_check, "check_on_window"); gtk_widget_show(aifp_close_when_ready_check); gtk_box_pack_start(GTK_BOX(vbox2), aifp_close_when_ready_check, FALSE, TRUE, 0); hseparator = gtk_hseparator_new (); gtk_widget_show (hseparator); gtk_box_pack_start (GTK_BOX (vbox1), hseparator, FALSE, TRUE, 3); hbuttonbox = gtk_hbutton_box_new (); gtk_widget_show (hbuttonbox); gtk_box_pack_start (GTK_BOX (vbox1), hbuttonbox, FALSE, TRUE, 0); gtk_container_set_border_width (GTK_CONTAINER (hbuttonbox), 5); gtk_button_box_set_layout (GTK_BUTTON_BOX (hbuttonbox), GTK_BUTTONBOX_END); gtk_box_set_spacing (GTK_BOX (hbuttonbox), 6); if (transfer_mode == UPLOAD_MODE) { upload_download_button = gui_stock_label_button (_("_Upload"), GTK_STOCK_GO_UP); } else { upload_download_button = gui_stock_label_button (_("_Download"), GTK_STOCK_GO_DOWN); } gtk_widget_set_can_focus(upload_download_button, FALSE); gtk_widget_show (upload_download_button); g_signal_connect(upload_download_button, "clicked", G_CALLBACK(upload_download_songs_cb), NULL); gtk_container_add (GTK_CONTAINER (hbuttonbox), upload_download_button); gtk_widget_set_can_default(upload_download_button, TRUE); abort_button = gui_stock_label_button (_("_Abort"), GTK_STOCK_CANCEL); gtk_widget_set_can_focus(abort_button, FALSE); gtk_widget_show (abort_button); g_signal_connect(abort_button, "clicked", G_CALLBACK(abort_transfer_cb), NULL); gtk_container_add (GTK_CONTAINER (hbuttonbox), abort_button); gtk_widget_set_can_default(abort_button, TRUE); close_button = gtk_button_new_from_stock (GTK_STOCK_CLOSE); gtk_widget_set_can_focus(close_button, FALSE); gtk_widget_show (close_button); g_signal_connect(close_button, "clicked", G_CALLBACK(aifp_window_close), NULL); gtk_container_add (GTK_CONTAINER (hbuttonbox), close_button); gtk_widget_set_can_default(close_button, TRUE); gtk_widget_set_sensitive(abort_button, FALSE); gtk_widget_grab_focus(list); aifp_update_info(); aifp_directory_listing (NULL); aifp_check_size(); abort_pressed = 0; remote_type = TYPE_DIR; gtk_widget_show(aifp_window); }
void create_generalpage (GtkNotebook *notebook) { GtkWidget *box1, *box2, *box3, *box4, *thispage; GtkWidget *label, *tmpw, *frame, *table; GSList * radio_group = NULL; label = gtk_label_new_with_mnemonic (_("_General")); thispage = gtk_vbox_new (FALSE, 12); gtk_container_set_border_width (GTK_CONTAINER (thispage), 12); gtk_widget_show (thispage); frame = gimp_frame_new (_("Background")); gtk_box_pack_start (GTK_BOX (thispage), frame, FALSE, FALSE, 0); gtk_widget_show (frame); box3 = gtk_vbox_new (FALSE, 6); gtk_container_add (GTK_CONTAINER (frame), box3); gtk_widget_show (box3); create_general_button (box3, BG_TYPE_KEEP_ORIGINAL, _("Keep original"), _("Preserve the original image as a background"), &radio_group); create_general_button (box3, BG_TYPE_FROM_PAPER, _("From paper"), _("Copy the texture of the selected paper as a background"), &radio_group); box4 = gtk_hbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (box3), box4, FALSE, FALSE, 0); gtk_widget_show (box4); create_general_button (box4, BG_TYPE_SOLID, _("Solid"), _("Solid colored background"), &radio_group); general_color_button = gimp_color_button_new (_("Color"), COLORBUTTONWIDTH, COLORBUTTONHEIGHT, &pcvals.color, GIMP_COLOR_AREA_FLAT); g_signal_connect (general_color_button, "clicked", G_CALLBACK (select_color), NULL); g_signal_connect (general_color_button, "color-changed", G_CALLBACK (gimp_color_button_get_color), &pcvals.color); gtk_box_pack_start (GTK_BOX (box4), general_color_button, FALSE, FALSE, 0); gtk_widget_show (general_color_button); tmpw = create_general_button (box3, BG_TYPE_TRANSPARENT, _("Transparent"), _("Use a transparent background; Only the strokes painted will be visible"), &radio_group); if (!img_has_alpha) gtk_widget_set_sensitive (tmpw, FALSE); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (general_bg_radio[pcvals.general_background_type]), TRUE); box1 = gtk_hbox_new (FALSE, 12); gtk_box_pack_start (GTK_BOX (thispage), box1, FALSE, FALSE, 0); gtk_widget_show (box1); box2 = gtk_vbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0); gtk_widget_show (box2); tmpw = gtk_check_button_new_with_label ( _("Paint edges")); general_paint_edges = tmpw; gtk_box_pack_start (GTK_BOX (box2), tmpw, FALSE, FALSE, 0); gtk_widget_show (tmpw); gimp_help_set_help_data (tmpw, _("Selects if to place strokes all the way out to the edges of the image"), NULL); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (tmpw), pcvals.general_paint_edges); general_tileable = tmpw = gtk_check_button_new_with_label ( _("Tileable")); gtk_box_pack_start (GTK_BOX (box2), tmpw, FALSE, FALSE, 0); gtk_widget_show (tmpw); gimp_help_set_help_data (tmpw, _("Selects if the resulting image should be seamlessly tileable"), NULL); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (tmpw), pcvals.general_tileable); tmpw = gtk_check_button_new_with_label ( _("Drop shadow")); general_drop_shadow = tmpw; gtk_box_pack_start (GTK_BOX (box2), tmpw, FALSE, FALSE, 0); gtk_widget_show (tmpw); gimp_help_set_help_data (tmpw, _("Adds a shadow effect to each brush stroke"), NULL); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (tmpw), pcvals.general_drop_shadow); table = gtk_table_new (5, 3, FALSE); gtk_table_set_col_spacings (GTK_TABLE (table), 6); gtk_table_set_row_spacings (GTK_TABLE (table), 6); gtk_box_pack_start (GTK_BOX (box1), table, FALSE, FALSE, 0); gtk_widget_show (table); general_dark_edge_adjust = gimp_scale_entry_new (GTK_TABLE (table), 0, 0, _("Edge darken:"), 150, 6, pcvals.general_dark_edge, 0.0, 1.0, 0.01, 0.1, 2, TRUE, 0, 0, _("How much to \"darken\" the edges of each brush stroke"), NULL); general_shadow_adjust = gimp_scale_entry_new (GTK_TABLE (table), 0, 1, _("Shadow darken:"), 150, 6, pcvals.general_shadow_darkness, 0.0, 99.0, 0.1, 1, 2, TRUE, 0, 0, _("How much to \"darken\" the drop shadow"), NULL); general_shadow_depth = gimp_scale_entry_new (GTK_TABLE (table), 0, 2, _("Shadow depth:"), 150, 6, pcvals.general_shadow_depth, 0, 99, 1, 5, 0, TRUE, 0, 0, _("The depth of the drop shadow, i.e. how far apart from the object it should be"), NULL); general_shadow_blur = gimp_scale_entry_new (GTK_TABLE (table), 0, 3, _("Shadow blur:"), 150, 6, pcvals.general_shadow_blur, 0, 99, 1, 5, 0, TRUE, 0, 0, _("How much to blur the drop shadow"), NULL); dev_thresh_adjust = gimp_scale_entry_new (GTK_TABLE (table), 0, 4, _("Deviation threshold:"), 150, 6, pcvals.devthresh, 0.0, 1.0, 0.01, 0.01, 2, TRUE, 0, 0, _("A bailout-value for adaptive selections"), NULL); gtk_notebook_append_page_menu (notebook, thispage, label, NULL); }
void Create_side(GtkWidget *widget, GtkWidget *stack){ widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); //widget = gtk_label_new ("Este assistente ira ajuda-lo a Criar um Banco de Dados."); static FZ_Create field;// caso não for static da pau GtkWidget *container_all, *container_label, *container_entry, *label_all ; // Container all container_all = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5); gtk_container_add(GTK_CONTAINER(widget), container_all); // Label's container_label = gtk_box_new(GTK_ORIENTATION_VERTICAL, 8); gtk_widget_set_halign(container_label, GTK_ALIGN_END); gtk_container_add(GTK_CONTAINER(container_all), container_label); /* nome do DB */ label_all = gtk_label_new ("Novo Banco de Dados: "); gtk_widget_set_halign(label_all, GTK_ALIGN_END); gtk_box_pack_start(GTK_BOX(container_label), label_all, FALSE, FALSE, 5); /* Code Builder or password SuperUser */ label_all = gtk_label_new ("Senha Master: "); gtk_widget_set_halign(label_all, GTK_ALIGN_END); gtk_box_pack_start(GTK_BOX(container_label), label_all, FALSE, FALSE, 5); /* ROOT Password */ label_all = gtk_label_new ("Senha do Administrador: "); gtk_widget_set_halign(label_all, GTK_ALIGN_END); gtk_box_pack_start(GTK_BOX(container_label), label_all, FALSE, FALSE, 5); label_all = gtk_label_new ("Confirme a Senha do Administrador: "); gtk_widget_set_halign(label_all, GTK_ALIGN_END); gtk_box_pack_start(GTK_BOX(container_label), label_all, FALSE, FALSE, 5); // Entry's container_entry = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5); gtk_container_add(GTK_CONTAINER(container_all), container_entry); gtk_widget_set_hexpand(container_entry, TRUE); /* nome do DB */ field.entry_db=gtk_entry_new(); gtk_widget_set_tooltip_text(field.entry_db, "Digite o Novo Nome do Banco de Dados."); gtk_entry_set_placeholder_text(GTK_ENTRY(field.entry_db), "Banco de Dados"); gtk_box_pack_start(GTK_BOX(container_entry), field.entry_db, FALSE, FALSE, 0); /* Code Builder or password SuperUser */ field.entry_pwd=gtk_entry_new(); gtk_widget_set_tooltip_text(field.entry_pwd, "Digite a senha de Super Usuario."); gtk_entry_set_visibility(GTK_ENTRY(field.entry_pwd), FALSE); gtk_entry_set_placeholder_text(GTK_ENTRY(field.entry_pwd), "Senha Mestre"); gtk_box_pack_start(GTK_BOX(container_entry), field.entry_pwd, FALSE, FALSE, 0); /* ROOT Password */ field.rootpwd = gtk_entry_new(); gtk_widget_set_tooltip_text(field.rootpwd, "Digite a senha de Adimistrador do Novo Banco de Dados (login:admin)."); gtk_entry_set_placeholder_text(GTK_ENTRY(field.rootpwd), "Senha do Administrador"); gtk_entry_set_visibility(GTK_ENTRY(field.rootpwd), FALSE); gtk_box_pack_start(GTK_BOX(container_entry), field.rootpwd, FALSE, FALSE, 0); /* ROOT Password Reply */ field.rootpwd_reply = gtk_entry_new(); gtk_widget_set_tooltip_text(field.rootpwd_reply, "Digite a senha de Adimistrador do Novo Banco de Dados (login:admin)."); gtk_entry_set_placeholder_text(GTK_ENTRY(field.rootpwd_reply), "Confirme a Senha"); gtk_entry_set_visibility(GTK_ENTRY(field.rootpwd_reply), FALSE); gtk_box_pack_start(GTK_BOX(container_entry), field.rootpwd_reply, FALSE, FALSE, 0); /* Demo info preload */ field.demo = gtk_check_button_new_with_label("Demostração?"); gtk_widget_set_halign(field.demo, GTK_ALIGN_CENTER); gtk_widget_set_tooltip_text(field.demo, "Se na criação as informações de Demostração serão instaladas."); gtk_container_add(GTK_CONTAINER(widget), field.demo); /* Botão de Criar */ field.button = gtk_button_new_with_label ("Criar"); gtk_widget_set_tooltip_text(field.button, "Sera ativado quando as Informações estiverem corretas."); gtk_widget_set_sensitive (field.button, FALSE);// disable button g_signal_connect (GTK_BUTTON (field.button), "clicked", G_CALLBACK (button_create_clicked), (gpointer) &field); gtk_container_add( GTK_CONTAINER(widget) ,field.button ); gtk_stack_add_named (GTK_STACK (stack), widget, "Criar"); gtk_container_child_set (GTK_CONTAINER (stack), widget, "title", "Criar", NULL); /* Validate Focus */ g_signal_connect (GTK_ENTRY (field.entry_db), "focus-out-event", G_CALLBACK (validate_create_focus), (gpointer) &field); g_signal_connect (GTK_ENTRY (field.entry_pwd), "focus-out-event", G_CALLBACK (validate_create_focus), (gpointer) &field); g_signal_connect (GTK_ENTRY (field.rootpwd), "focus-out-event", G_CALLBACK (validate_create_focus), (gpointer) &field); g_signal_connect (GTK_ENTRY (field.rootpwd_reply), "focus-out-event", G_CALLBACK (validate_create_focus), (gpointer) &field); }
void CLogGtk::create_filter_dialog() { if ( filter_form) { g_object_set( filter_form, "visible", TRUE, NULL); return; } // Create the options dialog filter_form = (GtkWidget *) g_object_new( GTK_TYPE_WINDOW, "default-height", 300, "default-width", 450, "title", "Filter Messages", NULL); g_signal_connect( filter_form, "delete_event", G_CALLBACK(filter_delete_event), this); GtkWidget *severity_label = gtk_label_new( "Message Severity"); gtk_misc_set_alignment( GTK_MISC(severity_label), 0.0, 0.05); gtk_widget_set_size_request( severity_label, 140, -1); GtkWidget *string_label = gtk_label_new( "String"); gtk_misc_set_alignment( GTK_MISC(string_label), 0.0, 0.5); gtk_widget_set_size_request( string_label, 140, -1); filter_string_w = gtk_entry_new(); show_success_w = gtk_check_button_new_with_label( "Success"); show_info_w = gtk_check_button_new_with_label( "Info"); show_warning_w = gtk_check_button_new_with_label( "Warning"); show_error_w = gtk_check_button_new_with_label( "Error"); show_fatal_w = gtk_check_button_new_with_label( "Fatal"); show_text_w = gtk_check_button_new_with_label( "Text"); GtkWidget *severity_vbox = gtk_vbox_new( FALSE, 0); gtk_box_pack_start( GTK_BOX(severity_vbox), show_success_w, FALSE, FALSE, 7); gtk_box_pack_start( GTK_BOX(severity_vbox), show_info_w, FALSE, FALSE, 7); gtk_box_pack_start( GTK_BOX(severity_vbox), show_warning_w, FALSE, FALSE, 7); gtk_box_pack_start( GTK_BOX(severity_vbox), show_error_w, FALSE, FALSE, 7); gtk_box_pack_start( GTK_BOX(severity_vbox), show_fatal_w, FALSE, FALSE, 7); gtk_box_pack_start( GTK_BOX(severity_vbox), show_text_w, FALSE, FALSE, 7); GtkWidget *severity_hbox = gtk_hbox_new( FALSE, 0); gtk_box_pack_start( GTK_BOX(severity_hbox), severity_label, FALSE, FALSE, 7); gtk_box_pack_start( GTK_BOX(severity_hbox), severity_vbox, FALSE, FALSE, 7); GtkWidget *string_hbox = gtk_hbox_new( FALSE, 0); gtk_box_pack_start( GTK_BOX(string_hbox), string_label, FALSE, FALSE, 7); gtk_box_pack_start( GTK_BOX(string_hbox), filter_string_w, TRUE, TRUE, 7); GtkWidget *filter_ok = gtk_button_new_with_label( "Ok"); gtk_widget_set_size_request( filter_ok, 70, 25); g_signal_connect( filter_ok, "clicked", G_CALLBACK(filter_ok_cb), this); GtkWidget *filter_apply = gtk_button_new_with_label( "Apply"); gtk_widget_set_size_request( filter_apply, 70, 25); g_signal_connect( filter_apply, "clicked", G_CALLBACK(filter_apply_cb), this); GtkWidget *filter_cancel = gtk_button_new_with_label( "Cancel"); gtk_widget_set_size_request( filter_cancel, 70, 25); g_signal_connect( filter_cancel, "clicked", G_CALLBACK(filter_cancel_cb), this); GtkWidget *filter_hboxbuttons = gtk_hbox_new( TRUE, 40); gtk_box_pack_start( GTK_BOX(filter_hboxbuttons), filter_ok, FALSE, FALSE, 0); gtk_box_pack_start( GTK_BOX(filter_hboxbuttons), filter_apply, FALSE, FALSE, 0); gtk_box_pack_end( GTK_BOX(filter_hboxbuttons), filter_cancel, FALSE, FALSE, 0); GtkWidget *filter_vbox = gtk_vbox_new( FALSE, 0); gtk_box_pack_start( GTK_BOX(filter_vbox), severity_hbox, FALSE, FALSE, 15); gtk_box_pack_start( GTK_BOX(filter_vbox), string_hbox, TRUE, TRUE, 15); gtk_box_pack_start( GTK_BOX(filter_vbox), gtk_hseparator_new(), FALSE, FALSE, 0); gtk_box_pack_end( GTK_BOX(filter_vbox), filter_hboxbuttons, FALSE, FALSE, 15); gtk_container_add( GTK_CONTAINER(filter_form), filter_vbox); gtk_widget_show_all( filter_form); }
int gtkui_run_dialog (GtkWidget *parentwin, ddb_dialog_t *conf, uint32_t buttons, int (*callback)(int button, void *ctx), void *ctx) { if (!parentwin) { parentwin = mainwin; } // create window char title[200]; snprintf (title, sizeof (title), _("Configure %s"), conf->title); GtkWidget *win; if (!buttons) { win = gtk_dialog_new_with_buttons (title, GTK_WINDOW (parentwin), GTK_DIALOG_MODAL, GTK_STOCK_APPLY, GTK_RESPONSE_APPLY, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_default_response (GTK_DIALOG (win), GTK_RESPONSE_OK); } else { win = gtk_dialog_new_with_buttons (title, GTK_WINDOW (parentwin), GTK_DIALOG_MODAL, NULL); if (buttons & (1<<ddb_button_ok)) { gtk_dialog_add_button (GTK_DIALOG (win), GTK_STOCK_OK, GTK_RESPONSE_OK); } if (buttons & (1<<ddb_button_cancel)) { gtk_dialog_add_button (GTK_DIALOG (win), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL); } if (buttons & (1<<ddb_button_close)) { gtk_dialog_add_button (GTK_DIALOG (win), GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE); } if (buttons & (1<<ddb_button_apply)) { gtk_dialog_add_button (GTK_DIALOG (win), GTK_STOCK_APPLY, GTK_RESPONSE_APPLY); } if (buttons & (1<<ddb_button_yes)) { gtk_dialog_add_button (GTK_DIALOG (win), GTK_STOCK_YES, GTK_RESPONSE_YES); } if (buttons & (1<<ddb_button_no)) { gtk_dialog_add_button (GTK_DIALOG (win), GTK_STOCK_NO, GTK_RESPONSE_NO); } } gtk_window_set_type_hint (GTK_WINDOW (win), GDK_WINDOW_TYPE_HINT_DIALOG); gtk_container_set_border_width (GTK_CONTAINER(win), 12); gtk_window_set_title (GTK_WINDOW (win), title); gtk_window_set_modal (GTK_WINDOW (win), TRUE); gtk_window_set_transient_for (GTK_WINDOW (win), GTK_WINDOW (parentwin)); GtkWidget *widgets[100] = {NULL}; int pack[100] = {0}; int ncurr = 0; widgets[ncurr] = gtk_dialog_get_content_area (GTK_DIALOG (win)); gtk_box_set_spacing (GTK_BOX (widgets[ncurr]), 8); GtkWidget *action_area = gtk_dialog_get_action_area (GTK_DIALOG (win)); gtk_widget_show (action_area); gtk_button_box_set_layout (GTK_BUTTON_BOX (action_area), GTK_BUTTONBOX_END); // parse script char token[MAX_TOKEN]; const char *script = conf->layout; parser_line = 1; while (script = gettoken (script, token)) { if (strcmp (token, "property")) { fprintf (stderr, "invalid token while loading plugin %s config dialog: %s at line %d\n", conf->title, token, parser_line); break; } char labeltext[MAX_TOKEN]; script = gettoken_warn_eof (script, labeltext); if (!script) { break; } if (ncurr > 0) { pack[ncurr]--; if (pack[ncurr] < 0) { ncurr--; } } char type[MAX_TOKEN]; script = gettoken_warn_eof (script, type); if (!script) { break; } if (!strncmp (type, "hbox[", 5) || !strncmp (type, "vbox[", 5)) { ncurr++; int n = 0; if (1 != sscanf (type+4, "[%d]", &n)) { break; } pack[ncurr] = n; int vert = 0; int hmg = FALSE; int fill = FALSE; int expand = FALSE; int border = 0; int spacing = 8; int height = 100; char param[MAX_TOKEN]; for (;;) { script = gettoken_warn_eof (script, param); if (!script) { break; } if (!strcmp (param, ";")) { break; } else if (!strcmp (param, "hmg")) { hmg = TRUE; } else if (!strcmp (param, "fill")) { fill = TRUE; } else if (!strcmp (param, "expand")) { expand = TRUE; } else if (!strncmp (param, "border=", 7)) { border = atoi (param+7); } else if (!strncmp (param, "spacing=", 8)) { spacing = atoi (param+8); } else if (!strncmp (param, "height=", 7)) { height = atoi (param+7); } } widgets[ncurr] = vert ? gtk_vbox_new (TRUE, spacing) : gtk_hbox_new (TRUE, spacing); gtk_widget_set_size_request (widgets[ncurr], -1, height); gtk_widget_show (widgets[ncurr]); gtk_box_pack_start (GTK_BOX(widgets[ncurr-1]), widgets[ncurr], fill, expand, border); continue; } int vertical = 0; char key[MAX_TOKEN]; for (;;) { script = gettoken_warn_eof (script, key); if (!script) { break; } if (!strcmp (key, "vert")) { vertical = 1; } else { break; } } char def[MAX_TOKEN]; script = gettoken_warn_eof (script, def); if (!script) { break; } // add to dialog GtkWidget *label = NULL; GtkWidget *prop = NULL; GtkWidget *cont = NULL; char value[1000]; conf->get_param (key, value, sizeof (value), def); if (!strcmp (type, "entry") || !strcmp (type, "password")) { label = gtk_label_new (_(labeltext)); gtk_widget_show (label); prop = gtk_entry_new (); gtk_entry_set_activates_default (GTK_ENTRY (prop), TRUE); g_signal_connect (G_OBJECT (prop), "changed", G_CALLBACK (prop_changed), win); gtk_widget_show (prop); gtk_entry_set_text (GTK_ENTRY (prop), value); if (!strcmp (type, "password")) { gtk_entry_set_visibility (GTK_ENTRY (prop), FALSE); } } else if (!strcmp (type, "checkbox")) { prop = gtk_check_button_new_with_label (_(labeltext)); g_signal_connect (G_OBJECT (prop), "toggled", G_CALLBACK (prop_changed), win); gtk_widget_show (prop); int val = atoi (value); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (prop), val); } else if (!strcmp (type, "file")) { label = gtk_label_new (_(labeltext)); gtk_widget_show (label); if (deadbeef->conf_get_int ("gtkui.pluginconf.use_filechooser_button", 0)) { prop = gtk_file_chooser_button_new (_(labeltext), GTK_FILE_CHOOSER_ACTION_OPEN); gtk_widget_show (prop); gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (prop), value); g_signal_connect (G_OBJECT (prop), "file-set", G_CALLBACK (prop_changed), win); } else { cont = gtk_hbox_new (FALSE, 2); gtk_widget_show (cont); prop = gtk_entry_new (); gtk_entry_set_activates_default (GTK_ENTRY (prop), TRUE); g_signal_connect (G_OBJECT (prop), "changed", G_CALLBACK (prop_changed), win); gtk_widget_show (prop); gtk_editable_set_editable (GTK_EDITABLE (prop), FALSE); gtk_entry_set_text (GTK_ENTRY (prop), value); gtk_box_pack_start (GTK_BOX (cont), prop, TRUE, TRUE, 0); GtkWidget *btn = gtk_button_new_with_label ("…"); gtk_widget_show (btn); gtk_box_pack_start (GTK_BOX (cont), btn, FALSE, FALSE, 0); g_signal_connect (G_OBJECT (btn), "clicked", G_CALLBACK (on_prop_browse_file), prop); } } else if (!strncmp (type, "select[", 7)) { int n; if (1 != sscanf (type+6, "[%d]", &n)) { break; } label = gtk_label_new (_(labeltext)); gtk_widget_show (label); prop = gtk_combo_box_text_new (); gtk_widget_show (prop); for (int i = 0; i < n; i++) { char entry[MAX_TOKEN]; script = gettoken_warn_eof (script, entry); if (!script) { break; } gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (prop), entry); } if (!script) { break; } gtk_combo_box_set_active (GTK_COMBO_BOX (prop), atoi (value)); g_signal_connect ((gpointer) prop, "changed", G_CALLBACK (prop_changed), win); } else if (!strncmp (type, "hscale[", 7) || !strncmp (type, "vscale[", 7) || !strncmp (type, "spinbtn[", 8)) { float min, max, step; const char *args; if (type[0] == 's') { args = type + 7; } else { args = type + 6; } if (3 != sscanf (args, "[%f,%f,%f]", &min, &max, &step)) { break; } int invert = 0; if (min >= max) { float tmp = min; min = max; max = tmp; invert = 1; } if (step <= 0) { step = 1; } if (type[0] == 's') { prop = gtk_spin_button_new_with_range (min, max, step); gtk_spin_button_set_value (GTK_SPIN_BUTTON (prop), atof (value)); } else { prop = type[0] == 'h' ? gtk_hscale_new_with_range (min, max, step) : gtk_vscale_new_with_range (min, max, step); if (invert) { gtk_range_set_inverted (GTK_RANGE (prop), TRUE); } gtk_range_set_value (GTK_RANGE (prop), (gdouble)atof (value)); gtk_scale_set_value_pos (GTK_SCALE (prop), GTK_POS_RIGHT); } label = gtk_label_new (_(labeltext)); gtk_widget_show (label); g_signal_connect (G_OBJECT (prop), "value-changed", G_CALLBACK (prop_changed), win); gtk_widget_show (prop); } script = gettoken_warn_eof (script, token); if (!script) { break; } if (strcmp (token, ";")) { fprintf (stderr, "expected `;' while loading plugin %s config dialog: %s at line %d\n", conf->title, token, parser_line); break; } if (label && prop) { GtkWidget *hbox = NULL; hbox = vertical ? gtk_vbox_new (FALSE, 8) : gtk_hbox_new (FALSE, 8); gtk_widget_show (hbox); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (hbox), cont ? cont : prop, TRUE, TRUE, 0); cont = hbox; } else { cont = prop; } if (prop) { g_object_set_data (G_OBJECT (win), key, prop); } if (cont) { gtk_box_pack_start (GTK_BOX (widgets[ncurr]), cont, FALSE, FALSE, 0); } } int response; do { gtk_dialog_set_response_sensitive (GTK_DIALOG (win), GTK_RESPONSE_APPLY, FALSE); response = gtk_dialog_run (GTK_DIALOG (win)); if (response == GTK_RESPONSE_APPLY || response == GTK_RESPONSE_OK) { apply_conf (win, conf); } if (callback) { int btn = ddb_button_from_gtk_response (response); if (!callback (btn, ctx)) { break; } } } while (response == GTK_RESPONSE_APPLY); gtk_widget_destroy (win); int btn = ddb_button_from_gtk_response (response); return btn; }
static void add_option_to_table(gpointer data, gpointer user_data) { event_option_t *option = data; GtkGrid *option_table = user_data; if (option->is_advanced) option_table = GTK_GRID(g_object_get_data(G_OBJECT(option_table), "advanced-options")); GtkWidget *label; GtkWidget *option_input; unsigned last_row; char *option_label; if (option->eo_label != NULL) option_label = xstrdup(option->eo_label); else { option_label = xstrdup(option->eo_name ? option->eo_name : ""); /* Replace '_' with ' ' */ char *p = option_label - 1; while (*++p) if (*p == '_') *p = ' '; } switch (option->eo_type) { case OPTION_TYPE_TEXT: case OPTION_TYPE_NUMBER: case OPTION_TYPE_PASSWORD: last_row = add_one_row_to_grid(option_table); label = gtk_label_new_justify_left(option_label); gtk_grid_attach(option_table, label, /*left,top:*/ 0, last_row, /*width,height:*/ 1, 1); option_input = gtk_entry_new(); gtk_widget_set_hexpand(option_input, TRUE); if (option->eo_value != NULL) gtk_entry_set_text(GTK_ENTRY(option_input), option->eo_value); gtk_grid_attach(option_table, option_input, /*left,top:*/ 1, last_row, /*width,height:*/ 1, 1); g_option_list = add_option_widget(g_option_list, option_input, option); if (option->eo_type == OPTION_TYPE_PASSWORD) { gtk_entry_set_visibility(GTK_ENTRY(option_input), 0); last_row = add_one_row_to_grid(option_table); GtkWidget *pass_cb = gtk_check_button_new_with_label(_("Show password")); gtk_grid_attach(option_table, pass_cb, /*left,top:*/ 1, last_row, /*width,height:*/ 1, 1); g_signal_connect(pass_cb, "toggled", G_CALLBACK(on_show_pass_cb), option_input); has_password_option = true; } break; case OPTION_TYPE_HINT_HTML: label = gtk_label_new(option_label); gtk_label_set_use_markup(GTK_LABEL(label), TRUE); gtk_misc_set_alignment(GTK_MISC(label), /*x,yalign:*/ 0.0, 0.0); make_label_autowrap_on_resize(GTK_LABEL(label)); last_row = add_one_row_to_grid(option_table); gtk_grid_attach(option_table, label, /*left,top:*/ 0, last_row, /*width,height:*/ 2, 1); break; case OPTION_TYPE_BOOL: last_row = add_one_row_to_grid(option_table); option_input = gtk_check_button_new_with_label(option_label); gtk_grid_attach(option_table, option_input, /*left,top:*/ 0, last_row, /*width,height:*/ 2, 1); if (option->eo_value != NULL) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(option_input), string_to_bool(option->eo_value)); g_option_list = add_option_widget(g_option_list, option_input, option); break; default: //option_input = gtk_label_new_justify_left("WTF?"); log("unsupported option type"); free(option_label); return; } if (option->eo_note_html) { label = gtk_label_new(option->eo_note_html); gtk_label_set_use_markup(GTK_LABEL(label), TRUE); gtk_misc_set_alignment(GTK_MISC(label), /*x,yalign:*/ 0.0, 0.0); make_label_autowrap_on_resize(GTK_LABEL(label)); last_row = add_one_row_to_grid(option_table); gtk_grid_attach(option_table, label, /*left,top:*/ 1, last_row, /*top,heigh:*/ 1, 1); } free(option_label); }
void gui_init(struct dt_iop_module_t *self) { self->gui_data = malloc(sizeof(dt_iop_exposure_gui_data_t)); dt_iop_exposure_gui_data_t *g = (dt_iop_exposure_gui_data_t *)self->gui_data; dt_iop_exposure_params_t *p = (dt_iop_exposure_params_t *)self->params; /* register hooks with current dev so that histogram can interact with this module. */ darktable.develop->proxy.exposure.module = self; darktable.develop->proxy.exposure.set_white = dt_iop_exposure_set_white; darktable.develop->proxy.exposure.get_white = dt_iop_exposure_get_white; darktable.develop->proxy.exposure.set_black = dt_iop_exposure_set_black; darktable.develop->proxy.exposure.get_black = dt_iop_exposure_get_black; self->request_color_pick = 0; self->widget = GTK_WIDGET(gtk_hbox_new(FALSE, 0)); g->vbox2 = GTK_VBOX(gtk_vbox_new(TRUE, DT_GUI_IOP_MODULE_CONTROL_SPACING)); gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(g->vbox2), TRUE, TRUE, 5); g->black = DTGTK_SLIDER(dtgtk_slider_new_with_range( DARKTABLE_SLIDER_BAR, -0.1, 0.1, .001, p->black, 3)); g_object_set(G_OBJECT(g->black), "tooltip-text", _("adjust the black level"), (char *)NULL); dtgtk_slider_set_label(g->black,_("black")); g->exposure = DTGTK_SLIDER(dtgtk_slider_new_with_range( DARKTABLE_SLIDER_BAR, -9.0, 9.0, .02, p->exposure, 3)); g_object_set(G_OBJECT(g->exposure), "tooltip-text", _("adjust the exposure correction"), (char *)NULL); dtgtk_slider_set_label(g->exposure,_("exposure")); dtgtk_slider_set_unit(g->exposure,"EV"); gtk_box_pack_start(GTK_BOX(g->vbox2), GTK_WIDGET(g->black), TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(g->vbox2), GTK_WIDGET(g->exposure), TRUE, TRUE, 0); g->autoexp = GTK_CHECK_BUTTON(gtk_check_button_new_with_label(_("auto"))); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->autoexp), FALSE); g->autoexpp = DTGTK_SLIDER(dtgtk_slider_new_with_range(DARKTABLE_SLIDER_BAR,0.0, 0.2, .001, 0.01,3)); g_object_set(G_OBJECT(g->autoexpp), "tooltip-text", _("percentage of bright values clipped out"), (char *)NULL); gtk_widget_set_sensitive(GTK_WIDGET(g->autoexpp), FALSE); GtkHBox *hbox = GTK_HBOX(gtk_hbox_new(FALSE, 0)); gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(g->autoexp), TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(g->autoexpp), TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(g->vbox2), GTK_WIDGET(hbox), TRUE, TRUE, 0); darktable.gui->reset = 1; self->gui_update(self); darktable.gui->reset = 0; g_signal_connect (G_OBJECT (g->black), "value-changed", G_CALLBACK (black_callback), self); g_signal_connect (G_OBJECT (g->exposure), "value-changed", G_CALLBACK (exposure_callback), self); // g_signal_connect (G_OBJECT (g->scale3), "value-changed", // G_CALLBACK (gain_callback), self); g_signal_connect (G_OBJECT (g->autoexpp), "value-changed", G_CALLBACK (autoexpp_callback), self); g_signal_connect (G_OBJECT (g->autoexp), "toggled", G_CALLBACK (autoexp_callback), self); g_signal_connect (G_OBJECT(self->widget), "expose-event", G_CALLBACK(expose), self); }
static GtkWidget *_lib_import_get_extra_widget(dt_lib_import_metadata_t *data, gboolean import_folder) { // add extra lines to 'extra'. don't forget to destroy the widgets later. GtkWidget *expander = gtk_expander_new(_("import options")); gtk_expander_set_expanded(GTK_EXPANDER(expander), dt_conf_get_bool("ui_last/import_options_expanded")); GtkWidget *frame = gtk_frame_new(NULL); gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_IN); gtk_widget_set_hexpand(frame, TRUE); GtkWidget *event_box = gtk_event_box_new(); gtk_widget_set_margin_start(event_box, DT_PIXEL_APPLY_DPI(8)); gtk_widget_set_margin_end(event_box, DT_PIXEL_APPLY_DPI(8)); gtk_widget_set_margin_top(event_box, DT_PIXEL_APPLY_DPI(8)); gtk_widget_set_margin_bottom(event_box, DT_PIXEL_APPLY_DPI(8)); gtk_container_add(GTK_CONTAINER(frame), event_box); gtk_container_add(GTK_CONTAINER(event_box), expander); GtkWidget *extra; extra = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); gtk_container_add(GTK_CONTAINER(expander), extra); gtk_widget_set_margin_start(extra, DT_PIXEL_APPLY_DPI(8)); gtk_widget_set_margin_end(extra, DT_PIXEL_APPLY_DPI(8)); gtk_widget_set_margin_top(extra, DT_PIXEL_APPLY_DPI(8)); gtk_widget_set_margin_bottom(extra, DT_PIXEL_APPLY_DPI(8)); GtkWidget *recursive = NULL, *ignore_jpeg = NULL; if(import_folder == TRUE) { // recursive opening. recursive = gtk_check_button_new_with_label(_("import directories recursively")); g_object_set(recursive, "tooltip-text", _("recursively import subdirectories. each directory goes into a new film roll."), NULL); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(recursive), dt_conf_get_bool("ui_last/import_recursive")); gtk_box_pack_start(GTK_BOX(extra), recursive, FALSE, FALSE, 0); // ignoring of jpegs. hack while we don't handle raw+jpeg in the same directories. ignore_jpeg = gtk_check_button_new_with_label(_("ignore JPEG files")); g_object_set(ignore_jpeg, "tooltip-text", _("do not load files with an extension of .jpg or .jpeg. this " "can be useful when there are raw+JPEG in a directory."), NULL); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(ignore_jpeg), dt_conf_get_bool("ui_last/import_ignore_jpegs")); gtk_box_pack_start(GTK_BOX(extra), ignore_jpeg, FALSE, FALSE, 0); } // default metadata GtkWidget *apply_metadata; GtkWidget *grid, *label, *creator, *publisher, *rights, *tags; apply_metadata = gtk_check_button_new_with_label(_("apply metadata on import")); g_object_set(apply_metadata, "tooltip-text", _("apply some metadata to all newly imported images."), NULL); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(apply_metadata), dt_conf_get_bool("ui_last/import_apply_metadata")); gtk_box_pack_start(GTK_BOX(extra), apply_metadata, FALSE, FALSE, 0); GValue value = { 0, }; g_value_init(&value, G_TYPE_INT); gtk_widget_style_get_property(apply_metadata, "indicator-size", &value); gint indicator_size = g_value_get_int(&value); gtk_widget_style_get_property(apply_metadata, "indicator-spacing", &value); gint indicator_spacing = g_value_get_int(&value); g_value_unset(&value); grid = gtk_grid_new(); gtk_grid_set_row_spacing(GTK_GRID(grid), DT_PIXEL_APPLY_DPI(5)); gtk_grid_set_column_spacing(GTK_GRID(grid), DT_PIXEL_APPLY_DPI(10)); gtk_widget_set_margin_start(grid, 2 * (indicator_spacing + indicator_size)); gtk_box_pack_start(GTK_BOX(extra), grid, FALSE, FALSE, 0); creator = gtk_entry_new(); gtk_widget_set_size_request(creator, DT_PIXEL_APPLY_DPI(300), -1); gchar *str = dt_conf_get_string("ui_last/import_last_creator"); gtk_entry_set_text(GTK_ENTRY(creator), str); g_free(str); publisher = gtk_entry_new(); str = dt_conf_get_string("ui_last/import_last_publisher"); gtk_entry_set_text(GTK_ENTRY(publisher), str); g_free(str); rights = gtk_entry_new(); str = dt_conf_get_string("ui_last/import_last_rights"); gtk_entry_set_text(GTK_ENTRY(rights), str); g_free(str); tags = gtk_entry_new(); str = dt_conf_get_string("ui_last/import_last_tags"); g_object_set(tags, "tooltip-text", _("comma separated list of tags"), NULL); gtk_entry_set_text(GTK_ENTRY(tags), str); g_free(str); // presets from the metadata plugin GtkCellRenderer *renderer; GtkTreeIter iter; GtkListStore *model = gtk_list_store_new(N_COLUMNS, G_TYPE_STRING /*name*/, G_TYPE_STRING /*creator*/, G_TYPE_STRING /*publisher*/, G_TYPE_STRING /*rights*/); GtkWidget *presets = gtk_combo_box_new_with_model(GTK_TREE_MODEL(model)); renderer = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(presets), renderer, FALSE); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(presets), renderer, "text", NAME_COLUMN, NULL); sqlite3_stmt *stmt; DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db), "select name, op_params from presets where operation = \"metadata\"", -1, &stmt, NULL); while(sqlite3_step(stmt) == SQLITE_ROW) { void *op_params = (void *)sqlite3_column_blob(stmt, 1); int32_t op_params_size = sqlite3_column_bytes(stmt, 1); char *buf = (char *)op_params; char *title = buf; buf += strlen(title) + 1; char *description = buf; buf += strlen(description) + 1; char *rights = buf; buf += strlen(rights) + 1; char *creator = buf; buf += strlen(creator) + 1; char *publisher = buf; if(op_params_size == strlen(title) + strlen(description) + strlen(rights) + strlen(creator) + strlen(publisher) + 5) { gtk_list_store_append(model, &iter); gtk_list_store_set(model, &iter, NAME_COLUMN, (char *)sqlite3_column_text(stmt, 0), CREATOR_COLUMN, creator, PUBLISHER_COLUMN, publisher, RIGHTS_COLUMN, rights, -1); } } sqlite3_finalize(stmt); g_object_unref(model); int line = 0; label = gtk_label_new(_("preset")); gtk_widget_set_halign(label, GTK_ALIGN_START); gtk_grid_attach(GTK_GRID(grid), label, 0, line++, 1, 1); gtk_grid_attach_next_to(GTK_GRID(grid), presets, label, GTK_POS_RIGHT, 1, 1); label = gtk_label_new(_("creator")); gtk_widget_set_halign(label, GTK_ALIGN_START); gtk_grid_attach(GTK_GRID(grid), label, 0, line++, 1, 1); gtk_grid_attach_next_to(GTK_GRID(grid), creator, label, GTK_POS_RIGHT, 1, 1); label = gtk_label_new(_("publisher")); gtk_widget_set_halign(label, GTK_ALIGN_START); gtk_grid_attach(GTK_GRID(grid), label, 0, line++, 1, 1); gtk_grid_attach_next_to(GTK_GRID(grid), publisher, label, GTK_POS_RIGHT, 1, 1); label = gtk_label_new(_("rights")); gtk_widget_set_halign(label, GTK_ALIGN_START); gtk_grid_attach(GTK_GRID(grid), label, 0, line++, 1, 1); gtk_grid_attach_next_to(GTK_GRID(grid), rights, label, GTK_POS_RIGHT, 1, 1); label = gtk_label_new(_("tags")); gtk_widget_set_halign(label, GTK_ALIGN_START); gtk_grid_attach(GTK_GRID(grid), label, 0, line, 1, 1); gtk_grid_attach_next_to(GTK_GRID(grid), tags, label, GTK_POS_RIGHT, 1, 1); gtk_widget_show_all(frame); if(data != NULL) { data->frame = frame; data->recursive = recursive; data->ignore_jpeg = ignore_jpeg; data->expander = expander; data->apply_metadata = apply_metadata; data->presets = presets; data->creator = creator; data->publisher = publisher; data->rights = rights; data->tags = tags; } g_signal_connect(apply_metadata, "toggled", G_CALLBACK(_lib_import_apply_metadata_toggled), grid); // needed since the apply_metadata starts being turned off, and setting it to off doesn't emit the 'toggled' signal ... _lib_import_apply_metadata_toggled(apply_metadata, grid); g_signal_connect(presets, "changed", G_CALLBACK(_lib_import_presets_changed), data); g_signal_connect(GTK_ENTRY(creator), "changed", G_CALLBACK(_lib_import_metadata_changed), presets); g_signal_connect(GTK_ENTRY(publisher), "changed", G_CALLBACK(_lib_import_metadata_changed), presets); g_signal_connect(GTK_ENTRY(rights), "changed", G_CALLBACK(_lib_import_metadata_changed), presets); return frame; }
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), GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, GTK_STOCK_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(dialog)->vbox), 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(); }