/**
* 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();
}
