static void
brasero_project_type_chooser_init (BraseroProjectTypeChooser *obj)
{
GtkRecentManager *recent;
GtkWidget *project_box;
GtkWidget *recent_box;
GtkWidget *separator;
GtkWidget *widget;
GtkWidget *table;
GtkWidget *label;
GtkWidget *vbox;
int nb_rows = 1;
gchar *string;
int nb_items;
int rows;
int i;
obj->priv = g_new0 (BraseroProjectTypeChooserPrivate, 1);
/* Project box */
project_box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_widget_show (project_box);
gtk_box_pack_start (GTK_BOX (obj), project_box, FALSE, TRUE, 0);
string = g_strdup_printf ("<span size='x-large'><b>%s</b></span>", _("Create a new project:"));
label = gtk_label_new (string);
g_free (string);
gtk_widget_show (label);
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.0);
gtk_misc_set_padding (GTK_MISC (label), 6.0, 0.0);
gtk_box_pack_start (GTK_BOX (project_box), label, FALSE, TRUE, 0);
/* get the number of rows */
nb_items = sizeof (items) / sizeof (ItemDescription);
rows = nb_items / nb_rows;
if (nb_items % nb_rows)
rows ++;
table = gtk_table_new (rows, nb_rows, TRUE);
gtk_container_set_border_width (GTK_CONTAINER (table), 6);
gtk_box_pack_start (GTK_BOX (project_box), table, FALSE, TRUE, 0);
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
gtk_table_set_row_spacings (GTK_TABLE (table), 4);
for (i = 0; i < nb_items; i ++) {
widget = brasero_project_type_chooser_new_item (obj, items + i);
gtk_table_attach (GTK_TABLE (table),
widget,
i % nb_rows,
i % nb_rows + 1,
i / nb_rows,
i / nb_rows + 1,
GTK_EXPAND|GTK_FILL,
GTK_FILL,
0,
0);
}
gtk_widget_show_all (table);
separator = gtk_separator_new (GTK_ORIENTATION_VERTICAL);
gtk_widget_show (separator);
gtk_box_pack_start (GTK_BOX (obj), separator, FALSE, TRUE, 2);
/* The recent files part */
recent_box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_widget_show (recent_box);
gtk_box_pack_start (GTK_BOX (obj), recent_box, TRUE, TRUE, 0);
string = g_strdup_printf ("<span size='x-large'><b>%s</b></span>", _("Recent projects:"));
label = gtk_label_new (string);
g_free (string);
gtk_widget_show (label);
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.0);
gtk_misc_set_padding (GTK_MISC (label), 6.0, 0.0);
gtk_box_pack_start (GTK_BOX (recent_box), label, FALSE, TRUE, 0);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_widget_show (vbox);
gtk_box_pack_start (GTK_BOX (recent_box), vbox, FALSE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 6);
obj->priv->recent_box = vbox;
recent = gtk_recent_manager_get_default ();
brasero_project_type_chooser_build_recent (obj, recent);
g_signal_connect (recent,
"changed",
G_CALLBACK (brasero_project_type_chooser_recent_changed_cb),
obj);
}
GtkWidget *create_mystyle_editor_interface (GtkWidget *
mystyle_editor
/* assumed descendand from vbox */
)
{
/* GtkWidget *mystyle_editor; */
ASGtkMyStyleEdit *asgtk_mystyle_editor =
ASGTK_MYSTYLE_EDIT (mystyle_editor);
/*-- hand edit end --*/
GtkWidget *vbox;
GtkWidget *hbox1_mystyle_name;
GtkWidget *label_mystyle;
GtkWidget *entry_mystyle_name;
GtkWidget *hbox2_overlay;
GtkWidget *tgl2_overlay;
GtkWidget *label_overlay;
GtkWidget *combo_overlay_mystyle;
GtkWidget *hbox3_inherit;
GtkWidget *tgl3_inherit;
GtkWidget *label_inherit;
GtkWidget *sw_inherit_list;
GtkWidget *tw_inherit_list;
GtkWidget *btn_inherit_add;
GtkWidget *image3;
GtkWidget *btn_inherit_remove;
GtkWidget *image4;
GtkWidget *hbox4_font;
GtkWidget *tgl4_font;
GtkWidget *label_font;
GtkWidget *btn_font_name;
GtkWidget *label_font_size;
GtkObject *spin_font_size_adj;
GtkWidget *spin_font_size;
GtkWidget *hbox5_colors;
GtkWidget *tgl5_colors;
GtkWidget *label_colors_fore;
GtkWidget *img_fore_color;
GtkWidget *btn_fore_color;
GtkWidget *label_colors_back;
GtkWidget *img_back_color;
GtkWidget *btn_back_color;
GtkWidget *hbox6_shadow;
GtkWidget *tgl5_shadow;
GtkWidget *label_shadow;
GtkWidget *combo_shadow_type;
GtkWidget *hbox7_background;
GtkWidget *tgl7_background;
GtkWidget *label_background;
GtkWidget *combo_background_type;
GtkWidget *hbox8_grad_details;
GtkWidget *arrow1_grad_details;
GtkWidget *btn_grad_color1;
GtkWidget *label_to1;
GtkWidget *btn_grad_color2;
GtkWidget *label1_to2;
GtkWidget *btn_grad_color3;
GtkWidget *btn_grad_edit;
GtkWidget *hbox9_texture_file;
GtkWidget *arrow2_texture_file;
GtkWidget *label_texture_file;
GtkWidget *filechooserbtn_texture_file;
GtkWidget *hbox10_texture_blend_type;
GtkWidget *arrow3_texture_blend_type;
GtkWidget *label_texture_blend_type;
GtkWidget *combo_texture_blend_type;
GtkWidget *table1_texture_slicing;
GtkWidget *label1_texture_slicing_x;
GtkObject *spin_texture_slicing_x_start_adj;
GtkWidget *spin_texture_slicing_x_start;
GtkWidget *label_texture_slicing_x2;
GtkObject *spin_texture_slicing_x_end_adj;
GtkWidget *spin_texture_slicing_x_end;
GtkWidget *label_texture_slicing_y;
GtkObject *spin_texture_slicing_y_start_adj;
GtkWidget *spin_texture_slicing_y_start;
GtkWidget *label_texture_slicing_y2;
GtkObject *spin_texture_slicing_y_end_adj;
GtkWidget *spin_texture_slicing_y_end;
GtkWidget *arrow5_texture_slicing;
/*-- hand edit begin --*/
/* mystyle_editor = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_widget_set_size_request (mystyle_editor, 340, 360);
gtk_window_set_title (GTK_WINDOW (mystyle_editor), "MyStyle Editor");
vbox = gtk_vbox_new (FALSE, 1);
gtk_widget_show (vbox);
gtk_container_add (GTK_CONTAINER (mystyle_editor), vbox);
*/
if (asgtk_mystyle_editor == NULL || GTK_VBOX (mystyle_editor) == NULL)
return NULL;
vbox = mystyle_editor;
/*-- hand edit end --*/
gtk_container_set_border_width (GTK_CONTAINER (vbox), 3);
hbox1_mystyle_name = gtk_hbox_new (FALSE, 4);
gtk_widget_show (hbox1_mystyle_name);
gtk_box_pack_start (GTK_BOX (vbox), hbox1_mystyle_name, FALSE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (hbox1_mystyle_name), 2);
label_mystyle = gtk_label_new ("MyStyle");
gtk_widget_show (label_mystyle);
gtk_box_pack_start (GTK_BOX (hbox1_mystyle_name), label_mystyle, FALSE,
FALSE, 0);
gtk_label_set_justify (GTK_LABEL (label_mystyle), GTK_JUSTIFY_RIGHT);
gtk_misc_set_padding (GTK_MISC (label_mystyle), 5, 0);
entry_mystyle_name = gtk_entry_new ();
gtk_widget_show (entry_mystyle_name);
gtk_box_pack_start (GTK_BOX (hbox1_mystyle_name), entry_mystyle_name,
TRUE, TRUE, 0);
gtk_entry_set_has_frame (GTK_ENTRY (entry_mystyle_name), FALSE);
gtk_entry_set_invisible_char (GTK_ENTRY (entry_mystyle_name), 9679);
hbox2_overlay = gtk_hbox_new (FALSE, 5);
gtk_widget_show (hbox2_overlay);
gtk_box_pack_start (GTK_BOX (vbox), hbox2_overlay, FALSE, TRUE, 0);
tgl2_overlay = gtk_toggle_button_new_with_mnemonic ("[-]");
gtk_widget_show (tgl2_overlay);
gtk_box_pack_start (GTK_BOX (hbox2_overlay), tgl2_overlay, FALSE, FALSE,
0);
gtk_button_set_relief (GTK_BUTTON (tgl2_overlay), GTK_RELIEF_HALF);
label_overlay = gtk_label_new ("overlayed by");
gtk_widget_show (label_overlay);
gtk_box_pack_start (GTK_BOX (hbox2_overlay), label_overlay, FALSE, FALSE,
0);
combo_overlay_mystyle = gtk_combo_box_new_text ();
gtk_widget_show (combo_overlay_mystyle);
gtk_box_pack_start (GTK_BOX (hbox2_overlay), combo_overlay_mystyle, TRUE,
TRUE, 0);
hbox3_inherit = gtk_hbox_new (FALSE, 5);
gtk_widget_show (hbox3_inherit);
gtk_box_pack_start (GTK_BOX (vbox), hbox3_inherit, FALSE, TRUE, 0);
tgl3_inherit = gtk_toggle_button_new_with_mnemonic ("[-]");
gtk_widget_show (tgl3_inherit);
gtk_box_pack_start (GTK_BOX (hbox3_inherit), tgl3_inherit, FALSE, FALSE,
0);
gtk_button_set_relief (GTK_BUTTON (tgl3_inherit), GTK_RELIEF_HALF);
label_inherit = gtk_label_new ("Inherits ");
gtk_widget_show (label_inherit);
gtk_box_pack_start (GTK_BOX (hbox3_inherit), label_inherit, FALSE, FALSE,
0);
sw_inherit_list = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_show (sw_inherit_list);
gtk_box_pack_start (GTK_BOX (hbox3_inherit), sw_inherit_list, TRUE,
FALSE, 0);
gtk_widget_set_size_request (sw_inherit_list, 191, 26);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw_inherit_list),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW
(sw_inherit_list), GTK_SHADOW_IN);
tw_inherit_list = gtk_tree_view_new ();
gtk_widget_show (tw_inherit_list);
gtk_container_add (GTK_CONTAINER (sw_inherit_list), tw_inherit_list);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (tw_inherit_list),
FALSE);
btn_inherit_add = gtk_button_new ();
gtk_widget_show (btn_inherit_add);
gtk_box_pack_start (GTK_BOX (hbox3_inherit), btn_inherit_add, FALSE,
FALSE, 0);
gtk_widget_set_size_request (btn_inherit_add, 24, -1);
gtk_button_set_relief (GTK_BUTTON (btn_inherit_add), GTK_RELIEF_HALF);
image3 = gtk_image_new_from_stock ("gtk-add", GTK_ICON_SIZE_BUTTON);
gtk_widget_show (image3);
gtk_container_add (GTK_CONTAINER (btn_inherit_add), image3);
btn_inherit_remove = gtk_button_new ();
gtk_widget_show (btn_inherit_remove);
gtk_box_pack_start (GTK_BOX (hbox3_inherit), btn_inherit_remove, FALSE,
FALSE, 0);
gtk_widget_set_size_request (btn_inherit_remove, 24, -1);
gtk_button_set_relief (GTK_BUTTON (btn_inherit_remove), GTK_RELIEF_HALF);
image4 = gtk_image_new_from_stock ("gtk-remove", GTK_ICON_SIZE_BUTTON);
gtk_widget_show (image4);
gtk_container_add (GTK_CONTAINER (btn_inherit_remove), image4);
hbox4_font = gtk_hbox_new (FALSE, 5);
gtk_widget_show (hbox4_font);
gtk_box_pack_start (GTK_BOX (vbox), hbox4_font, FALSE, TRUE, 0);
tgl4_font = gtk_toggle_button_new_with_mnemonic ("[-]");
gtk_widget_show (tgl4_font);
gtk_box_pack_start (GTK_BOX (hbox4_font), tgl4_font, FALSE, FALSE, 0);
gtk_button_set_relief (GTK_BUTTON (tgl4_font), GTK_RELIEF_HALF);
label_font = gtk_label_new ("it uses font ");
gtk_widget_show (label_font);
gtk_box_pack_start (GTK_BOX (hbox4_font), label_font, FALSE, FALSE, 0);
btn_font_name = gtk_button_new_with_mnemonic ("Font Name");
gtk_widget_show (btn_font_name);
gtk_box_pack_start (GTK_BOX (hbox4_font), btn_font_name, FALSE, TRUE, 0);
gtk_widget_set_size_request (btn_font_name, 150, -1);
label_font_size = gtk_label_new ("of size");
gtk_widget_show (label_font_size);
gtk_box_pack_start (GTK_BOX (hbox4_font), label_font_size, FALSE, FALSE,
0);
spin_font_size_adj = gtk_adjustment_new (14, 0, 150, 1, 10, 10);
spin_font_size =
gtk_spin_button_new (GTK_ADJUSTMENT (spin_font_size_adj), 1, 0);
gtk_widget_show (spin_font_size);
gtk_box_pack_start (GTK_BOX (hbox4_font), spin_font_size, FALSE, TRUE,
0);
hbox5_colors = gtk_hbox_new (FALSE, 5);
gtk_widget_show (hbox5_colors);
gtk_box_pack_start (GTK_BOX (vbox), hbox5_colors, FALSE, TRUE, 0);
tgl5_colors = gtk_toggle_button_new_with_mnemonic ("[-]");
gtk_widget_show (tgl5_colors);
gtk_box_pack_start (GTK_BOX (hbox5_colors), tgl5_colors, FALSE, FALSE,
0);
gtk_button_set_relief (GTK_BUTTON (tgl5_colors), GTK_RELIEF_HALF);
label_colors_fore = gtk_label_new ("and colors");
gtk_widget_show (label_colors_fore);
gtk_box_pack_start (GTK_BOX (hbox5_colors), label_colors_fore, FALSE,
FALSE, 0);
img_fore_color = gtk_image_new ();
gtk_widget_show (img_fore_color);
gtk_box_pack_start (GTK_BOX (hbox5_colors), img_fore_color, FALSE, FALSE,
0);
gtk_widget_set_size_request (img_fore_color, 16, 16);
btn_fore_color = gtk_button_new_with_mnemonic ("fore color");
gtk_widget_show (btn_fore_color);
gtk_box_pack_start (GTK_BOX (hbox5_colors), btn_fore_color, FALSE, TRUE,
0);
gtk_widget_set_size_request (btn_fore_color, 90, -1);
gtk_button_set_relief (GTK_BUTTON (btn_fore_color), GTK_RELIEF_HALF);
label_colors_back = gtk_label_new ("over");
gtk_widget_show (label_colors_back);
gtk_box_pack_start (GTK_BOX (hbox5_colors), label_colors_back, FALSE,
FALSE, 0);
img_back_color = gtk_image_new ();
gtk_widget_show (img_back_color);
gtk_box_pack_start (GTK_BOX (hbox5_colors), img_back_color, FALSE, FALSE,
0);
gtk_widget_set_size_request (img_back_color, 16, 16);
btn_back_color = gtk_button_new_with_mnemonic ("back color");
gtk_widget_show (btn_back_color);
gtk_box_pack_start (GTK_BOX (hbox5_colors), btn_back_color, FALSE, TRUE,
0);
gtk_widget_set_size_request (btn_back_color, 90, -1);
gtk_button_set_relief (GTK_BUTTON (btn_back_color), GTK_RELIEF_HALF);
hbox6_shadow = gtk_hbox_new (FALSE, 5);
gtk_widget_show (hbox6_shadow);
gtk_box_pack_start (GTK_BOX (vbox), hbox6_shadow, FALSE, TRUE, 0);
tgl5_shadow = gtk_toggle_button_new_with_mnemonic ("[-]");
gtk_widget_show (tgl5_shadow);
gtk_box_pack_start (GTK_BOX (hbox6_shadow), tgl5_shadow, FALSE, FALSE,
0);
gtk_button_set_relief (GTK_BUTTON (tgl5_shadow), GTK_RELIEF_HALF);
label_shadow = gtk_label_new ("using shadow type");
gtk_widget_show (label_shadow);
gtk_box_pack_start (GTK_BOX (hbox6_shadow), label_shadow, FALSE, FALSE,
0);
combo_shadow_type = gtk_combo_box_new_text ();
gtk_widget_show (combo_shadow_type);
gtk_box_pack_start (GTK_BOX (hbox6_shadow), combo_shadow_type, TRUE,
TRUE, 0);
gtk_combo_box_append_text (GTK_COMBO_BOX (combo_shadow_type),
"Normal text");
gtk_combo_box_append_text (GTK_COMBO_BOX (combo_shadow_type),
"Embossed 3D text");
gtk_combo_box_append_text (GTK_COMBO_BOX (combo_shadow_type),
"Sunken 3D text");
gtk_combo_box_append_text (GTK_COMBO_BOX (combo_shadow_type),
"Shade above the text");
gtk_combo_box_append_text (GTK_COMBO_BOX (combo_shadow_type),
"Shade below the text");
gtk_combo_box_append_text (GTK_COMBO_BOX (combo_shadow_type),
"Thick embossed 3D text");
gtk_combo_box_append_text (GTK_COMBO_BOX (combo_shadow_type),
"Thick sunken 3D text");
gtk_combo_box_append_text (GTK_COMBO_BOX (combo_shadow_type),
"Outlined upper edge");
gtk_combo_box_append_text (GTK_COMBO_BOX (combo_shadow_type),
"Outlined bottom edge");
gtk_combo_box_append_text (GTK_COMBO_BOX (combo_shadow_type),
"Outlined all around");
hbox7_background = gtk_hbox_new (FALSE, 5);
gtk_widget_show (hbox7_background);
gtk_box_pack_start (GTK_BOX (vbox), hbox7_background, FALSE, TRUE, 0);
tgl7_background = gtk_toggle_button_new_with_mnemonic ("[-]");
gtk_widget_show (tgl7_background);
gtk_box_pack_start (GTK_BOX (hbox7_background), tgl7_background, FALSE,
FALSE, 0);
gtk_button_set_relief (GTK_BUTTON (tgl7_background), GTK_RELIEF_HALF);
label_background = gtk_label_new ("over");
gtk_widget_show (label_background);
gtk_box_pack_start (GTK_BOX (hbox7_background), label_background, FALSE,
FALSE, 0);
combo_background_type = gtk_combo_box_new_text ();
gtk_widget_show (combo_background_type);
gtk_box_pack_start (GTK_BOX (hbox7_background), combo_background_type,
TRUE, TRUE, 0);
gtk_combo_box_append_text (GTK_COMBO_BOX (combo_background_type),
"Solid color background");
gtk_combo_box_append_text (GTK_COMBO_BOX (combo_background_type),
"Horizontal gradient");
gtk_combo_box_append_text (GTK_COMBO_BOX (combo_background_type),
"Vertical gradient");
gtk_combo_box_append_text (GTK_COMBO_BOX (combo_background_type),
"Left-top to right-bottom gradient");
gtk_combo_box_append_text (GTK_COMBO_BOX (combo_background_type),
"Right-top to left-bottom gradient");
gtk_combo_box_append_text (GTK_COMBO_BOX (combo_background_type),
"Scaled texture");
gtk_combo_box_append_text (GTK_COMBO_BOX (combo_background_type),
"Tiled texture");
gtk_combo_box_append_text (GTK_COMBO_BOX (combo_background_type),
"Tinted desktop background");
gtk_combo_box_append_text (GTK_COMBO_BOX (combo_background_type),
"Scaled shaped texture");
gtk_combo_box_append_text (GTK_COMBO_BOX (combo_background_type),
"Sliced shaped texture");
gtk_combo_box_append_text (GTK_COMBO_BOX (combo_background_type),
"Tiled shaped texture");
gtk_combo_box_append_text (GTK_COMBO_BOX (combo_background_type),
"Two-way Tinted desktop background");
gtk_combo_box_append_text (GTK_COMBO_BOX (combo_background_type),
"Tiled pseudo-transp. texture");
gtk_combo_box_append_text (GTK_COMBO_BOX (combo_background_type),
"Scaled pseudo-transp. texture");
gtk_combo_box_append_text (GTK_COMBO_BOX (combo_background_type),
"Sliced pseudo-transp. texture");
hbox8_grad_details = gtk_hbox_new (FALSE, 5);
gtk_widget_show (hbox8_grad_details);
gtk_box_pack_start (GTK_BOX (vbox), hbox8_grad_details, FALSE, TRUE, 0);
arrow1_grad_details = gtk_arrow_new (GTK_ARROW_RIGHT, GTK_SHADOW_OUT);
gtk_widget_show (arrow1_grad_details);
gtk_box_pack_start (GTK_BOX (hbox8_grad_details), arrow1_grad_details,
FALSE, TRUE, 0);
btn_grad_color1 = gtk_button_new_with_mnemonic ("color1");
gtk_widget_show (btn_grad_color1);
gtk_box_pack_start (GTK_BOX (hbox8_grad_details), btn_grad_color1, FALSE,
FALSE, 0);
gtk_button_set_relief (GTK_BUTTON (btn_grad_color1), GTK_RELIEF_HALF);
label_to1 = gtk_label_new ("to");
gtk_widget_show (label_to1);
gtk_box_pack_start (GTK_BOX (hbox8_grad_details), label_to1, FALSE,
FALSE, 0);
btn_grad_color2 = gtk_button_new_with_mnemonic ("color2");
gtk_widget_show (btn_grad_color2);
gtk_box_pack_start (GTK_BOX (hbox8_grad_details), btn_grad_color2, FALSE,
FALSE, 0);
gtk_button_set_relief (GTK_BUTTON (btn_grad_color2), GTK_RELIEF_HALF);
label1_to2 = gtk_label_new ("to");
gtk_widget_show (label1_to2);
gtk_box_pack_start (GTK_BOX (hbox8_grad_details), label1_to2, FALSE,
FALSE, 0);
btn_grad_color3 = gtk_button_new_with_mnemonic ("color3");
gtk_widget_show (btn_grad_color3);
gtk_box_pack_start (GTK_BOX (hbox8_grad_details), btn_grad_color3, FALSE,
FALSE, 0);
gtk_button_set_relief (GTK_BUTTON (btn_grad_color3), GTK_RELIEF_HALF);
btn_grad_edit = gtk_button_new_with_mnemonic ("Edit");
gtk_widget_show (btn_grad_edit);
gtk_box_pack_start (GTK_BOX (hbox8_grad_details), btn_grad_edit, FALSE,
FALSE, 0);
hbox9_texture_file = gtk_hbox_new (FALSE, 5);
gtk_widget_show (hbox9_texture_file);
gtk_box_pack_start (GTK_BOX (vbox), hbox9_texture_file, FALSE, TRUE, 0);
arrow2_texture_file = gtk_arrow_new (GTK_ARROW_RIGHT, GTK_SHADOW_OUT);
gtk_widget_show (arrow2_texture_file);
gtk_box_pack_start (GTK_BOX (hbox9_texture_file), arrow2_texture_file,
FALSE, FALSE, 0);
label_texture_file = gtk_label_new ("from file :");
gtk_widget_show (label_texture_file);
gtk_box_pack_start (GTK_BOX (hbox9_texture_file), label_texture_file,
FALSE, FALSE, 0);
filechooserbtn_texture_file =
gtk_file_chooser_button_new ("", GTK_FILE_CHOOSER_ACTION_OPEN);
gtk_widget_show (filechooserbtn_texture_file);
gtk_box_pack_start (GTK_BOX (hbox9_texture_file),
filechooserbtn_texture_file, TRUE, TRUE, 0);
hbox10_texture_blend_type = gtk_hbox_new (FALSE, 5);
gtk_widget_show (hbox10_texture_blend_type);
gtk_box_pack_start (GTK_BOX (vbox), hbox10_texture_blend_type, FALSE,
TRUE, 0);
arrow3_texture_blend_type =
gtk_arrow_new (GTK_ARROW_RIGHT, GTK_SHADOW_OUT);
gtk_widget_show (arrow3_texture_blend_type);
gtk_box_pack_start (GTK_BOX (hbox10_texture_blend_type),
arrow3_texture_blend_type, FALSE, TRUE, 0);
label_texture_blend_type = gtk_label_new ("blending type :");
gtk_widget_show (label_texture_blend_type);
gtk_box_pack_start (GTK_BOX (hbox10_texture_blend_type),
label_texture_blend_type, FALSE, FALSE, 0);
combo_texture_blend_type = gtk_combo_box_new_text ();
gtk_widget_show (combo_texture_blend_type);
gtk_box_pack_start (GTK_BOX (hbox10_texture_blend_type),
combo_texture_blend_type, TRUE, TRUE, 0);
gtk_combo_box_append_text (GTK_COMBO_BOX (combo_texture_blend_type),
"average color values");
gtk_combo_box_append_text (GTK_COMBO_BOX (combo_texture_blend_type),
"alpha-blending");
gtk_combo_box_append_text (GTK_COMBO_BOX (combo_texture_blend_type),
"tint");
gtk_combo_box_append_text (GTK_COMBO_BOX (combo_texture_blend_type),
"color add");
gtk_combo_box_append_text (GTK_COMBO_BOX (combo_texture_blend_type),
"color substruct");
gtk_combo_box_append_text (GTK_COMBO_BOX (combo_texture_blend_type),
"color difference");
gtk_combo_box_append_text (GTK_COMBO_BOX (combo_texture_blend_type),
"lowest color value");
gtk_combo_box_append_text (GTK_COMBO_BOX (combo_texture_blend_type),
"highest color value");
gtk_combo_box_append_text (GTK_COMBO_BOX (combo_texture_blend_type),
"screen");
gtk_combo_box_append_text (GTK_COMBO_BOX (combo_texture_blend_type),
"overlay");
gtk_combo_box_append_text (GTK_COMBO_BOX (combo_texture_blend_type),
"same hue");
gtk_combo_box_append_text (GTK_COMBO_BOX (combo_texture_blend_type),
"saturation");
gtk_combo_box_append_text (GTK_COMBO_BOX (combo_texture_blend_type),
"value");
gtk_combo_box_append_text (GTK_COMBO_BOX (combo_texture_blend_type),
"colorize");
gtk_combo_box_append_text (GTK_COMBO_BOX (combo_texture_blend_type),
"dissipate");
table1_texture_slicing = gtk_table_new (2, 5, FALSE);
gtk_widget_show (table1_texture_slicing);
gtk_box_pack_start (GTK_BOX (vbox), table1_texture_slicing, FALSE, TRUE,
0);
gtk_table_set_col_spacings (GTK_TABLE (table1_texture_slicing), 5);
label1_texture_slicing_x = gtk_label_new ("scaled horiz. between");
gtk_widget_show (label1_texture_slicing_x);
gtk_table_attach (GTK_TABLE (table1_texture_slicing),
label1_texture_slicing_x, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0),
0, 0);
spin_texture_slicing_x_start_adj =
gtk_adjustment_new (1, 0, 100, 1, 10, 10);
spin_texture_slicing_x_start =
gtk_spin_button_new (GTK_ADJUSTMENT
(spin_texture_slicing_x_start_adj), 1, 0);
gtk_widget_show (spin_texture_slicing_x_start);
gtk_table_attach (GTK_TABLE (table1_texture_slicing),
spin_texture_slicing_x_start, 2, 3, 0, 1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
label_texture_slicing_x2 = gtk_label_new ("and");
gtk_widget_show (label_texture_slicing_x2);
gtk_table_attach (GTK_TABLE (table1_texture_slicing),
label_texture_slicing_x2, 3, 4, 0, 1,
(GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0),
0, 0);
gtk_misc_set_alignment (GTK_MISC (label_texture_slicing_x2), 0.51, 0.5);
spin_texture_slicing_x_end_adj =
gtk_adjustment_new (1, 0, 100, 1, 10, 10);
spin_texture_slicing_x_end =
gtk_spin_button_new (GTK_ADJUSTMENT (spin_texture_slicing_x_end_adj),
1, 0);
gtk_widget_show (spin_texture_slicing_x_end);
gtk_table_attach (GTK_TABLE (table1_texture_slicing),
spin_texture_slicing_x_end, 4, 5, 0, 1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
label_texture_slicing_y = gtk_label_new ("scaled vert. between");
gtk_widget_show (label_texture_slicing_y);
gtk_table_attach (GTK_TABLE (table1_texture_slicing),
label_texture_slicing_y, 1, 2, 1, 2,
(GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0),
0, 0);
gtk_misc_set_alignment (GTK_MISC (label_texture_slicing_y), 1, 0.5);
spin_texture_slicing_y_start_adj =
gtk_adjustment_new (1, 0, 100, 1, 10, 10);
spin_texture_slicing_y_start =
gtk_spin_button_new (GTK_ADJUSTMENT
(spin_texture_slicing_y_start_adj), 1, 0);
gtk_widget_show (spin_texture_slicing_y_start);
gtk_table_attach (GTK_TABLE (table1_texture_slicing),
spin_texture_slicing_y_start, 2, 3, 1, 2,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
label_texture_slicing_y2 = gtk_label_new ("and");
gtk_widget_show (label_texture_slicing_y2);
gtk_table_attach (GTK_TABLE (table1_texture_slicing),
label_texture_slicing_y2, 3, 4, 1, 2,
(GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0),
0, 0);
spin_texture_slicing_y_end_adj =
gtk_adjustment_new (1, 0, 100, 1, 10, 10);
spin_texture_slicing_y_end =
gtk_spin_button_new (GTK_ADJUSTMENT (spin_texture_slicing_y_end_adj),
1, 0);
gtk_widget_show (spin_texture_slicing_y_end);
gtk_table_attach (GTK_TABLE (table1_texture_slicing),
spin_texture_slicing_y_end, 4, 5, 1, 2,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
arrow5_texture_slicing = gtk_arrow_new (GTK_ARROW_RIGHT, GTK_SHADOW_OUT);
gtk_widget_show (arrow5_texture_slicing);
gtk_table_attach (GTK_TABLE (table1_texture_slicing),
arrow5_texture_slicing, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
/* Store pointers to all widgets, for use by lookup_widget(). */
GLADE_HOOKUP_OBJECT_NO_REF (mystyle_editor, mystyle_editor,
"mystyle_editor");
/*-- hand edit start --*/
/* GLADE_HOOKUP_OBJECT (mystyle_editor, vbox, "vbox"); */
/*-- hand edit end --*/
GLADE_HOOKUP_OBJECT (mystyle_editor, hbox1_mystyle_name,
"hbox1_mystyle_name");
GLADE_HOOKUP_OBJECT (mystyle_editor, label_mystyle, "label_mystyle");
GLADE_HOOKUP_OBJECT (mystyle_editor, entry_mystyle_name,
"entry_mystyle_name");
GLADE_HOOKUP_OBJECT (mystyle_editor, hbox2_overlay, "hbox2_overlay");
GLADE_HOOKUP_OBJECT (mystyle_editor, tgl2_overlay, "tgl2_overlay");
GLADE_HOOKUP_OBJECT (mystyle_editor, label_overlay, "label_overlay");
GLADE_HOOKUP_OBJECT (mystyle_editor, combo_overlay_mystyle,
"combo_overlay_mystyle");
GLADE_HOOKUP_OBJECT (mystyle_editor, hbox3_inherit, "hbox3_inherit");
GLADE_HOOKUP_OBJECT (mystyle_editor, tgl3_inherit, "tgl3_inherit");
GLADE_HOOKUP_OBJECT (mystyle_editor, label_inherit, "label_inherit");
GLADE_HOOKUP_OBJECT (mystyle_editor, sw_inherit_list, "sw_inherit_list");
GLADE_HOOKUP_OBJECT (mystyle_editor, tw_inherit_list, "tw_inherit_list");
GLADE_HOOKUP_OBJECT (mystyle_editor, btn_inherit_add, "btn_inherit_add");
GLADE_HOOKUP_OBJECT (mystyle_editor, image3, "image3");
GLADE_HOOKUP_OBJECT (mystyle_editor, btn_inherit_remove,
"btn_inherit_remove");
GLADE_HOOKUP_OBJECT (mystyle_editor, image4, "image4");
GLADE_HOOKUP_OBJECT (mystyle_editor, hbox4_font, "hbox4_font");
GLADE_HOOKUP_OBJECT (mystyle_editor, tgl4_font, "tgl4_font");
GLADE_HOOKUP_OBJECT (mystyle_editor, label_font, "label_font");
GLADE_HOOKUP_OBJECT (mystyle_editor, btn_font_name, "btn_font_name");
GLADE_HOOKUP_OBJECT (mystyle_editor, label_font_size, "label_font_size");
GLADE_HOOKUP_OBJECT (mystyle_editor, spin_font_size, "spin_font_size");
GLADE_HOOKUP_OBJECT (mystyle_editor, hbox5_colors, "hbox5_colors");
GLADE_HOOKUP_OBJECT (mystyle_editor, tgl5_colors, "tgl5_colors");
GLADE_HOOKUP_OBJECT (mystyle_editor, label_colors_fore,
"label_colors_fore");
GLADE_HOOKUP_OBJECT (mystyle_editor, img_fore_color, "img_fore_color");
GLADE_HOOKUP_OBJECT (mystyle_editor, btn_fore_color, "btn_fore_color");
GLADE_HOOKUP_OBJECT (mystyle_editor, label_colors_back,
"label_colors_back");
GLADE_HOOKUP_OBJECT (mystyle_editor, img_back_color, "img_back_color");
GLADE_HOOKUP_OBJECT (mystyle_editor, btn_back_color, "btn_back_color");
GLADE_HOOKUP_OBJECT (mystyle_editor, hbox6_shadow, "hbox6_shadow");
GLADE_HOOKUP_OBJECT (mystyle_editor, tgl5_shadow, "tgl5_shadow");
GLADE_HOOKUP_OBJECT (mystyle_editor, label_shadow, "label_shadow");
GLADE_HOOKUP_OBJECT (mystyle_editor, combo_shadow_type,
"combo_shadow_type");
GLADE_HOOKUP_OBJECT (mystyle_editor, hbox7_background,
"hbox7_background");
GLADE_HOOKUP_OBJECT (mystyle_editor, tgl7_background, "tgl7_background");
GLADE_HOOKUP_OBJECT (mystyle_editor, label_background,
"label_background");
GLADE_HOOKUP_OBJECT (mystyle_editor, combo_background_type,
"combo_background_type");
GLADE_HOOKUP_OBJECT (mystyle_editor, hbox8_grad_details,
"hbox8_grad_details");
GLADE_HOOKUP_OBJECT (mystyle_editor, arrow1_grad_details,
"arrow1_grad_details");
GLADE_HOOKUP_OBJECT (mystyle_editor, btn_grad_color1, "btn_grad_color1");
GLADE_HOOKUP_OBJECT (mystyle_editor, label_to1, "label_to1");
GLADE_HOOKUP_OBJECT (mystyle_editor, btn_grad_color2, "btn_grad_color2");
GLADE_HOOKUP_OBJECT (mystyle_editor, label1_to2, "label1_to2");
GLADE_HOOKUP_OBJECT (mystyle_editor, btn_grad_color3, "btn_grad_color3");
GLADE_HOOKUP_OBJECT (mystyle_editor, btn_grad_edit, "btn_grad_edit");
GLADE_HOOKUP_OBJECT (mystyle_editor, hbox9_texture_file,
"hbox9_texture_file");
GLADE_HOOKUP_OBJECT (mystyle_editor, arrow2_texture_file,
"arrow2_texture_file");
GLADE_HOOKUP_OBJECT (mystyle_editor, label_texture_file,
"label_texture_file");
GLADE_HOOKUP_OBJECT (mystyle_editor, filechooserbtn_texture_file,
"filechooserbtn_texture_file");
GLADE_HOOKUP_OBJECT (mystyle_editor, hbox10_texture_blend_type,
"hbox10_texture_blend_type");
GLADE_HOOKUP_OBJECT (mystyle_editor, arrow3_texture_blend_type,
"arrow3_texture_blend_type");
GLADE_HOOKUP_OBJECT (mystyle_editor, label_texture_blend_type,
"label_texture_blend_type");
GLADE_HOOKUP_OBJECT (mystyle_editor, combo_texture_blend_type,
"combo_texture_blend_type");
GLADE_HOOKUP_OBJECT (mystyle_editor, table1_texture_slicing,
"table1_texture_slicing");
GLADE_HOOKUP_OBJECT (mystyle_editor, label1_texture_slicing_x,
"label1_texture_slicing_x");
GLADE_HOOKUP_OBJECT (mystyle_editor, spin_texture_slicing_x_start,
"spin_texture_slicing_x_start");
GLADE_HOOKUP_OBJECT (mystyle_editor, label_texture_slicing_x2,
"label_texture_slicing_x2");
GLADE_HOOKUP_OBJECT (mystyle_editor, spin_texture_slicing_x_end,
"spin_texture_slicing_x_end");
GLADE_HOOKUP_OBJECT (mystyle_editor, label_texture_slicing_y,
"label_texture_slicing_y");
GLADE_HOOKUP_OBJECT (mystyle_editor, spin_texture_slicing_y_start,
"spin_texture_slicing_y_start");
GLADE_HOOKUP_OBJECT (mystyle_editor, label_texture_slicing_y2,
"label_texture_slicing_y2");
GLADE_HOOKUP_OBJECT (mystyle_editor, spin_texture_slicing_y_end,
"spin_texture_slicing_y_end");
GLADE_HOOKUP_OBJECT (mystyle_editor, arrow5_texture_slicing,
"arrow5_texture_slicing");
return mystyle_editor;
}
void pluginwindow_create()
{
PluginWindow *pluginwindow;
GtkWidget *window;
GtkWidget *vbox1;
GtkWidget *hbox2;
GtkWidget *scrolledwindow2;
GtkWidget *plugin_list_view;
GtkWidget *vbox2;
GtkWidget *frame2;
GtkWidget *label13;
GtkWidget *scrolledwindow3;
GtkWidget *plugin_desc;
GtkWidget *hbuttonbox1;
GtkWidget *hbuttonbox2;
GtkWidget *help_btn;
GtkWidget *load_btn;
GtkWidget *unload_btn;
GtkWidget *close_btn;
gchar *markup;
GtkWidget *desc_lbl;
GtkWidget *vbox3;
GtkWidget *hbox_info;
static GdkGeometry geometry;
debug_print("Creating plugins window...\n");
pluginwindow = g_new0(PluginWindow, 1);
window = gtkut_window_new(GTK_WINDOW_TOPLEVEL, "pluginwindow");
gtk_container_set_border_width(GTK_CONTAINER(window), 8);
gtk_window_set_title(GTK_WINDOW(window), _("Plugins"));
gtk_window_set_modal(GTK_WINDOW(window), TRUE);
manage_window_set_transient(GTK_WINDOW(window));
vbox1 = gtk_vbox_new(FALSE, 4);
gtk_widget_show(vbox1);
gtk_container_add(GTK_CONTAINER(window), vbox1);
gtk_box_set_homogeneous(GTK_BOX(vbox1), FALSE);
gtk_widget_realize(window);
hbox2 = gtk_hbox_new(FALSE, 8);
gtk_widget_show(hbox2);
gtk_box_pack_start(GTK_BOX(vbox1), hbox2, TRUE, TRUE, 0);
vbox3 = gtk_vbox_new(FALSE, 4);
gtk_widget_show(vbox3);
gtk_box_pack_start(GTK_BOX(hbox2), vbox3, FALSE, FALSE, 0);
scrolledwindow2 = gtk_scrolled_window_new(NULL, NULL);
gtk_widget_show(scrolledwindow2);
gtk_box_pack_start(GTK_BOX(vbox3), scrolledwindow2, TRUE, TRUE, 0);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolledwindow2),
GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW
(scrolledwindow2), GTK_POLICY_NEVER,
GTK_POLICY_AUTOMATIC);
plugin_list_view = pluginwindow_list_view_create(pluginwindow);
gtk_widget_show(plugin_list_view);
gtk_container_add(GTK_CONTAINER(scrolledwindow2), plugin_list_view);
gtk_widget_grab_focus(GTK_WIDGET(plugin_list_view));
gtkut_stock_button_set_create(&hbuttonbox1,
&load_btn, _("Load..."),
&unload_btn, _("Unload"),
NULL, NULL);
gtk_widget_show(hbuttonbox1);
gtk_box_pack_start(GTK_BOX(vbox3), hbuttonbox1, FALSE, FALSE, 0);
vbox2 = gtk_vbox_new(FALSE, 0);
gtk_widget_show(vbox2);
gtk_box_pack_start(GTK_BOX(hbox2), vbox2, TRUE, TRUE, 0);
frame2 = gtk_frame_new(NULL);
gtk_widget_show(frame2);
gtk_box_pack_start(GTK_BOX(vbox2), frame2, FALSE, TRUE, 0);
label13 = gtk_label_new(_("Description"));
gtk_widget_show(label13);
gtk_container_add(GTK_CONTAINER(frame2), label13);
gtk_misc_set_alignment(GTK_MISC(label13), 0, 0.5);
gtk_misc_set_padding(GTK_MISC(label13), 2, 2);
scrolledwindow3 = gtk_scrolled_window_new(NULL, NULL);
gtk_widget_show(scrolledwindow3);
gtk_box_pack_start(GTK_BOX(vbox2), scrolledwindow3, TRUE, TRUE, 0);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolledwindow3),
GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW
(scrolledwindow3), GTK_POLICY_NEVER,
GTK_POLICY_ALWAYS);
plugin_desc = gtk_text_view_new();
gtk_widget_show(plugin_desc);
gtk_container_add(GTK_CONTAINER(scrolledwindow3), plugin_desc);
hbox_info = gtk_hbox_new(FALSE, 5);
gtk_widget_show(hbox_info);
desc_lbl = gtk_label_new("");
markup = g_markup_printf_escaped(_("For more information about plugins see the "
"<a href=\"%s\"><span underline=\"none\">Claws Mail website</span></a>."),PLUGINS_URI);
gtk_label_set_markup(GTK_LABEL(desc_lbl), markup);
g_free(markup);
gtk_misc_set_alignment(GTK_MISC(desc_lbl), 0, 0.5);
gtk_widget_show(desc_lbl);
gtk_box_pack_start(GTK_BOX(hbox_info), desc_lbl, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox_info), gtk_label_new(""), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox1), hbox_info, FALSE, FALSE, 0);
gtkut_stock_button_set_create_with_help(&hbuttonbox2, &help_btn,
&close_btn, GTK_STOCK_CLOSE,
NULL, NULL, NULL, NULL);
gtk_box_set_spacing(GTK_BOX(hbuttonbox2), 6);
gtk_widget_show(hbuttonbox2);
gtk_box_pack_end(GTK_BOX(vbox1), hbuttonbox2, FALSE, FALSE, 0);
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(plugin_desc), GTK_WRAP_WORD);
gtk_widget_set_sensitive(GTK_WIDGET(unload_btn), FALSE);
g_signal_connect(G_OBJECT(help_btn), "clicked",
G_CALLBACK(manual_open_with_anchor_cb),
MANUAL_ANCHOR_PLUGINS);
g_signal_connect(G_OBJECT(load_btn), "clicked",
G_CALLBACK(load_cb), pluginwindow);
g_signal_connect(G_OBJECT(unload_btn), "clicked",
G_CALLBACK(unload_cb), pluginwindow);
g_signal_connect(G_OBJECT(close_btn), "clicked",
G_CALLBACK(close_cb), pluginwindow);
g_signal_connect(G_OBJECT(window), "size_allocate",
G_CALLBACK(pluginwindow_size_allocate_cb), NULL);
g_signal_connect(G_OBJECT(window), "key_press_event",
G_CALLBACK(pluginwindow_key_pressed), pluginwindow);
g_signal_connect(G_OBJECT(window), "delete_event",
G_CALLBACK(pluginwindow_delete_cb), pluginwindow);
MANAGE_WINDOW_SIGNALS_CONNECT(window);
CLAWS_SET_TIP(load_btn,
_("Click here to load one or more plugins"));
CLAWS_SET_TIP(unload_btn,
_("Unload the selected plugin"));
pluginwindow->window = window;
pluginwindow->plugin_list_view = plugin_list_view;
pluginwindow->plugin_desc = plugin_desc;
pluginwindow->unload_btn = unload_btn;
pluginwindow->selected_plugin = NULL;
set_plugin_list(pluginwindow);
inc_lock();
if (!geometry.min_height) {
geometry.min_width = -1;
geometry.min_height = 300;
}
gtk_window_set_geometry_hints(GTK_WINDOW(window), NULL, &geometry,
GDK_HINT_MIN_SIZE);
gtk_window_set_default_size(GTK_WINDOW(window), prefs_common.pluginswin_width,
prefs_common.pluginswin_height);
gtk_widget_show(window);
}
void
create_chooser_dialog (ContactsData *data)
{
GtkWidget *chooser_dialog;
GtkWidget *dialog_vbox1;
GtkWidget *vbox6;
GtkWidget *chooser_label;
GtkWidget *chooser_add_hbox;
GtkWidget *chooser_entry;
GtkWidget *add_type_button;
GtkWidget *scrolledwindow5;
GtkWidget *chooser_treeview;
GtkWidget *widget;
GtkTreeModel *model;
GtkCellRenderer *renderer;
chooser_dialog = gtk_dialog_new ();
gtk_window_set_title (GTK_WINDOW (chooser_dialog), _("Edit Types"));
gtk_window_set_modal (GTK_WINDOW (chooser_dialog), TRUE);
gtk_window_set_default_size (GTK_WINDOW (chooser_dialog), -1, 280);
gtk_window_set_type_hint (GTK_WINDOW (chooser_dialog), GDK_WINDOW_TYPE_HINT_DIALOG);
gtk_dialog_set_has_separator (GTK_DIALOG (chooser_dialog), FALSE);
dialog_vbox1 = GTK_DIALOG (chooser_dialog)->vbox;
vbox6 = gtk_vbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (dialog_vbox1), vbox6, TRUE, TRUE, 6);
gtk_container_set_border_width (GTK_CONTAINER (vbox6), 6);
chooser_label = gtk_label_new (_("<span><b>Make a choice:</b></span>"));
gtk_box_pack_start (GTK_BOX (vbox6), chooser_label, FALSE, FALSE, 6);
gtk_label_set_use_markup (GTK_LABEL (chooser_label), TRUE);
gtk_misc_set_alignment (GTK_MISC (chooser_label), 0, 0.5);
gtk_misc_set_padding (GTK_MISC (chooser_label), 6, 0);
chooser_add_hbox = gtk_hbox_new (FALSE, 6);
gtk_box_pack_start (GTK_BOX (vbox6), chooser_add_hbox, FALSE, TRUE, 6);
chooser_entry = gtk_entry_new ();
gtk_box_pack_start (GTK_BOX (chooser_add_hbox), chooser_entry, TRUE, TRUE, 0);
gtk_entry_set_activates_default (GTK_ENTRY (chooser_entry), TRUE);
g_signal_connect (chooser_entry, "changed",
G_CALLBACK (contacts_chooser_entry_changed_cb), data);
add_type_button = gtk_button_new_from_stock ("gtk-add");
gtk_box_pack_start (GTK_BOX (chooser_add_hbox), add_type_button, FALSE, FALSE, 0);
GTK_WIDGET_SET_FLAGS (add_type_button, GTK_CAN_DEFAULT);
gtk_button_set_focus_on_click (GTK_BUTTON (add_type_button), FALSE);
/* initially insensitive, enabled when user enters text into the entry
*/
gtk_widget_set_sensitive (add_type_button, FALSE);
scrolledwindow5 = gtk_scrolled_window_new (NULL, NULL);
gtk_box_pack_start (GTK_BOX (vbox6), scrolledwindow5, TRUE, TRUE, 0);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow5), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow5), GTK_SHADOW_IN);
chooser_treeview = gtk_tree_view_new ();
gtk_container_add (GTK_CONTAINER (scrolledwindow5), chooser_treeview);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (chooser_treeview), FALSE);
widget = GTK_DIALOG (chooser_dialog)->action_area;
gtk_button_box_set_layout (GTK_BUTTON_BOX (widget), GTK_BUTTONBOX_END);
widget = gtk_button_new_from_stock ("gtk-cancel");
gtk_dialog_add_action_widget (GTK_DIALOG (chooser_dialog), widget, GTK_RESPONSE_CANCEL);
GTK_WIDGET_SET_FLAGS (widget, GTK_CAN_DEFAULT);
widget = gtk_button_new_from_stock ("gtk-ok");
gtk_dialog_add_action_widget (GTK_DIALOG (chooser_dialog), widget, GTK_RESPONSE_OK);
GTK_WIDGET_SET_FLAGS (widget, GTK_CAN_DEFAULT);
gtk_widget_grab_focus (chooser_entry);
gtk_widget_grab_default (add_type_button);
/* connect signals */
g_signal_connect ((gpointer) add_type_button, "clicked",
G_CALLBACK (contacts_chooser_add_cb),
data);
/* Create model/view for groups/type chooser list */
model = (GtkTreeModel *) gtk_list_store_new (2, G_TYPE_BOOLEAN, G_TYPE_STRING);
renderer = gtk_cell_renderer_toggle_new ();
g_object_set (renderer, "activatable", TRUE, NULL);
g_signal_connect (renderer, "toggled",
(GCallback) contacts_chooser_toggle_cb, model);
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW
(chooser_treeview), -1,
NULL, renderer, "active",
CHOOSER_TICK_COL, NULL);
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW
(chooser_treeview), -1,
NULL, renderer, "text",
CHOOSER_NAME_COL, NULL);
gtk_tree_view_set_model (GTK_TREE_VIEW (chooser_treeview),
GTK_TREE_MODEL (model));
g_object_unref (model);
data->ui->chooser_add_button = add_type_button;
data->ui->chooser_add_hbox = chooser_add_hbox;
data->ui->chooser_dialog = chooser_dialog;
data->ui->chooser_entry = chooser_entry;
data->ui->chooser_label = chooser_label;
data->ui->chooser_treeview = chooser_treeview;
gtk_widget_show_all (dialog_vbox1);
}
static GtkCellEditable*
marlin_text_renderer_start_editing (GtkCellRenderer *cell,
GdkEvent *event,
GtkWidget *widget,
const gchar *path,
const GdkRectangle *background_area,
const GdkRectangle *cell_area,
GtkCellRendererState flags)
{
MarlinTextRenderer *text_renderer = MARLIN_TEXT_RENDERER (cell);
gint xpad, ypad;
gfloat xalign, yalign;
gboolean mode, visible;
/* verify that we are visible & editable */
g_object_get (cell, "visible", &visible, "mode", &mode, NULL);
if (!(visible && mode == GTK_CELL_RENDERER_MODE_EDITABLE))
return NULL;
//g_message ("%s %s\n", G_STRFUNC, path);
gtk_cell_renderer_get_alignment (cell, &xalign, &yalign);
/* allocate a new text entry widget to be used for editing */
/*text_renderer->entry = g_object_new (GTK_TYPE_ENTRY,
"has-frame", FALSE,
"text", text_renderer->text,
"visible", TRUE,
"xalign", xalign,
NULL);*/
text_renderer->entry = eel_editable_label_new ("Test text");
eel_editable_label_set_line_wrap (EEL_EDITABLE_LABEL (text_renderer->entry), TRUE);
eel_editable_label_set_line_wrap_mode (EEL_EDITABLE_LABEL (text_renderer->entry), text_renderer->wrap_mode);
eel_editable_label_set_draw_outline (EEL_EDITABLE_LABEL (text_renderer->entry), TRUE);
/* presume we're in POSITION UNDER */
if (text_renderer->wrap_width > 0)
eel_editable_label_set_justify (EEL_EDITABLE_LABEL (text_renderer->entry), GTK_JUSTIFY_CENTER);
//gtk_misc_set_alignment (GTK_MISC (text_renderer->entry), xalign, yalign);
g_object_set (text_renderer->entry, "yalign", yalign, NULL);
gtk_cell_renderer_get_padding (cell, &xpad, &ypad);
gtk_misc_set_padding (GTK_MISC (text_renderer->entry), xpad, ypad);
if (text_renderer->zoom_level < MARLIN_ZOOM_LEVEL_NORMAL)
g_object_set (text_renderer->entry, "small-size", TRUE, NULL);
gtk_widget_set_size_request (text_renderer->entry, text_renderer->wrap_width, -1);
eel_editable_label_set_text (EEL_EDITABLE_LABEL (text_renderer->entry),
text_renderer->text);
gtk_widget_show (text_renderer->entry);
/* remember the tree path that we're editing */
g_object_set_data_full (G_OBJECT (text_renderer->entry), "marlin-text-renderer-path", g_strdup (path), g_free);
/* connect required signals */
g_signal_connect (G_OBJECT (text_renderer->entry), "editing-done", G_CALLBACK (marlin_text_renderer_editing_done), text_renderer);
g_signal_connect (G_OBJECT (text_renderer->entry), "focus-out-event", G_CALLBACK (marlin_text_renderer_focus_out_event), text_renderer);
g_signal_connect (G_OBJECT (text_renderer->entry), "populate-popup", G_CALLBACK (marlin_text_renderer_populate_popup), text_renderer);
return GTK_CELL_EDITABLE (text_renderer->entry);
}
int
nsSetupTypeDlg::VerifyDiskSpace(void)
{
int err = OK;
int dsAvail, dsReqd;
char dsAvailStr[128], dsReqdStr[128];
char message[512];
GtkWidget *noDSDlg, *label, *okButton;
// find disk space available at destination
dsAvail = DSAvailable();
if (dsAvail < 0)
return OK; // optimistic when statfs failed
// or we don't have statfs
// get disk space required
dsReqd = DSRequired();
if (dsReqd > dsAvail)
{
if (gCtx->opt->mMode == nsXIOptions::MODE_DEFAULT)
{
// throw up not enough ds dlg
sprintf(dsAvailStr, gCtx->Res("DS_AVAIL"), dsAvail);
sprintf(dsReqdStr, gCtx->Res("DS_REQD"), dsReqd);
sprintf(message, "%s\n%s\n\n%s", dsAvailStr, dsReqdStr,
gCtx->Res("NO_DISK_SPACE"));
noDSDlg = gtk_dialog_new();
gtk_window_set_modal(GTK_WINDOW(noDSDlg), TRUE);
label = gtk_label_new(message);
okButton = gtk_button_new_with_label(gCtx->Res("OK_LABEL"));
if (noDSDlg && label && okButton)
{
gtk_window_set_title(GTK_WINDOW(noDSDlg), gCtx->opt->mTitle);
gtk_window_set_position(GTK_WINDOW(noDSDlg),
GTK_WIN_POS_CENTER);
gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
gtk_misc_set_padding(GTK_MISC(label), 20, 20);
gtk_misc_set_alignment(GTK_MISC(label), 0.5, 1);
gtk_box_pack_start(GTK_BOX(
GTK_DIALOG(noDSDlg)->action_area), okButton,
FALSE, FALSE, 10);
gtk_signal_connect(GTK_OBJECT(okButton), "clicked",
GTK_SIGNAL_FUNC(NoDiskSpaceOK), noDSDlg);
gtk_box_pack_start(GTK_BOX(
GTK_DIALOG(noDSDlg)->vbox), label, FALSE, FALSE, 10);
GTK_WIDGET_SET_FLAGS(okButton, GTK_CAN_DEFAULT);
gtk_widget_grab_default(okButton);
gtk_widget_show_all(noDSDlg);
}
}
err = E_NO_DISK_SPACE;
}
return err;
}
static void
collection_albums(void *opaque, prop_event_t event, ...)
{
albumbrowse_t *ab = opaque;
prop_t *p;
GtkWidget *w;
GtkWidget *hbox;
prop_sub_t *s;
va_list ap;
va_start(ap, event);
switch(event) {
case PROP_ADD_CHILD:
p = va_arg(ap, prop_t *);
/* Separator */
if(ab->albums > 0) {
w = gtk_hseparator_new();
gtk_box_pack_start(GTK_BOX(ab->vbox), w, FALSE, FALSE, 5);
gtk_widget_show(w);
}
ab->albums++;
/* Album name */
w = gtk_label_new("");
gtk_misc_set_alignment(GTK_MISC(w), 0, 0);
gtk_misc_set_padding(GTK_MISC(w), 5, 0);
gtk_label_set_ellipsize(GTK_LABEL(w), PANGO_ELLIPSIZE_END);
gtk_box_pack_start(GTK_BOX(ab->vbox), w, TRUE, TRUE, 0);
gtk_widget_show(w);
s = prop_subscribe(0,
PROP_TAG_NAME("self", "metadata", "album_name"),
PROP_TAG_CALLBACK_STRING, set_title, w,
PROP_TAG_COURIER, ab->gt->gt_gw->gw_gu->gu_pc,
PROP_TAG_NAMED_ROOT, p, "self",
NULL);
gu_unsubscribe_on_destroy(GTK_OBJECT(w), s);
/* hbox */
hbox = gtk_hbox_new(FALSE, 1);
gtk_box_pack_start(GTK_BOX(ab->vbox), hbox, TRUE, TRUE, 0);
/* Album art */
w = gtk_image_new();
gtk_misc_set_alignment(GTK_MISC(w), 0.5, 0.0);
gtk_box_pack_start(GTK_BOX(hbox), w, FALSE, TRUE, 5);
s = prop_subscribe(0,
PROP_TAG_NAME("self", "metadata", "album_art"),
PROP_TAG_CALLBACK_STRING, album_set_art, w,
PROP_TAG_COURIER, ab->gt->gt_gw->gw_gu->gu_pc,
PROP_TAG_NAMED_ROOT, p, "self",
NULL);
gu_unsubscribe_on_destroy(GTK_OBJECT(w), s);
gtk_widget_show(w);
/* Tracklist */
w = gu_directory_list_create(ab->gt, p,
GU_DIR_COL_ARTIST |
GU_DIR_COL_DURATION |
GU_DIR_COL_TRACKINDEX);
gtk_box_pack_start(GTK_BOX(hbox), w, TRUE, TRUE, 0);
gtk_widget_show_all(hbox);
break;
case PROP_SET_DIR:
case PROP_SET_VOID:
break;
default:
fprintf(stderr,
"artist_albums(): Can not handle event %d, aborting()\n", event);
abort();
}
}
int
main (int argc, char **argv)
{
char *text;
GtkWidget *window;
GtkWidget *scrollwin;
GtkWidget *vbox, *hbox;
GtkWidget *frame;
GtkWidget *checkbutton;
gtk_init (&argc, &argv);
if (argc != 2)
{
fprintf (stderr, "Usage: %s FILE\n", g_get_prgname ());
exit(1);
}
/* Create the list of paragraphs from the supplied file
*/
text = read_file (argv[1]);
if (!text)
exit(1);
context = pango_win32_get_context ();
paragraphs = split_paragraphs (text);
pango_context_set_language (context, pango_language_from_string ("en_US"));
pango_context_set_base_dir (context, PANGO_DIRECTION_LTR);
font_description = pango_font_description_new ();
pango_font_description_set_family(font_description, "sans");
pango_font_description_set_size(font_description, 16 * PANGO_SCALE);
#if 0 /* default init ok? */
font_description.style = PANGO_STYLE_NORMAL;
font_description.variant = PANGO_VARIANT_NORMAL;
font_description.weight = 500;
font_description.stretch = PANGO_STRETCH_NORMAL;
#endif
pango_context_set_font_description (context, font_description);
/* Create the user interface
*/
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size (GTK_WINDOW (window), 400, 400);
gtk_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC (gtk_main_quit), NULL);
vbox = gtk_vbox_new (FALSE, 4);
gtk_container_add (GTK_CONTAINER (window), vbox);
hbox = make_font_selector ();
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
scrollwin = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrollwin),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_box_pack_start (GTK_BOX (vbox), scrollwin, TRUE, TRUE, 0);
layout = gtk_layout_new (NULL, NULL);
gtk_widget_set_events (layout, GDK_BUTTON_PRESS_MASK);
gtk_widget_set_app_paintable (layout, TRUE);
gtk_signal_connect (GTK_OBJECT (layout), "size_allocate",
GTK_SIGNAL_FUNC (size_allocate), paragraphs);
gtk_signal_connect (GTK_OBJECT (layout), "expose_event",
GTK_SIGNAL_FUNC (expose), paragraphs);
gtk_signal_connect (GTK_OBJECT (layout), "draw",
GTK_SIGNAL_FUNC (draw), paragraphs);
gtk_signal_connect (GTK_OBJECT (layout), "button_press_event",
GTK_SIGNAL_FUNC (button_press), paragraphs);
#if GTK_CHECK_VERSION (1,3,2)
gtk_widget_set_double_buffered (layout, FALSE);
#endif
gtk_container_add (GTK_CONTAINER (scrollwin), layout);
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
message_label = gtk_label_new ("Current char:");
gtk_misc_set_padding (GTK_MISC (message_label), 1, 1);
gtk_misc_set_alignment (GTK_MISC (message_label), 0.0, 0.5);
gtk_container_add (GTK_CONTAINER (frame), message_label);
checkbutton = gtk_check_button_new_with_label ("Use RTL global direction");
gtk_signal_connect (GTK_OBJECT (checkbutton), "toggled",
GTK_SIGNAL_FUNC (checkbutton_toggled), NULL);
gtk_box_pack_start (GTK_BOX (vbox), checkbutton, FALSE, FALSE, 0);
gtk_widget_show_all (window);
gtk_main ();
return 0;
}
/*****************************************************************************
* check_session_overwrite()
*****************************************************************************/
int
check_session_overwrite(char *directory)
{
struct stat filestat;
GtkWidget *dialog;
GtkWidget *label;
char filename[PATH_MAX];
gint response;
static int recurse = 0;
if (recurse) {
recurse = 0;
return 0;
}
/* check to see if the first patch file exists, since the filechooser */
/* likes to create directories automatically */
snprintf(filename, sizeof(filename), "%s/phasex-01.phx", directory);
if (stat(filename, &filestat) == 0) {
recurse = 1;
/* create dialog with buttons */
dialog = gtk_dialog_new_with_buttons("WARNING: Session directory exists",
GTK_WINDOW(main_window),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL,
GTK_STOCK_SAVE_AS,
1,
GTK_STOCK_SAVE,
GTK_RESPONSE_YES,
NULL);
gtk_window_set_wmclass(GTK_WINDOW(dialog), "phasex", "phasex-dialog");
gtk_window_set_role(GTK_WINDOW(dialog), "verify-save");
/* Alert message */
label = gtk_label_new("This operation will overwrite an existing session "
"with the same directory name. Save anyway? ");
gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
gtk_misc_set_padding(GTK_MISC(label), 8, 8);
gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), label);
//widget_set_custom_font (dialog);
gtk_widget_show_all(dialog);
/* Run the dialog */
response = gtk_dialog_run(GTK_DIALOG(dialog));
/* all finished with dialog now */
gtk_widget_destroy(dialog);
switch (response) {
case GTK_RESPONSE_YES:
/* save */
on_session_save_activate(NULL, directory);
break;
case 1:
/* save as */
run_session_save_as_dialog(NULL, directory);
break;
case GTK_RESPONSE_CANCEL:
/* cancel */
break;
}
recurse = 0;
return 1;
}
return 0;
}
GtkWidget *create_tdb_langwin(void)
{
GtkWidget *tdb_langwin;
GtkWidget *vbox_lang;
GtkWidget *f_lang_mand;
GtkWidget *hbox_lang_mand;
GtkWidget *table_lang_mand;
GtkWidget *l_lang;
GtkWidget *l_lang_code;
GtkWidget *entry1;
GtkWidget *entry2;
GtkWidget *b_lang_sel;
GtkWidget *image2;
GtkWidget *l_lang_mandatory;
GtkWidget *f_lang_opt;
GtkWidget *table_lang_opt;
GtkWidget *l_lang_diaolog;
GtkWidget *c_lang_out;
GtkWidget *c_lang_labs;
GtkWidget *c_lang_dialog;
GtkWidget *alignment3;
GtkWidget *hbox6;
GtkWidget *image4;
GtkWidget *label11;
GtkWidget *l_lang_opt;
GtkWidget *f_lang_menu;
GtkWidget *hbox_lang_menu;
GtkWidget *b_lang_OK;
GtkWidget *alignment1;
GtkWidget *hbox4;
GtkWidget *image1;
GtkWidget *label9;
GtkWidget *b_lang_new;
GtkWidget *alignment4;
GtkWidget *hbox7;
GtkWidget *image5;
GtkWidget *label12;
GtkWidget *b_lang_del;
GtkWidget *alignment5;
GtkWidget *hbox8;
GtkWidget *image6;
GtkWidget *label13;
GtkWidget *b_lang_clr;
GtkWidget *alignment6;
GtkWidget *hbox9;
GtkWidget *image7;
GtkWidget *label14;
GtkWidget *b_lang_close;
GtkWidget *alignment2;
GtkWidget *hbox5;
GtkWidget *image3;
GtkWidget *label10;
GtkWidget *label3;
GtkWidget *sb_lang;
tdb_langwin = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(tdb_langwin), _("Languages"));
vbox_lang = gtk_vbox_new(FALSE, 0);
gtk_widget_show(vbox_lang);
gtk_container_add(GTK_CONTAINER(tdb_langwin), vbox_lang);
f_lang_mand = gtk_frame_new(NULL);
gtk_widget_show(f_lang_mand);
gtk_box_pack_start(GTK_BOX(vbox_lang), f_lang_mand, TRUE, TRUE, 0);
hbox_lang_mand = gtk_hbox_new(FALSE, 0);
gtk_widget_show(hbox_lang_mand);
gtk_container_add(GTK_CONTAINER(f_lang_mand), hbox_lang_mand);
table_lang_mand = gtk_table_new(2, 2, FALSE);
gtk_widget_show(table_lang_mand);
gtk_box_pack_start(GTK_BOX(hbox_lang_mand), table_lang_mand, TRUE, TRUE, 0);
l_lang = gtk_label_new(_("Language:"));
gtk_widget_show(l_lang);
gtk_table_attach(GTK_TABLE(table_lang_mand), l_lang, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0,
0);
gtk_misc_set_alignment(GTK_MISC(l_lang), 0, 0.5);
gtk_misc_set_padding(GTK_MISC(l_lang), 3, 3);
l_lang_code = gtk_label_new(_("System code:"));
gtk_widget_show(l_lang_code);
gtk_table_attach(GTK_TABLE(table_lang_mand), l_lang_code, 0, 1, 1, 2,
(GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0,
0);
gtk_misc_set_alignment(GTK_MISC(l_lang_code), 0, 0.5);
gtk_misc_set_padding(GTK_MISC(l_lang_code), 3, 3);
entry1 = gtk_entry_new();
gtk_widget_show(entry1);
gtk_table_attach(GTK_TABLE(table_lang_mand), entry1, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
entry2 = gtk_entry_new();
gtk_widget_show(entry2);
gtk_table_attach(GTK_TABLE(table_lang_mand), entry2, 1, 2, 1, 2,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
b_lang_sel = gtk_button_new();
gtk_widget_show(b_lang_sel);
gtk_box_pack_start(GTK_BOX(hbox_lang_mand), b_lang_sel, FALSE, FALSE, 0);
image2 = gtk_image_new_from_stock("gtk-open", GTK_ICON_SIZE_BUTTON);
gtk_widget_show(image2);
gtk_container_add(GTK_CONTAINER(b_lang_sel), image2);
l_lang_mandatory = gtk_label_new(_("mandatory data"));
gtk_widget_show(l_lang_mandatory);
gtk_frame_set_label_widget(GTK_FRAME(f_lang_mand), l_lang_mandatory);
gtk_misc_set_alignment(GTK_MISC(l_lang_mandatory), 0.52, 0.5);
f_lang_opt = gtk_frame_new(NULL);
gtk_widget_show(f_lang_opt);
gtk_box_pack_start(GTK_BOX(vbox_lang), f_lang_opt, TRUE, TRUE, 0);
table_lang_opt = gtk_table_new(3, 2, FALSE);
gtk_widget_show(table_lang_opt);
gtk_container_add(GTK_CONTAINER(f_lang_opt), table_lang_opt);
l_lang_diaolog = gtk_label_new(_("Dialogue language ?"));
gtk_widget_show(l_lang_diaolog);
gtk_table_attach(GTK_TABLE(table_lang_opt), l_lang_diaolog, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0,
0);
gtk_misc_set_alignment(GTK_MISC(l_lang_diaolog), 0, 0.5);
gtk_misc_set_padding(GTK_MISC(l_lang_diaolog), 3, 3);
c_lang_out = gtk_check_button_new_with_mnemonic(_("Output language ?"));
gtk_widget_show(c_lang_out);
gtk_table_attach(GTK_TABLE(table_lang_opt), c_lang_out, 0, 1, 1, 2,
(GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0,
0);
c_lang_labs = gtk_check_button_new_with_mnemonic(_("Labels ?"));
gtk_widget_show(c_lang_labs);
gtk_table_attach(GTK_TABLE(table_lang_opt), c_lang_labs, 0, 1, 2, 3,
(GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0,
0);
c_lang_dialog = gtk_toggle_button_new();
gtk_widget_show(c_lang_dialog);
gtk_table_attach(GTK_TABLE(table_lang_opt), c_lang_dialog, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0,
0);
alignment3 = gtk_alignment_new(0.5, 0.5, 0, 0);
gtk_widget_show(alignment3);
gtk_container_add(GTK_CONTAINER(c_lang_dialog), alignment3);
hbox6 = gtk_hbox_new(FALSE, 2);
gtk_widget_show(hbox6);
gtk_container_add(GTK_CONTAINER(alignment3), hbox6);
image4 = gtk_image_new_from_stock("gtk-apply", GTK_ICON_SIZE_BUTTON);
gtk_widget_show(image4);
gtk_box_pack_start(GTK_BOX(hbox6), image4, FALSE, FALSE, 0);
label11 = gtk_label_new_with_mnemonic(_("Yes / No"));
gtk_widget_show(label11);
gtk_box_pack_start(GTK_BOX(hbox6), label11, FALSE, FALSE, 0);
l_lang_opt = gtk_label_new(_("optional data"));
gtk_widget_show(l_lang_opt);
gtk_frame_set_label_widget(GTK_FRAME(f_lang_opt), l_lang_opt);
f_lang_menu = gtk_frame_new(NULL);
gtk_widget_show(f_lang_menu);
gtk_box_pack_start(GTK_BOX(vbox_lang), f_lang_menu, TRUE, TRUE, 0);
hbox_lang_menu = gtk_hbox_new(FALSE, 3);
gtk_widget_show(hbox_lang_menu);
gtk_container_add(GTK_CONTAINER(f_lang_menu), hbox_lang_menu);
gtk_container_set_border_width(GTK_CONTAINER(hbox_lang_menu), 5);
b_lang_OK = gtk_button_new();
gtk_widget_show(b_lang_OK);
gtk_box_pack_start(GTK_BOX(hbox_lang_menu), b_lang_OK, FALSE, FALSE, 0);
alignment1 = gtk_alignment_new(0.5, 0.5, 0, 0);
gtk_widget_show(alignment1);
gtk_container_add(GTK_CONTAINER(b_lang_OK), alignment1);
hbox4 = gtk_hbox_new(FALSE, 2);
gtk_widget_show(hbox4);
gtk_container_add(GTK_CONTAINER(alignment1), hbox4);
image1 = gtk_image_new_from_stock("gtk-save", GTK_ICON_SIZE_BUTTON);
gtk_widget_show(image1);
gtk_box_pack_start(GTK_BOX(hbox4), image1, FALSE, FALSE, 0);
label9 = gtk_label_new_with_mnemonic(_("Save"));
gtk_widget_show(label9);
gtk_box_pack_start(GTK_BOX(hbox4), label9, FALSE, FALSE, 0);
b_lang_new = gtk_button_new();
gtk_widget_show(b_lang_new);
gtk_box_pack_start(GTK_BOX(hbox_lang_menu), b_lang_new, FALSE, FALSE, 0);
alignment4 = gtk_alignment_new(0.5, 0.5, 0, 0);
gtk_widget_show(alignment4);
gtk_container_add(GTK_CONTAINER(b_lang_new), alignment4);
hbox7 = gtk_hbox_new(FALSE, 2);
gtk_widget_show(hbox7);
gtk_container_add(GTK_CONTAINER(alignment4), hbox7);
image5 = gtk_image_new_from_stock("gtk-new", GTK_ICON_SIZE_BUTTON);
gtk_widget_show(image5);
gtk_box_pack_start(GTK_BOX(hbox7), image5, FALSE, FALSE, 0);
label12 = gtk_label_new_with_mnemonic(_("New"));
gtk_widget_show(label12);
gtk_box_pack_start(GTK_BOX(hbox7), label12, FALSE, FALSE, 0);
b_lang_del = gtk_button_new();
gtk_widget_show(b_lang_del);
gtk_box_pack_start(GTK_BOX(hbox_lang_menu), b_lang_del, FALSE, FALSE, 0);
alignment5 = gtk_alignment_new(0.5, 0.5, 0, 0);
gtk_widget_show(alignment5);
gtk_container_add(GTK_CONTAINER(b_lang_del), alignment5);
hbox8 = gtk_hbox_new(FALSE, 2);
gtk_widget_show(hbox8);
gtk_container_add(GTK_CONTAINER(alignment5), hbox8);
image6 = gtk_image_new_from_stock("gtk-delete", GTK_ICON_SIZE_BUTTON);
gtk_widget_show(image6);
gtk_box_pack_start(GTK_BOX(hbox8), image6, FALSE, FALSE, 0);
label13 = gtk_label_new_with_mnemonic(_("Delete"));
gtk_widget_show(label13);
gtk_box_pack_start(GTK_BOX(hbox8), label13, FALSE, FALSE, 0);
b_lang_clr = gtk_button_new();
gtk_widget_show(b_lang_clr);
gtk_box_pack_start(GTK_BOX(hbox_lang_menu), b_lang_clr, FALSE, FALSE, 0);
alignment6 = gtk_alignment_new(0.5, 0.5, 0, 0);
gtk_widget_show(alignment6);
gtk_container_add(GTK_CONTAINER(b_lang_clr), alignment6);
hbox9 = gtk_hbox_new(FALSE, 2);
gtk_widget_show(hbox9);
gtk_container_add(GTK_CONTAINER(alignment6), hbox9);
image7 = gtk_image_new_from_stock("gtk-clear", GTK_ICON_SIZE_BUTTON);
gtk_widget_show(image7);
gtk_box_pack_start(GTK_BOX(hbox9), image7, FALSE, FALSE, 0);
label14 = gtk_label_new_with_mnemonic(_("Clear"));
gtk_widget_show(label14);
gtk_box_pack_start(GTK_BOX(hbox9), label14, FALSE, FALSE, 0);
b_lang_close = gtk_button_new();
gtk_widget_show(b_lang_close);
gtk_box_pack_start(GTK_BOX(hbox_lang_menu), b_lang_close, FALSE, FALSE, 0);
alignment2 = gtk_alignment_new(0.5, 0.5, 0, 0);
gtk_widget_show(alignment2);
gtk_container_add(GTK_CONTAINER(b_lang_close), alignment2);
hbox5 = gtk_hbox_new(FALSE, 2);
gtk_widget_show(hbox5);
gtk_container_add(GTK_CONTAINER(alignment2), hbox5);
image3 = gtk_image_new_from_stock("gtk-close", GTK_ICON_SIZE_BUTTON);
gtk_widget_show(image3);
gtk_box_pack_start(GTK_BOX(hbox5), image3, FALSE, FALSE, 0);
label10 = gtk_label_new_with_mnemonic(_("Close"));
gtk_widget_show(label10);
gtk_box_pack_start(GTK_BOX(hbox5), label10, FALSE, FALSE, 0);
label3 = gtk_label_new(_("label3"));
gtk_widget_show(label3);
gtk_frame_set_label_widget(GTK_FRAME(f_lang_menu), label3);
sb_lang = gtk_statusbar_new();
gtk_widget_show(sb_lang);
gtk_box_pack_start(GTK_BOX(vbox_lang), sb_lang, FALSE, FALSE, 0);
g_signal_connect((gpointer) b_lang_sel, "clicked",
G_CALLBACK(on_b_lang_sel_clicked), NULL);
g_signal_connect((gpointer) b_lang_OK, "clicked",
G_CALLBACK(on_b_lang_OK_clicked), NULL);
g_signal_connect((gpointer) b_lang_new, "clicked",
G_CALLBACK(on_b_lang_new_clicked), NULL);
g_signal_connect((gpointer) b_lang_del, "clicked",
G_CALLBACK(on_b_lang_del_clicked), NULL);
g_signal_connect((gpointer) b_lang_clr, "clicked",
G_CALLBACK(on_b_lang_clr_clicked), NULL);
g_signal_connect((gpointer) b_lang_close, "clicked",
G_CALLBACK(on_b_lang_close_clicked), NULL);
/* Store pointers to all widgets, for use by lookup_widget(). */
GLADE_HOOKUP_OBJECT_NO_REF(tdb_langwin, tdb_langwin, "tdb_langwin");
GLADE_HOOKUP_OBJECT(tdb_langwin, vbox_lang, "vbox_lang");
GLADE_HOOKUP_OBJECT(tdb_langwin, f_lang_mand, "f_lang_mand");
GLADE_HOOKUP_OBJECT(tdb_langwin, hbox_lang_mand, "hbox_lang_mand");
GLADE_HOOKUP_OBJECT(tdb_langwin, table_lang_mand, "table_lang_mand");
GLADE_HOOKUP_OBJECT(tdb_langwin, l_lang, "l_lang");
GLADE_HOOKUP_OBJECT(tdb_langwin, l_lang_code, "l_lang_code");
GLADE_HOOKUP_OBJECT(tdb_langwin, entry1, "entry1");
GLADE_HOOKUP_OBJECT(tdb_langwin, entry2, "entry2");
GLADE_HOOKUP_OBJECT(tdb_langwin, b_lang_sel, "b_lang_sel");
GLADE_HOOKUP_OBJECT(tdb_langwin, image2, "image2");
GLADE_HOOKUP_OBJECT(tdb_langwin, l_lang_mandatory, "l_lang_mandatory");
GLADE_HOOKUP_OBJECT(tdb_langwin, f_lang_opt, "f_lang_opt");
GLADE_HOOKUP_OBJECT(tdb_langwin, table_lang_opt, "table_lang_opt");
GLADE_HOOKUP_OBJECT(tdb_langwin, l_lang_diaolog, "l_lang_diaolog");
GLADE_HOOKUP_OBJECT(tdb_langwin, c_lang_out, "c_lang_out");
GLADE_HOOKUP_OBJECT(tdb_langwin, c_lang_labs, "c_lang_labs");
GLADE_HOOKUP_OBJECT(tdb_langwin, c_lang_dialog, "c_lang_dialog");
GLADE_HOOKUP_OBJECT(tdb_langwin, alignment3, "alignment3");
GLADE_HOOKUP_OBJECT(tdb_langwin, hbox6, "hbox6");
GLADE_HOOKUP_OBJECT(tdb_langwin, image4, "image4");
GLADE_HOOKUP_OBJECT(tdb_langwin, label11, "label11");
GLADE_HOOKUP_OBJECT(tdb_langwin, l_lang_opt, "l_lang_opt");
GLADE_HOOKUP_OBJECT(tdb_langwin, f_lang_menu, "f_lang_menu");
GLADE_HOOKUP_OBJECT(tdb_langwin, hbox_lang_menu, "hbox_lang_menu");
GLADE_HOOKUP_OBJECT(tdb_langwin, b_lang_OK, "b_lang_OK");
GLADE_HOOKUP_OBJECT(tdb_langwin, alignment1, "alignment1");
GLADE_HOOKUP_OBJECT(tdb_langwin, hbox4, "hbox4");
GLADE_HOOKUP_OBJECT(tdb_langwin, image1, "image1");
GLADE_HOOKUP_OBJECT(tdb_langwin, label9, "label9");
GLADE_HOOKUP_OBJECT(tdb_langwin, b_lang_new, "b_lang_new");
GLADE_HOOKUP_OBJECT(tdb_langwin, alignment4, "alignment4");
GLADE_HOOKUP_OBJECT(tdb_langwin, hbox7, "hbox7");
GLADE_HOOKUP_OBJECT(tdb_langwin, image5, "image5");
GLADE_HOOKUP_OBJECT(tdb_langwin, label12, "label12");
GLADE_HOOKUP_OBJECT(tdb_langwin, b_lang_del, "b_lang_del");
GLADE_HOOKUP_OBJECT(tdb_langwin, alignment5, "alignment5");
GLADE_HOOKUP_OBJECT(tdb_langwin, hbox8, "hbox8");
GLADE_HOOKUP_OBJECT(tdb_langwin, image6, "image6");
GLADE_HOOKUP_OBJECT(tdb_langwin, label13, "label13");
GLADE_HOOKUP_OBJECT(tdb_langwin, b_lang_clr, "b_lang_clr");
GLADE_HOOKUP_OBJECT(tdb_langwin, alignment6, "alignment6");
GLADE_HOOKUP_OBJECT(tdb_langwin, hbox9, "hbox9");
GLADE_HOOKUP_OBJECT(tdb_langwin, image7, "image7");
GLADE_HOOKUP_OBJECT(tdb_langwin, label14, "label14");
GLADE_HOOKUP_OBJECT(tdb_langwin, b_lang_close, "b_lang_close");
GLADE_HOOKUP_OBJECT(tdb_langwin, alignment2, "alignment2");
GLADE_HOOKUP_OBJECT(tdb_langwin, hbox5, "hbox5");
GLADE_HOOKUP_OBJECT(tdb_langwin, image3, "image3");
GLADE_HOOKUP_OBJECT(tdb_langwin, label10, "label10");
GLADE_HOOKUP_OBJECT(tdb_langwin, label3, "label3");
GLADE_HOOKUP_OBJECT(tdb_langwin, sb_lang, "sb_lang");
return tdb_langwin;
}
MetaTabPopup*
meta_ui_tab_popup_new (const MetaTabEntry *entries,
int screen_number,
int entry_count,
int width,
gboolean outline)
{
MetaTabPopup *popup;
int i, left, right, top, bottom;
int height;
GtkWidget *table;
GtkWidget *vbox;
GtkWidget *align;
GList *tmp;
GtkWidget *frame;
int max_label_width; /* the actual max width of the labels we create */
AtkObject *obj;
GdkScreen *screen;
int screen_width;
popup = g_new (MetaTabPopup, 1);
popup->outline_window = gtk_window_new (GTK_WINDOW_POPUP);
screen = gdk_display_get_screen (gdk_display_get_default (),
screen_number);
gtk_window_set_screen (GTK_WINDOW (popup->outline_window),
screen);
gtk_widget_set_app_paintable (popup->outline_window, TRUE);
gtk_widget_realize (popup->outline_window);
g_signal_connect (G_OBJECT (popup->outline_window), "expose_event",
G_CALLBACK (outline_window_expose), popup);
popup->window = gtk_window_new (GTK_WINDOW_POPUP);
gtk_window_set_screen (GTK_WINDOW (popup->window),
screen);
gtk_window_set_position (GTK_WINDOW (popup->window),
GTK_WIN_POS_CENTER_ALWAYS);
/* enable resizing, to get never-shrink behavior */
gtk_window_set_resizable (GTK_WINDOW (popup->window),
TRUE);
popup->current = NULL;
popup->entries = NULL;
popup->current_selected_entry = NULL;
popup->outline = outline;
screen_width = gdk_screen_get_width (screen);
for (i = 0; i < entry_count; ++i)
{
TabEntry* new_entry = tab_entry_new (&entries[i], screen_width, outline);
popup->entries = g_list_prepend (popup->entries, new_entry);
}
popup->entries = g_list_reverse (popup->entries);
g_assert (width > 0);
height = i / width;
if (i % width)
height += 1;
table = gtk_table_new (height, width, FALSE);
vbox = gtk_vbox_new (FALSE, 0);
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_OUT);
gtk_container_set_border_width (GTK_CONTAINER (table), 1);
gtk_container_add (GTK_CONTAINER (popup->window),
frame);
gtk_container_add (GTK_CONTAINER (frame),
vbox);
align = gtk_alignment_new (0.5, 0.5, 0.0, 0.0);
gtk_box_pack_start (GTK_BOX (vbox), align, TRUE, TRUE, 0);
gtk_container_add (GTK_CONTAINER (align),
table);
popup->label = gtk_label_new ("");
/* Set the accessible role of the label to a status bar so it
* will emit name changed events that can be used by screen
* readers.
*/
obj = gtk_widget_get_accessible (popup->label);
atk_object_set_role (obj, ATK_ROLE_STATUSBAR);
gtk_misc_set_padding (GTK_MISC (popup->label), 3, 3);
gtk_box_pack_end (GTK_BOX (vbox), popup->label, FALSE, FALSE, 0);
max_label_width = 0;
top = 0;
bottom = 1;
tmp = popup->entries;
while (tmp && top < height)
{
left = 0;
right = 1;
while (tmp && left < width)
{
GtkWidget *image;
GtkRequisition req;
TabEntry *te;
te = tmp->data;
if (te->blank)
{
/* just stick a widget here to avoid special cases */
image = gtk_alignment_new (0.0, 0.0, 0.0, 0.0);
}
else if (outline)
{
if (te->dimmed_icon)
{
image = selectable_image_new (te->dimmed_icon);
}
else
{
image = selectable_image_new (te->icon);
}
gtk_misc_set_padding (GTK_MISC (image),
INSIDE_SELECT_RECT + OUTSIDE_SELECT_RECT + 1,
INSIDE_SELECT_RECT + OUTSIDE_SELECT_RECT + 1);
gtk_misc_set_alignment (GTK_MISC (image), 0.5, 0.5);
}
else
{
image = selectable_workspace_new ((MetaWorkspace *) te->key);
}
te->widget = image;
gtk_table_attach (GTK_TABLE (table),
te->widget,
left, right, top, bottom,
0, 0,
0, 0);
/* Efficiency rules! */
gtk_label_set_markup (GTK_LABEL (popup->label),
te->title);
gtk_widget_size_request (popup->label, &req);
max_label_width = MAX (max_label_width, req.width);
tmp = tmp->next;
++left;
++right;
}
++top;
++bottom;
}
/* remove all the temporary text */
gtk_label_set_text (GTK_LABEL (popup->label), "");
/* Make it so that we ellipsize if the text is too long */
gtk_label_set_ellipsize (GTK_LABEL (popup->label), PANGO_ELLIPSIZE_END);
/* Limit the window size to no bigger than screen_width/4 */
if (max_label_width>(screen_width/4))
{
max_label_width = screen_width/4;
}
max_label_width += 20; /* add random padding */
gtk_window_set_default_size (GTK_WINDOW (popup->window),
max_label_width,
-1);
return popup;
}
GtkWidget*
create_threshold_dialog (void)
{
GtkWidget *threshold_dialog;
GtkWidget *dialogVbox;
GtkWidget *allButButtonsVbox;
GtkWidget *settingsOuterHbox;
GtkWidget *settingsOuterVbox;
GtkWidget *minValueVbox;
GtkWidget *minValueLabel;
GtkWidget *minValueHbox;
GtkWidget *minValueSlider;
GtkObject *minValueSpinner_adj;
GtkWidget *minValueSpinner;
GtkWidget *maxValueVbox;
GtkWidget *maxValueLabel;
GtkWidget *maxValueHbox;
GtkWidget *maxValueSlider;
GtkObject *maxValueSpinner_adj;
GtkWidget *maxValueSpinner;
GtkWidget *outputValuesHbox;
GtkWidget *outputValuesLabel;
GtkWidget *outputValuesMenu;
GtkWidget *debugHbox;
GtkWidget *debugLabel;
GtkObject *debugSpinButton_adj;
GtkWidget *debugSpinButton;
GtkWidget *previewFrame;
GtkWidget *previewAlignment;
GtkWidget *previewVbox;
GtkWidget *previewControlHbox;
GtkWidget *previewOutputMenu;
GtkWidget *previewSlider;
GtkWidget *previewVideo;
GtkWidget *previewLabel;
GtkWidget *dialogButtonBox;
GtkWidget *cancelButton;
GtkWidget *okButton;
threshold_dialog = gtk_dialog_new ();
gtk_window_set_title (GTK_WINDOW (threshold_dialog), QT_TR_NOOP("Threshold"));
gtk_window_set_type_hint (GTK_WINDOW (threshold_dialog), GDK_WINDOW_TYPE_HINT_DIALOG);
dialogVbox = GTK_DIALOG (threshold_dialog)->vbox;
gtk_widget_show (dialogVbox);
allButButtonsVbox = gtk_vbox_new (FALSE, 12);
gtk_widget_show (allButButtonsVbox);
gtk_box_pack_start (GTK_BOX (dialogVbox), allButButtonsVbox, TRUE, TRUE, 0);
settingsOuterHbox = gtk_hbox_new (FALSE, 0);
gtk_widget_show (settingsOuterHbox);
gtk_box_pack_start (GTK_BOX (allButButtonsVbox), settingsOuterHbox, FALSE, TRUE, 0);
settingsOuterVbox = gtk_vbox_new (FALSE, 12);
gtk_widget_show (settingsOuterVbox);
gtk_box_pack_start (GTK_BOX (settingsOuterHbox), settingsOuterVbox, TRUE, TRUE, 0);
minValueVbox = gtk_vbox_new (FALSE, 0);
gtk_widget_show (minValueVbox);
gtk_box_pack_start (GTK_BOX (settingsOuterVbox), minValueVbox, FALSE, FALSE, 0);
minValueLabel = gtk_label_new (QT_TR_NOOP("Minimum value to be in-range:"));
gtk_widget_show (minValueLabel);
gtk_box_pack_start (GTK_BOX (minValueVbox), minValueLabel, FALSE, FALSE, 0);
gtk_misc_set_alignment (GTK_MISC (minValueLabel), 0.5, 1);
gtk_misc_set_padding (GTK_MISC (minValueLabel), 0, 8);
minValueHbox = gtk_hbox_new (FALSE, 5);
gtk_widget_show (minValueHbox);
gtk_box_pack_start (GTK_BOX (minValueVbox), minValueHbox, TRUE, TRUE, 0);
#ifdef ORIGINAL_CODE_GENERATED_BY_GLADE
minValueSlider = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (0, 0, 255, 1, 1, 0)));
#else
minValueSpinner_adj = gtk_adjustment_new (0, 0, 255, 1, 1, 0);
minValueSlider = gtk_hscale_new (GTK_ADJUSTMENT (minValueSpinner_adj));
#endif
gtk_widget_show (minValueSlider);
gtk_box_pack_start (GTK_BOX (minValueHbox), minValueSlider, TRUE, TRUE, 0);
gtk_scale_set_draw_value (GTK_SCALE (minValueSlider), FALSE);
gtk_scale_set_value_pos (GTK_SCALE (minValueSlider), GTK_POS_LEFT);
gtk_scale_set_digits (GTK_SCALE (minValueSlider), 0);
#ifdef ORIGINAL_CODE_GENERATED_BY_GLADE
minValueSpinner_adj = gtk_adjustment_new (0, 0, 255, 1, 10, 10);
#endif
minValueSpinner = gtk_spin_button_new (GTK_ADJUSTMENT (minValueSpinner_adj), 1, 0);
gtk_widget_show (minValueSpinner);
gtk_box_pack_start (GTK_BOX (minValueHbox), minValueSpinner, FALSE, TRUE, 0);
maxValueVbox = gtk_vbox_new (FALSE, 0);
gtk_widget_show (maxValueVbox);
gtk_box_pack_start (GTK_BOX (settingsOuterVbox), maxValueVbox, FALSE, FALSE, 0);
maxValueLabel = gtk_label_new (QT_TR_NOOP("Maximum value to be in-range:"));
gtk_widget_show (maxValueLabel);
gtk_box_pack_start (GTK_BOX (maxValueVbox), maxValueLabel, FALSE, FALSE, 0);
maxValueHbox = gtk_hbox_new (FALSE, 5);
gtk_widget_show (maxValueHbox);
gtk_box_pack_start (GTK_BOX (maxValueVbox), maxValueHbox, TRUE, TRUE, 0);
#ifdef ORIGINAL_CODE_GENERATED_BY_GLADE
maxValueSlider = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (255, 0, 255, 1, 1, 0)));
#else
maxValueSpinner_adj = gtk_adjustment_new (255, 0, 255, 1, 1, 0);
maxValueSlider = gtk_hscale_new (GTK_ADJUSTMENT (maxValueSpinner_adj));
#endif
gtk_widget_show (maxValueSlider);
gtk_box_pack_start (GTK_BOX (maxValueHbox), maxValueSlider, TRUE, TRUE, 0);
gtk_scale_set_draw_value (GTK_SCALE (maxValueSlider), FALSE);
gtk_scale_set_value_pos (GTK_SCALE (maxValueSlider), GTK_POS_LEFT);
gtk_scale_set_digits (GTK_SCALE (maxValueSlider), 0);
#ifdef ORIGINAL_CODE_GENERATED_BY_GLADE
maxValueSpinner_adj = gtk_adjustment_new (255, 0, 255, 1, 10, 10);
#endif
maxValueSpinner = gtk_spin_button_new (GTK_ADJUSTMENT (maxValueSpinner_adj), 1, 0);
gtk_widget_show (maxValueSpinner);
gtk_box_pack_start (GTK_BOX (maxValueHbox), maxValueSpinner, FALSE, TRUE, 0);
outputValuesHbox = gtk_hbox_new (FALSE, 0);
gtk_widget_show (outputValuesHbox);
gtk_box_pack_start (GTK_BOX (settingsOuterVbox), outputValuesHbox, TRUE, TRUE, 0);
outputValuesLabel = gtk_label_new (QT_TR_NOOP("Output values: "));
gtk_widget_show (outputValuesLabel);
gtk_box_pack_start (GTK_BOX (outputValuesHbox), outputValuesLabel, FALSE, FALSE, 0);
outputValuesMenu = gtk_combo_box_new_text ();
gtk_widget_show (outputValuesMenu);
gtk_box_pack_start (GTK_BOX (outputValuesHbox), outputValuesMenu, TRUE, TRUE, 0);
gtk_combo_box_append_text (GTK_COMBO_BOX (outputValuesMenu), QT_TR_NOOP("In-range values go black, out-of-range values go white"));
gtk_combo_box_append_text (GTK_COMBO_BOX (outputValuesMenu), QT_TR_NOOP("In-range values go white, out-of-range values go black"));
debugHbox = gtk_hbox_new (FALSE, 0);
gtk_widget_show (debugHbox);
gtk_box_pack_start (GTK_BOX (settingsOuterVbox), debugHbox, TRUE, TRUE, 0);
debugLabel = gtk_label_new (QT_TR_NOOP("Debugging settings (bits): "));
gtk_widget_show (debugLabel);
gtk_box_pack_start (GTK_BOX (debugHbox), debugLabel, FALSE, FALSE, 0);
debugSpinButton_adj = gtk_adjustment_new (0, 0, 16777215, 1, 10, 10);
debugSpinButton = gtk_spin_button_new (GTK_ADJUSTMENT (debugSpinButton_adj), 1, 0);
gtk_widget_show (debugSpinButton);
gtk_box_pack_start (GTK_BOX (debugHbox), debugSpinButton, TRUE, TRUE, 0);
previewFrame = gtk_frame_new (NULL);
gtk_widget_show (previewFrame);
gtk_box_pack_start (GTK_BOX (allButButtonsVbox), previewFrame, TRUE, TRUE, 0);
previewAlignment = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_show (previewAlignment);
gtk_container_add (GTK_CONTAINER (previewFrame), previewAlignment);
gtk_alignment_set_padding (GTK_ALIGNMENT (previewAlignment), 0, 8, 6, 8);
previewVbox = gtk_vbox_new (FALSE, 5);
gtk_widget_show (previewVbox);
gtk_container_add (GTK_CONTAINER (previewAlignment), previewVbox);
previewControlHbox = gtk_hbox_new (FALSE, 5);
gtk_widget_show (previewControlHbox);
gtk_box_pack_start (GTK_BOX (previewVbox), previewControlHbox, TRUE, TRUE, 0);
previewOutputMenu = gtk_combo_box_new_text ();
gtk_widget_show (previewOutputMenu);
gtk_box_pack_start (GTK_BOX (previewControlHbox), previewOutputMenu, FALSE, TRUE, 0);
previewSlider = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (0, 0, 99, 1, 1, 1)));
gtk_widget_show (previewSlider);
gtk_box_pack_start (GTK_BOX (previewControlHbox), previewSlider, TRUE, TRUE, 0);
gtk_scale_set_digits (GTK_SCALE (previewSlider), 0);
previewVideo = gtk_drawing_area_new ();
gtk_widget_show (previewVideo);
gtk_box_pack_start (GTK_BOX (previewVbox), previewVideo, TRUE, TRUE, 0);
gtk_widget_set_size_request (previewVideo, 30, 30);
gtk_widget_set_events (previewVideo, GDK_BUTTON1_MOTION_MASK | GDK_BUTTON_PRESS_MASK);
previewLabel = gtk_label_new (QT_TR_NOOP("Preview"));
gtk_widget_show (previewLabel);
gtk_frame_set_label_widget (GTK_FRAME (previewFrame), previewLabel);
dialogButtonBox = GTK_DIALOG (threshold_dialog)->action_area;
gtk_widget_show (dialogButtonBox);
gtk_button_box_set_layout (GTK_BUTTON_BOX (dialogButtonBox), GTK_BUTTONBOX_END);
cancelButton = gtk_button_new_from_stock ("gtk-cancel");
gtk_widget_show (cancelButton);
gtk_dialog_add_action_widget (GTK_DIALOG (threshold_dialog), cancelButton, GTK_RESPONSE_CANCEL);
GTK_WIDGET_SET_FLAGS (cancelButton, GTK_CAN_DEFAULT);
okButton = gtk_button_new_from_stock ("gtk-ok");
gtk_widget_show (okButton);
gtk_dialog_add_action_widget (GTK_DIALOG (threshold_dialog), okButton, GTK_RESPONSE_OK);
GTK_WIDGET_SET_FLAGS (okButton, GTK_CAN_DEFAULT);
/* Store pointers to all widgets, for use by lookup_widget(). */
GLADE_HOOKUP_OBJECT_NO_REF (threshold_dialog, threshold_dialog, "threshold_dialog");
GLADE_HOOKUP_OBJECT_NO_REF (threshold_dialog, dialogVbox, "dialogVbox");
GLADE_HOOKUP_OBJECT (threshold_dialog, allButButtonsVbox, "allButButtonsVbox");
GLADE_HOOKUP_OBJECT (threshold_dialog, settingsOuterHbox, "settingsOuterHbox");
GLADE_HOOKUP_OBJECT (threshold_dialog, settingsOuterVbox, "settingsOuterVbox");
GLADE_HOOKUP_OBJECT (threshold_dialog, minValueVbox, "minValueVbox");
GLADE_HOOKUP_OBJECT (threshold_dialog, minValueLabel, "minValueLabel");
GLADE_HOOKUP_OBJECT (threshold_dialog, minValueHbox, "minValueHbox");
GLADE_HOOKUP_OBJECT (threshold_dialog, minValueSlider, "minValueSlider");
GLADE_HOOKUP_OBJECT (threshold_dialog, minValueSpinner, "minValueSpinner");
GLADE_HOOKUP_OBJECT (threshold_dialog, maxValueVbox, "maxValueVbox");
GLADE_HOOKUP_OBJECT (threshold_dialog, maxValueLabel, "maxValueLabel");
GLADE_HOOKUP_OBJECT (threshold_dialog, maxValueHbox, "maxValueHbox");
GLADE_HOOKUP_OBJECT (threshold_dialog, maxValueSlider, "maxValueSlider");
GLADE_HOOKUP_OBJECT (threshold_dialog, maxValueSpinner, "maxValueSpinner");
GLADE_HOOKUP_OBJECT (threshold_dialog, outputValuesHbox, "outputValuesHbox");
GLADE_HOOKUP_OBJECT (threshold_dialog, outputValuesLabel, "outputValuesLabel");
GLADE_HOOKUP_OBJECT (threshold_dialog, outputValuesMenu, "outputValuesMenu");
GLADE_HOOKUP_OBJECT (threshold_dialog, debugHbox, "debugHbox");
GLADE_HOOKUP_OBJECT (threshold_dialog, debugLabel, "debugLabel");
GLADE_HOOKUP_OBJECT (threshold_dialog, debugSpinButton, "debugSpinButton");
GLADE_HOOKUP_OBJECT (threshold_dialog, previewFrame, "previewFrame");
GLADE_HOOKUP_OBJECT (threshold_dialog, previewAlignment, "previewAlignment");
GLADE_HOOKUP_OBJECT (threshold_dialog, previewVbox, "previewVbox");
GLADE_HOOKUP_OBJECT (threshold_dialog, previewControlHbox, "previewControlHbox");
GLADE_HOOKUP_OBJECT (threshold_dialog, previewOutputMenu, "previewOutputMenu");
GLADE_HOOKUP_OBJECT (threshold_dialog, previewSlider, "previewSlider");
GLADE_HOOKUP_OBJECT (threshold_dialog, previewVideo, "previewVideo");
GLADE_HOOKUP_OBJECT (threshold_dialog, previewLabel, "previewLabel");
GLADE_HOOKUP_OBJECT_NO_REF (threshold_dialog, dialogButtonBox, "dialogButtonBox");
GLADE_HOOKUP_OBJECT (threshold_dialog, cancelButton, "cancelButton");
GLADE_HOOKUP_OBJECT (threshold_dialog, okButton, "okButton");
return threshold_dialog;
}
void AP_UnixDialog_Styles::_constructModifyDialogContents(GtkWidget * container)
{
GtkWidget *dialog_vbox1 = NULL;
GtkWidget *OverallVbox = NULL;
GtkWidget *comboTable = NULL;
GtkWidget *nameLabel = NULL;
GtkWidget *basedOnLabel = NULL;
GtkWidget *followingLabel = NULL;
GtkWidget *styleTypeLabel = NULL;
GtkWidget *styleNameEntry = NULL;
GtkWidget *basedOnCombo = NULL;
GtkWidget *basedOnEntry = NULL;
GtkWidget *followingCombo = NULL;
GtkWidget *followingEntry = NULL;
GtkWidget *styleTypeCombo = NULL;
GtkWidget *styleTypeEntry = NULL;
GtkWidget *previewFrame = NULL;
GtkWidget *modifyDrawingArea = NULL;
GtkWidget *DescriptionText = NULL;
GtkWidget *checkBoxRow = NULL;
GtkWidget *checkAddTo = NULL;
GtkWidget *checkAutoUpdate = NULL;
GtkWidget *deletePropCombo = NULL;
GtkWidget *deletePropEntry = NULL;
GtkWidget *deletePropButton = NULL;
const XAP_StringSet * pSS = m_pApp->getStringSet();
dialog_vbox1 = container;
gtk_widget_show (dialog_vbox1);
OverallVbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_widget_show (OverallVbox);
gtk_box_pack_start (GTK_BOX (dialog_vbox1), OverallVbox, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (OverallVbox), 5);
comboTable = gtk_table_new (4,2, TRUE);
gtk_widget_show (comboTable);
gtk_box_pack_start (GTK_BOX (OverallVbox), comboTable, TRUE, TRUE, 2);
gtk_container_set_border_width (GTK_CONTAINER (comboTable), 2);
gtk_table_set_row_spacings (GTK_TABLE (comboTable), 6);
gtk_table_set_col_spacings (GTK_TABLE (comboTable), 2);
UT_UTF8String s;
pSS->getValueUTF8(AP_STRING_ID_DLG_Styles_ModifyName,s);
nameLabel = gtk_label_new ( s.utf8_str());
gtk_widget_show (nameLabel);
gtk_table_attach (GTK_TABLE (comboTable), nameLabel, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (nameLabel), 0, 0.5);
gtk_label_set_justify (GTK_LABEL (nameLabel), GTK_JUSTIFY_LEFT);
gtk_misc_set_padding (GTK_MISC (nameLabel), 2, 2);
pSS->getValueUTF8(AP_STRING_ID_DLG_Styles_ModifyType,s);
styleTypeLabel = gtk_label_new ( s.utf8_str());
gtk_widget_show (styleTypeLabel);
gtk_table_attach (GTK_TABLE (comboTable), styleTypeLabel, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (styleTypeLabel), 0, 0.5);
gtk_label_set_justify (GTK_LABEL (styleTypeLabel), GTK_JUSTIFY_LEFT);
gtk_misc_set_padding (GTK_MISC (styleTypeLabel), 2, 2);
pSS->getValueUTF8(AP_STRING_ID_DLG_Styles_ModifyBasedOn,s);
basedOnLabel = gtk_label_new (s.utf8_str() );
gtk_widget_show (basedOnLabel);
gtk_table_attach (GTK_TABLE (comboTable), basedOnLabel, 0, 1, 2, 3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (basedOnLabel), 0, 0.5);
gtk_label_set_justify (GTK_LABEL (basedOnLabel), GTK_JUSTIFY_LEFT);
gtk_misc_set_padding (GTK_MISC (basedOnLabel), 2, 2);
pSS->getValueUTF8(AP_STRING_ID_DLG_Styles_ModifyFollowing,s);
followingLabel = gtk_label_new (s.utf8_str());
gtk_widget_show (followingLabel);
gtk_table_attach (GTK_TABLE (comboTable), followingLabel, 1, 2, 2, 3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (followingLabel), 0, 0.5);
gtk_misc_set_padding (GTK_MISC (followingLabel), 2, 3);
styleNameEntry = gtk_entry_new ();
gtk_widget_show (styleNameEntry);
gtk_table_attach (GTK_TABLE (comboTable), styleNameEntry, 0, 1, 1, 2,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_widget_set_size_request (styleNameEntry, 158, -1);
basedOnCombo = gtk_combo_box_text_new_with_entry ();
gtk_widget_show (basedOnCombo);
gtk_table_attach (GTK_TABLE (comboTable), basedOnCombo, 0, 1, 3, 4,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
basedOnEntry = gtk_bin_get_child(GTK_BIN(basedOnCombo));
gtk_widget_show (basedOnEntry);
gtk_widget_set_size_request (basedOnEntry, 158, -1);
followingCombo = gtk_combo_box_text_new_with_entry ();
gtk_widget_show (followingCombo);
gtk_table_attach (GTK_TABLE (comboTable), followingCombo, 1, 2, 3, 4,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
followingEntry = gtk_bin_get_child(GTK_BIN(followingCombo));
gtk_widget_show (followingEntry);
gtk_widget_set_size_request (followingEntry, 158, -1);
//
// Cannot modify style type attribute
//
if(isNew())
{
styleTypeCombo = gtk_combo_box_text_new_with_entry();
gtk_widget_show (styleTypeCombo);
gtk_table_attach (GTK_TABLE (comboTable), styleTypeCombo, 1, 2, 1, 2,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
styleTypeEntry = gtk_bin_get_child(GTK_BIN(styleTypeCombo));
gtk_widget_show (styleTypeEntry);
gtk_widget_set_size_request (styleTypeEntry, 158, -1);
}
else
{
styleTypeEntry = gtk_entry_new ();
gtk_widget_show (styleTypeEntry);
gtk_table_attach (GTK_TABLE (comboTable), styleTypeEntry, 1, 2, 1, 2,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_widget_set_size_request (styleTypeEntry, 158, -1);
}
pSS->getValueUTF8(AP_STRING_ID_DLG_Styles_ModifyPreview,s);
previewFrame = gtk_frame_new (s.utf8_str());
gtk_frame_set_shadow_type(GTK_FRAME(previewFrame), GTK_SHADOW_NONE);
gtk_widget_show (previewFrame);
gtk_box_pack_start (GTK_BOX (OverallVbox), previewFrame, TRUE, TRUE, 2);
gtk_container_set_border_width (GTK_CONTAINER (previewFrame), 5);
modifyDrawingArea = createDrawingArea();
gtk_widget_show (modifyDrawingArea);
gtk_container_add (GTK_CONTAINER (previewFrame), modifyDrawingArea);
gtk_widget_set_size_request (modifyDrawingArea, -1, 120);
pSS->getValueUTF8(AP_STRING_ID_DLG_Styles_ModifyDescription,s);
GtkWidget * descriptionFrame = gtk_frame_new (s.utf8_str());
gtk_frame_set_shadow_type(GTK_FRAME(descriptionFrame), GTK_SHADOW_NONE);
gtk_widget_show (descriptionFrame);
gtk_box_pack_start (GTK_BOX (OverallVbox), descriptionFrame, FALSE, FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (descriptionFrame), 5);
DescriptionText = gtk_label_new (NULL);
gtk_widget_show (DescriptionText);
gtk_container_add (GTK_CONTAINER (descriptionFrame), DescriptionText);
gtk_misc_set_alignment (GTK_MISC (DescriptionText), 0, 0.5);
gtk_label_set_justify (GTK_LABEL (DescriptionText), GTK_JUSTIFY_LEFT);
gtk_label_set_line_wrap (GTK_LABEL (DescriptionText), TRUE);
//
// Code to choose properties to be removed from the current style.
//
GtkWidget * deleteRow = gtk_box_new(GTK_ORIENTATION_HORIZONTAL,2);
gtk_widget_show (deleteRow);
gtk_box_pack_start (GTK_BOX (OverallVbox), deleteRow, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (deleteRow), 2);
pSS->getValueUTF8(AP_STRING_ID_DLG_Styles_RemoveLab,s);
GtkWidget * deleteLabel = gtk_label_new(s.utf8_str());
gtk_widget_show (deleteLabel);
gtk_box_pack_start (GTK_BOX (deleteRow), deleteLabel, TRUE, TRUE, 0);
GtkListStore * store = gtk_list_store_new(1, G_TYPE_STRING);
deletePropCombo = gtk_combo_box_new_with_model_and_entry(GTK_TREE_MODEL(store));
gtk_widget_show (deletePropCombo);
gtk_box_pack_start (GTK_BOX (deleteRow), deletePropCombo, TRUE, TRUE, 0);
deletePropEntry = gtk_bin_get_child(GTK_BIN(deletePropCombo));
gtk_widget_show (deletePropEntry);
gtk_widget_set_size_request (deletePropEntry, 158, -1);
pSS->getValueUTF8(AP_STRING_ID_DLG_Styles_RemoveButton,s);
deletePropButton = gtk_button_new_with_label(s.utf8_str());
gtk_widget_show(deletePropButton);
gtk_box_pack_start (GTK_BOX (deleteRow), deletePropButton, TRUE, TRUE, 0);
checkBoxRow = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 3);
gtk_box_pack_start (GTK_BOX (OverallVbox), checkBoxRow, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (checkBoxRow), 2);
pSS->getValueUTF8(AP_STRING_ID_DLG_Styles_ModifyTemplate,s);
checkAddTo = gtk_check_button_new_with_label (s.utf8_str());
gtk_widget_show (checkAddTo);
gtk_box_pack_start (GTK_BOX (checkBoxRow), checkAddTo, TRUE, TRUE, 0);
pSS->getValueUTF8(AP_STRING_ID_DLG_Styles_ModifyAutomatic,s);
checkAutoUpdate = gtk_check_button_new_with_label (s.utf8_str());
gtk_widget_show (checkAutoUpdate);
gtk_box_pack_start (GTK_BOX (checkBoxRow), checkAutoUpdate, TRUE, TRUE, 0);
//
// Save widget pointers in member variables
//
m_wStyleNameEntry = styleNameEntry;
m_wBasedOnCombo = basedOnCombo;
m_wBasedOnEntry = basedOnEntry;
m_wFollowingCombo = followingCombo;
m_wFollowingEntry = followingEntry;
m_wStyleTypeCombo = styleTypeCombo;
m_wStyleTypeEntry = styleTypeEntry;
m_wModifyDrawingArea = modifyDrawingArea;
m_wLabDescription = DescriptionText;
m_wDeletePropCombo = deletePropCombo;
m_wDeletePropEntry = deletePropEntry;
m_wDeletePropButton = deletePropButton;
}
static GtkWidget *create_dialog(void)
{
GtkWidget *dialog;
GtkWidget *header_image;
GtkWidget *header_label;
GtkWidget *label_info;
GtkWidget *codename_label;
GtkWidget *builddate_label;
GtkWidget *url_button;
GtkWidget *cop_label;
GtkWidget *label;
GtkWidget *license_textview;
GtkWidget *notebook;
GtkWidget *box;
GtkWidget *credits_scrollwin;
GtkWidget *table;
GtkWidget *license_scrollwin;
GtkWidget *info_box;
GtkWidget *header_hbox;
GtkWidget *header_eventbox;
GdkPixbuf *icon;
GtkTextBuffer* tb;
gchar *license_text = NULL;
gchar buffer[512];
gchar buffer2[128];
guint i, row = 0;
dialog = gtk_dialog_new();
/* configure dialog */
gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(main_widgets.window));
gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER_ON_PARENT);
gtk_window_set_title(GTK_WINDOW(dialog), _("About Geany"));
gtk_widget_set_name(dialog, "GeanyDialog");
gtk_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE);
gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_CLOSE);
gtk_dialog_set_has_separator(GTK_DIALOG(dialog), FALSE);
g_signal_connect(dialog, "key-press-event", G_CALLBACK(gb_on_key_pressed), NULL);
/* create header */
header_eventbox = gtk_event_box_new();
gtk_widget_show(header_eventbox);
header_hbox = gtk_hbox_new(FALSE, 12);
gtk_container_set_border_width(GTK_CONTAINER(header_hbox), 4);
gtk_widget_show(header_hbox);
gtk_container_add(GTK_CONTAINER(header_eventbox), header_hbox);
header_image = gtk_image_new();
gtk_box_pack_start(GTK_BOX(header_hbox), header_image, FALSE, FALSE, 0);
header_label = gtk_label_new(NULL);
gtk_label_set_use_markup(GTK_LABEL(header_label), TRUE);
/* print the subversion revision generated by ./configure if it is available */
g_snprintf(buffer, sizeof(buffer), HEADER, main_get_version_string());
gtk_label_set_markup(GTK_LABEL(header_label), buffer);
gtk_widget_show(header_label);
gtk_box_pack_start(GTK_BOX(header_hbox), header_label, FALSE, FALSE, 0);
header_eventbox_style_set(header_eventbox);
header_label_style_set(header_label);
g_signal_connect_after(header_eventbox, "style-set", G_CALLBACK(header_eventbox_style_set), NULL);
g_signal_connect_after(header_label, "style-set", G_CALLBACK(header_label_style_set), NULL);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), header_eventbox, FALSE, FALSE, 0);
/* set image */
icon = ui_new_pixbuf_from_inline(GEANY_IMAGE_LOGO);
gtk_image_set_from_pixbuf(GTK_IMAGE(header_image), icon);
gtk_window_set_icon(GTK_WINDOW(dialog), icon);
g_object_unref(icon); /* free our reference */
/* create notebook */
notebook = gtk_notebook_new();
gtk_widget_show(notebook);
gtk_container_set_border_width(GTK_CONTAINER(notebook), 2);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), notebook, TRUE, TRUE, 0);
/* create "Info" tab */
info_box = gtk_vbox_new(FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(info_box), 6);
gtk_widget_show(info_box);
label_info = gtk_label_new(NULL);
gtk_label_set_justify(GTK_LABEL(label_info), GTK_JUSTIFY_CENTER);
gtk_label_set_selectable(GTK_LABEL(label_info), TRUE);
gtk_label_set_use_markup(GTK_LABEL(label_info), TRUE);
g_snprintf(buffer, sizeof(buffer), INFO, _("A fast and lightweight IDE"));
gtk_label_set_markup(GTK_LABEL(label_info), buffer);
gtk_misc_set_padding(GTK_MISC(label_info), 2, 11);
gtk_widget_show(label_info);
gtk_box_pack_start(GTK_BOX(info_box), label_info, FALSE, FALSE, 0);
/* Codename label */
codename_label = gtk_label_new(NULL);
gtk_label_set_justify(GTK_LABEL(codename_label), GTK_JUSTIFY_CENTER);
gtk_label_set_selectable(GTK_LABEL(codename_label), TRUE);
gtk_label_set_use_markup(GTK_LABEL(codename_label), TRUE);
gtk_label_set_markup(GTK_LABEL(codename_label), CODENAME);
gtk_misc_set_padding(GTK_MISC(codename_label), 2, 8);
gtk_widget_show(codename_label);
gtk_box_pack_start(GTK_BOX(info_box), codename_label, FALSE, FALSE, 0);
/* build date label */
builddate_label = gtk_label_new(NULL);
gtk_label_set_justify(GTK_LABEL(builddate_label), GTK_JUSTIFY_CENTER);
gtk_label_set_selectable(GTK_LABEL(builddate_label), TRUE);
gtk_label_set_use_markup(GTK_LABEL(builddate_label), TRUE);
g_snprintf(buffer2, sizeof(buffer2), _("(built on or after %s)"), __DATE__);
g_snprintf(buffer, sizeof(buffer), BUILDDATE, buffer2);
gtk_label_set_markup(GTK_LABEL(builddate_label), buffer);
gtk_misc_set_padding(GTK_MISC(builddate_label), 2, 2);
gtk_widget_show(builddate_label);
gtk_box_pack_start(GTK_BOX(info_box), builddate_label, FALSE, FALSE, 0);
box = gtk_hbutton_box_new();
url_button = gtk_button_new();
gtk_button_set_relief(GTK_BUTTON(url_button), GTK_RELIEF_NONE);
g_signal_connect(url_button, "clicked", G_CALLBACK(homepage_clicked), (gpointer)GEANY_HOMEPAGE);
label = gtk_label_new(NULL);
gtk_label_set_text(GTK_LABEL(label), GEANY_HOMEPAGE);
gtk_widget_show(label);
gtk_container_add(GTK_CONTAINER(url_button), label);
gtk_widget_show(url_button);
gtk_box_pack_start(GTK_BOX(box), url_button, FALSE, FALSE, 0);
gtk_widget_show(box);
gtk_box_pack_start(GTK_BOX(info_box), box, FALSE, FALSE, 10);
/* copyright label */
cop_label = gtk_label_new(NULL);
gtk_label_set_justify(GTK_LABEL(cop_label), GTK_JUSTIFY_CENTER);
gtk_label_set_selectable(GTK_LABEL(cop_label), FALSE);
gtk_label_set_use_markup(GTK_LABEL(cop_label), TRUE);
gtk_label_set_markup(GTK_LABEL(cop_label), COPYRIGHT);
gtk_misc_set_padding(GTK_MISC(cop_label), 2, 10);
gtk_widget_show(cop_label);
gtk_box_pack_start(GTK_BOX(info_box), cop_label, FALSE, FALSE, 0);
/*gtk_container_add(GTK_CONTAINER(info_box), cop_label); */
label = gtk_label_new(_("Info"));
gtk_widget_show(label);
gtk_widget_show_all(info_box);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), info_box, label);
/* create "Credits" tab */
credits_scrollwin = gtk_scrolled_window_new(NULL, NULL);
gtk_container_set_border_width(GTK_CONTAINER(credits_scrollwin), 10);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(credits_scrollwin),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
table = gtk_table_new(23 + translators_len + prev_translators_len, 3, FALSE);
gtk_table_set_col_spacings(GTK_TABLE(table), 10);
row = 0;
g_snprintf(buffer, sizeof(buffer),
"<span size=\"larger\" weight=\"bold\">%s</span>", _("Developers"));
label = gtk_label_new(buffer);
gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1, GTK_FILL, 0, 0, 5);
gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
gtk_misc_set_alignment(GTK_MISC(label), 0, 0);
row++;
g_snprintf(buffer, sizeof(buffer), "Colomban Wendling - %s", _("maintainer"));
ROW(buffer, row, 0, 0, 0, 1);
row++;
ROW("<[email protected]>", row, 0, 0, 0, 1);
row++;
ROW("", row, 0, 0, 0, 0);
row++;
g_snprintf(buffer, sizeof(buffer), "Nick Treleaven - %s", _("developer"));
ROW(buffer, row, 0, 0, 0, 1);
row++;
ROW("<[email protected]>", row, 0, 0, 0, 1);
row++;
ROW("", row, 0, 0, 0, 0);
row++;
g_snprintf(buffer, sizeof(buffer), "Enrico Tröger - %s", _("developer"));
ROW(buffer, row, 0, 0, 0, 1);
row++;
ROW("<[email protected]>", row, 0, 0, 0, 1);
row++;
ROW("", row, 0, 0, 0, 0);
row++;
g_snprintf(buffer, sizeof(buffer), "Matthew Brush - %s", _("developer"));
ROW(buffer, row, 0, 0, 0, 1);
row++;
ROW("<[email protected]>", row, 0, 0, 0, 1);
row++;
ROW("", row, 0, 0, 0, 0);
row++;
g_snprintf(buffer, sizeof(buffer), "Frank Lanitz - %s", _("translation maintainer"));
ROW(buffer, row, 0, 0, 0, 1);
row++;
ROW("<[email protected]>", row, 0, 0, 0, 1);
row++;
ROW("", row, 0, 0, 0, 0);
row++;
g_snprintf(buffer, sizeof(buffer),
"<span size=\"larger\" weight=\"bold\">%s</span>", _("Translators"));
label = gtk_label_new(buffer);
gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 5);
gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
row++;
for (i = 0; i < translators_len; i++)
{
ROW(translators[i][0], row, 0, 1, 4, 0);
ROW(translators[i][1], row, 1, 0, 4, 0);
row++;
}
ROW("", row, 0, 0, 0, 0);
row++;
g_snprintf(buffer, sizeof(buffer),
"<span size=\"larger\" weight=\"bold\">%s</span>", _("Previous Translators"));
label = gtk_label_new(buffer);
gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 5);
gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
row++;
for (i = 0; i < prev_translators_len; i++)
{
ROW(prev_translators[i][0], row, 0, 1, 4, 0);
ROW(prev_translators[i][1], row, 1, 0, 4, 0);
row++;
}
ROW("", row, 0, 0, 0, 0);
row++;
g_snprintf(buffer, sizeof(buffer),
"<span size=\"larger\" weight=\"bold\">%s</span>", _("Contributors"));
label = gtk_label_new(buffer);
gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 5);
gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
row++;
g_snprintf(buffer, sizeof(buffer),
_("Some of the many contributors (for a more detailed list, see the file %s):"),
#ifdef G_OS_WIN32
"Thanks.txt"
#else
"THANKS"
#endif
);
label = geany_wrap_label_new(buffer);
gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 5);
gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
row++;
label = geany_wrap_label_new(contributors);
gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1,
(GtkAttachOptions) (GTK_FILL | GTK_EXPAND),
(GtkAttachOptions) (0), 0, 5);
gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
row++;
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(credits_scrollwin), table);
gtk_viewport_set_shadow_type(GTK_VIEWPORT(gtk_widget_get_parent(table)), GTK_SHADOW_NONE);
gtk_widget_show_all(table);
label = gtk_label_new(_("Credits"));
gtk_widget_show(label);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), credits_scrollwin, label);
/* create "License" tab */
license_scrollwin = gtk_scrolled_window_new(NULL, NULL);
gtk_container_set_border_width(GTK_CONTAINER(license_scrollwin), 6);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(license_scrollwin),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
license_textview = gtk_text_view_new();
gtk_text_view_set_editable(GTK_TEXT_VIEW(license_textview), FALSE);
gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(license_textview), FALSE);
gtk_widget_show(license_textview);
gtk_container_add(GTK_CONTAINER(license_scrollwin), license_textview);
label = gtk_label_new(_("License"));
gtk_widget_show(label);
g_snprintf(buffer, sizeof(buffer), "%s" G_DIR_SEPARATOR_S "GPL-2", app->datadir);
g_file_get_contents(buffer, &license_text, NULL, NULL);
if (license_text == NULL)
{
license_text = g_strdup(
_("License text could not be found, please visit http://www.gnu.org/licenses/gpl-2.0.txt to view it online."));
}
tb = gtk_text_view_get_buffer(GTK_TEXT_VIEW(license_textview));
gtk_text_buffer_set_text(tb, license_text, -1);
g_free(license_text);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), license_scrollwin, label);
gtk_widget_show_all(dialog);
return dialog;
}
/**
* thunar_dialogs_show_rename_file:
* @parent : a #GtkWidget on which the error dialog should be shown, or a #GdkScreen
* if no #GtkWidget is known. May also be %NULL, in which case the default
* #GdkScreen will be used.
* @file : the #ThunarFile we're going to rename.
*
* Displays the Thunar rename dialog for a single file rename.
*
* Return value: The #ThunarJob responsible for renaming the file or
* %NULL if there was no renaming required.
**/
ThunarJob *
thunar_dialogs_show_rename_file (gpointer parent,
ThunarFile *file)
{
ThunarIconFactory *icon_factory;
GtkIconTheme *icon_theme;
const gchar *filename;
const gchar *text;
ThunarJob *job = NULL;
GtkWidget *dialog;
GtkWidget *entry;
GtkWidget *label;
GtkWidget *image;
GtkWidget *table;
GtkWindow *window;
GdkPixbuf *icon;
GdkScreen *screen;
glong offset;
gchar *title;
gint response;
PangoLayout *layout;
gint layout_width;
gint layout_offset;
gint parent_width = 500;
_thunar_return_val_if_fail (parent == NULL || GDK_IS_SCREEN (parent) || GTK_IS_WINDOW (parent), FALSE);
_thunar_return_val_if_fail (THUNAR_IS_FILE (file), FALSE);
/* parse the parent window and screen */
screen = thunar_util_parse_parent (parent, &window);
/* get the filename of the file */
filename = thunar_file_get_display_name (file);
/* create a new dialog window */
title = g_strdup_printf (_("Rename \"%s\""), filename);
dialog = gtk_dialog_new_with_buttons (title,
window,
GTK_DIALOG_MODAL
| GTK_DIALOG_NO_SEPARATOR
| GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
_("_Rename"), GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
g_free (title);
/* move the dialog to the appropriate screen */
if (G_UNLIKELY (window == NULL && screen != NULL))
gtk_window_set_screen (GTK_WINDOW (dialog), screen);
table = g_object_new (GTK_TYPE_TABLE, "border-width", 6, "column-spacing", 6, "row-spacing", 3, NULL);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), table, TRUE, TRUE, 0);
gtk_widget_show (table);
icon_theme = gtk_icon_theme_get_for_screen (gtk_widget_get_screen (dialog));
icon_factory = thunar_icon_factory_get_for_icon_theme (icon_theme);
icon = thunar_icon_factory_load_file_icon (icon_factory, file, THUNAR_FILE_ICON_STATE_DEFAULT, 48);
g_object_unref (G_OBJECT (icon_factory));
image = gtk_image_new_from_pixbuf (icon);
gtk_misc_set_padding (GTK_MISC (image), 6, 6);
gtk_table_attach (GTK_TABLE (table), image, 0, 1, 0, 2, GTK_FILL, GTK_FILL, 0, 0);
g_object_unref (G_OBJECT (icon));
gtk_widget_show (image);
label = gtk_label_new (_("Enter the new name:"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0f, 0.5f);
gtk_table_attach (GTK_TABLE (table), label, 1, 2, 0, 1, GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
entry = gtk_entry_new ();
gtk_entry_set_activates_default (GTK_ENTRY (entry), TRUE);
gtk_table_attach (GTK_TABLE (table), entry, 1, 2, 1, 2, GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (entry);
/* setup the old filename */
gtk_entry_set_text (GTK_ENTRY (entry), filename);
/* check if we don't have a directory here */
if (!thunar_file_is_directory (file))
{
/* check if the filename contains an extension */
text = thunar_util_str_get_extension (filename);
if (G_LIKELY (text != NULL))
{
/* grab focus to the entry first, else the selection will be altered later */
gtk_widget_grab_focus (entry);
/* determine the UTF-8 char offset */
offset = g_utf8_pointer_to_offset (filename, text);
/* select the text prior to the dot */
if (G_LIKELY (offset > 0))
gtk_editable_select_region (GTK_EDITABLE (entry), 0, offset);
}
}
/* get the size the entry requires to render the full text */
layout = gtk_entry_get_layout (GTK_ENTRY (entry));
pango_layout_get_pixel_size (layout, &layout_width, NULL);
gtk_entry_get_layout_offsets (GTK_ENTRY (entry), &layout_offset, NULL);
layout_width += (layout_offset * 2) + (12 * 4) + 48; /* 12px free space in entry */
/* parent window width */
if (G_LIKELY (window != NULL))
{
/* keep below 90% of the parent window width */
gtk_window_get_size (GTK_WINDOW (window), &parent_width, NULL);
parent_width *= 0.90f;
}
/* resize the dialog to make long names fit as much as possible */
gtk_window_set_default_size (GTK_WINDOW (dialog), CLAMP (layout_width, 300, parent_width), -1);
/* run the dialog */
response = gtk_dialog_run (GTK_DIALOG (dialog));
if (G_LIKELY (response == GTK_RESPONSE_OK))
{
/* hide the dialog */
gtk_widget_hide (dialog);
/* determine the new filename */
text = gtk_entry_get_text (GTK_ENTRY (entry));
/* check if we have a new name here */
if (G_LIKELY (!exo_str_is_equal (filename, text)))
{
/* try to rename the file */
job = thunar_io_jobs_rename_file (file, text);
}
}
/* cleanup */
gtk_widget_destroy (dialog);
return job;
}
/*****************************************************************************
* on_load_session()
*
* Handler for the 'Load Session' button in the navbar.
*****************************************************************************/
void
on_load_session(GtkWidget *UNUSED(widget), gpointer data)
{
SESSION *session = get_current_session();
PATCH *patch;
GtkEntry *entry = GTK_ENTRY(data);
GtkWidget *dialog;
GtkWidget *label;
const char *name;
char directory[PATH_MAX];
gint response;
int need_load = 0;
unsigned int part_num;
/* build directory from entry widget and current session directory */
name = gtk_entry_get_text(entry);
if (session->parent_dir == NULL) {
snprintf(directory, PATH_MAX, "%s/%s", user_session_dir, name);
}
else {
snprintf(directory, PATH_MAX, "%s/%s", session->parent_dir, name);
}
/* handle saving of current session based on mem mode */
switch (setting_bank_mem_mode) {
case BANK_MEM_AUTOSAVE:
/* save current session if modified */
if (session->modified) {
on_session_save_activate(NULL, NULL);
}
need_load = 1;
break;
case BANK_MEM_WARN:
/* if modified, warn about losing current session */
if (session->modified) {
/* create dialog with buttons */
dialog = gtk_dialog_new_with_buttons("WARNING: Session Modified",
GTK_WINDOW(main_window),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL,
"Ignore Changes",
GTK_RESPONSE_NO,
"Save and Load New",
GTK_RESPONSE_YES,
NULL);
gtk_window_set_wmclass(GTK_WINDOW(dialog), "phasex", "phasex-dialog");
gtk_window_set_role(GTK_WINDOW(dialog), "verify-save");
/* Alert message */
label = gtk_label_new("The current session has not been saved since it "
"was last modified. Save now before loading new "
"session?");
gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
gtk_misc_set_padding(GTK_MISC(label), 8, 8);
gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), label);
//widget_set_custom_font (dialog);
gtk_widget_show_all(dialog);
/* Run the dialog */
response = gtk_dialog_run(GTK_DIALOG(dialog));
switch (response) {
case GTK_RESPONSE_YES:
/* save session and get ready to load a new one */
on_session_save_activate(NULL, NULL);
need_load = 1;
break;
case GTK_RESPONSE_NO:
/* no save, only set flag to load new session */
need_load = 1;
break;
case GTK_RESPONSE_CANCEL:
/* find old session name and revert text in entry */
if ((session->name == NULL) && (session->directory != NULL)) {
session->name = get_session_name_from_directory(session->directory);
}
update_gui_session_name();
/* cancel out on loading new session */
need_load = 0;
break;
}
gtk_widget_destroy(dialog);
}
/* if not modified, just load new session */
else {
need_load = 1;
}
break;
case BANK_MEM_PROTECT:
/* explicitly don't save in protect mode */
need_load = 1;
break;
}
/* load session specified by entry or assign an Untitled name */
if (need_load) {
session_load_in_progress = 1;
if ((need_load = load_session(directory, visible_sess_num)) != 0) {
snprintf(directory, PATH_MAX, "%s/%s", user_session_dir, name);
need_load = load_session(directory, visible_sess_num);
}
for (part_num = 0; part_num < MAX_PARTS; part_num++) {
visible_prog_num[part_num] = 0;
patch = set_active_patch(visible_sess_num, part_num, 0);
init_patch_state(patch);
if (part_num == visible_part_num) {
update_gui_patch(patch, 0);
}
}
if (session->name == NULL) {
sprintf(directory, "Untitled-%04d", visible_sess_num);
session->name = strdup(directory);
}
session->modified = 0;
session_load_in_progress = 0;
update_gui_patch(NULL, 0);
save_session_bank();
}
}
GtkWidget*
create_TextPlotDialog (void)
{
GtkWidget *TextPlotDialog;
GtkWidget *dialog_vbox1;
GtkWidget *table1;
GtkWidget *label1;
GtkWidget *label2;
GtkWidget *label3;
GtkWidget *label4;
GtkObject *size_sb_adj;
GtkWidget *size_sb;
GtkObject *spacing_sb_adj;
GtkWidget *spacing_sb;
GtkObject *fontx_sb_adj;
GtkWidget *fontx_sb;
GtkObject *fonty_sb_adj;
GtkWidget *fonty_sb;
GtkWidget *Color;
GtkWidget *label5;
GtkWidget *textplot_variables;
GtkWidget *textplot_variables_menu;
GtkWidget *dialog_action_area1;
GtkWidget *hbuttonbox1;
GtkWidget *tpclose;
TextPlotDialog = gtk_dialog_new ();
gtk_widget_set_name (TextPlotDialog, "TextPlotDialog");
gtk_object_set_data (GTK_OBJECT (TextPlotDialog), "TextPlotDialog", TextPlotDialog);
gtk_window_set_title (GTK_WINDOW (TextPlotDialog), _("Text Plot Dialog"));
GTK_WINDOW (TextPlotDialog)->type = GTK_WINDOW_DIALOG;
gtk_window_set_policy (GTK_WINDOW (TextPlotDialog), TRUE, TRUE, FALSE);
dialog_vbox1 = GTK_DIALOG (TextPlotDialog)->vbox;
gtk_widget_set_name (dialog_vbox1, "dialog_vbox1");
gtk_object_set_data (GTK_OBJECT (TextPlotDialog), "dialog_vbox1", dialog_vbox1);
gtk_widget_show (dialog_vbox1);
table1 = gtk_table_new (6, 2, FALSE);
gtk_widget_set_name (table1, "table1");
gtk_widget_ref (table1);
gtk_object_set_data_full (GTK_OBJECT (TextPlotDialog), "table1", table1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (table1);
gtk_box_pack_start (GTK_BOX (dialog_vbox1), table1, TRUE, TRUE, 0);
gtk_table_set_row_spacings (GTK_TABLE (table1), 3);
label1 = gtk_label_new (_("Size:"));
gtk_widget_set_name (label1, "label1");
gtk_widget_ref (label1);
gtk_object_set_data_full (GTK_OBJECT (TextPlotDialog), "label1", label1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label1);
gtk_table_attach (GTK_TABLE (table1), label1, 0, 1, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label1), 0, 0.5);
gtk_misc_set_padding (GTK_MISC (label1), 5, 0);
label2 = gtk_label_new (_("Spacing:"));
gtk_widget_set_name (label2, "label2");
gtk_widget_ref (label2);
gtk_object_set_data_full (GTK_OBJECT (TextPlotDialog), "label2", label2,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label2);
gtk_table_attach (GTK_TABLE (table1), label2, 0, 1, 2, 3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label2), 0, 0.5);
gtk_misc_set_padding (GTK_MISC (label2), 5, 0);
label3 = gtk_label_new (_("Font Width:"));
gtk_widget_set_name (label3, "label3");
gtk_widget_ref (label3);
gtk_object_set_data_full (GTK_OBJECT (TextPlotDialog), "label3", label3,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label3);
gtk_table_attach (GTK_TABLE (table1), label3, 0, 1, 3, 4,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label3), 0, 0.5);
gtk_misc_set_padding (GTK_MISC (label3), 5, 0);
label4 = gtk_label_new (_("Font Height:"));
gtk_widget_set_name (label4, "label4");
gtk_widget_ref (label4);
gtk_object_set_data_full (GTK_OBJECT (TextPlotDialog), "label4", label4,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label4);
gtk_table_attach (GTK_TABLE (table1), label4, 0, 1, 4, 5,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label4), 0, 0.5);
gtk_misc_set_padding (GTK_MISC (label4), 5, 0);
size_sb_adj = gtk_adjustment_new (1, 0.01, 100, 1, 10, 10);
size_sb = gtk_spin_button_new (GTK_ADJUSTMENT (size_sb_adj), 1, 2);
gtk_widget_set_name (size_sb, "size_sb");
gtk_widget_ref (size_sb);
gtk_object_set_data_full (GTK_OBJECT (TextPlotDialog), "size_sb", size_sb,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (size_sb);
gtk_table_attach (GTK_TABLE (table1), size_sb, 1, 2, 1, 2,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (size_sb), TRUE);
spacing_sb_adj = gtk_adjustment_new (1, 0, 100, 1, 10, 10);
spacing_sb = gtk_spin_button_new (GTK_ADJUSTMENT (spacing_sb_adj), 1, 0);
gtk_widget_set_name (spacing_sb, "spacing_sb");
gtk_widget_ref (spacing_sb);
gtk_object_set_data_full (GTK_OBJECT (TextPlotDialog), "spacing_sb", spacing_sb,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (spacing_sb);
gtk_table_attach (GTK_TABLE (table1), spacing_sb, 1, 2, 2, 3,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
fontx_sb_adj = gtk_adjustment_new (10, 0, 100, 1, 10, 10);
fontx_sb = gtk_spin_button_new (GTK_ADJUSTMENT (fontx_sb_adj), 1, 0);
gtk_widget_set_name (fontx_sb, "fontx_sb");
gtk_widget_ref (fontx_sb);
gtk_object_set_data_full (GTK_OBJECT (TextPlotDialog), "fontx_sb", fontx_sb,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (fontx_sb);
gtk_table_attach (GTK_TABLE (table1), fontx_sb, 1, 2, 3, 4,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
fonty_sb_adj = gtk_adjustment_new (10, 0, 100, 1, 10, 10);
fonty_sb = gtk_spin_button_new (GTK_ADJUSTMENT (fonty_sb_adj), 1, 0);
gtk_widget_set_name (fonty_sb, "fonty_sb");
gtk_widget_ref (fonty_sb);
gtk_object_set_data_full (GTK_OBJECT (TextPlotDialog), "fonty_sb", fonty_sb,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (fonty_sb);
gtk_table_attach (GTK_TABLE (table1), fonty_sb, 1, 2, 4, 5,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
Color = gtk_button_new_with_label (_("Color"));
gtk_widget_set_name (Color, "Color");
gtk_widget_ref (Color);
gtk_object_set_data_full (GTK_OBJECT (TextPlotDialog), "Color", Color,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (Color);
gtk_table_attach (GTK_TABLE (table1), Color, 0, 2, 5, 6,
(GtkAttachOptions) (0),
(GtkAttachOptions) (0), 0, 0);
label5 = gtk_label_new (_("Variable:"));
gtk_widget_set_name (label5, "label5");
gtk_widget_ref (label5);
gtk_object_set_data_full (GTK_OBJECT (TextPlotDialog), "label5", label5,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label5);
gtk_table_attach (GTK_TABLE (table1), label5, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label5), 0, 0.5);
gtk_misc_set_padding (GTK_MISC (label5), 5, 0);
textplot_variables = gtk_option_menu_new ();
gtk_widget_set_name (textplot_variables, "textplot_variables");
gtk_widget_ref (textplot_variables);
gtk_object_set_data_full (GTK_OBJECT (TextPlotDialog), "textplot_variables", textplot_variables,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (textplot_variables);
gtk_table_attach (GTK_TABLE (table1), textplot_variables, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_widget_set_usize (textplot_variables, 150, 40);
gtk_container_set_border_width (GTK_CONTAINER (textplot_variables), 5);
textplot_variables_menu = gtk_menu_new ();
gtk_option_menu_set_menu (GTK_OPTION_MENU (textplot_variables), textplot_variables_menu);
dialog_action_area1 = GTK_DIALOG (TextPlotDialog)->action_area;
gtk_widget_set_name (dialog_action_area1, "dialog_action_area1");
gtk_object_set_data (GTK_OBJECT (TextPlotDialog), "dialog_action_area1", dialog_action_area1);
gtk_widget_show (dialog_action_area1);
gtk_container_set_border_width (GTK_CONTAINER (dialog_action_area1), 10);
hbuttonbox1 = gtk_hbutton_box_new ();
gtk_widget_set_name (hbuttonbox1, "hbuttonbox1");
gtk_widget_ref (hbuttonbox1);
gtk_object_set_data_full (GTK_OBJECT (TextPlotDialog), "hbuttonbox1", hbuttonbox1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hbuttonbox1);
gtk_box_pack_start (GTK_BOX (dialog_action_area1), hbuttonbox1, TRUE, TRUE, 0);
tpclose = gtk_button_new_with_label (_("Close"));
gtk_widget_set_name (tpclose, "tpclose");
gtk_widget_ref (tpclose);
gtk_object_set_data_full (GTK_OBJECT (TextPlotDialog), "tpclose", tpclose,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (tpclose);
gtk_container_add (GTK_CONTAINER (hbuttonbox1), tpclose);
GTK_WIDGET_SET_FLAGS (tpclose, GTK_CAN_DEFAULT);
gtk_signal_connect (GTK_OBJECT (size_sb), "changed",
GTK_SIGNAL_FUNC (on_tp_sb_changed),
GINT_TO_POINTER(0));
gtk_signal_connect (GTK_OBJECT (spacing_sb), "changed",
GTK_SIGNAL_FUNC (on_tp_sb_changed),
GINT_TO_POINTER(1));
gtk_signal_connect (GTK_OBJECT (fontx_sb), "changed",
GTK_SIGNAL_FUNC (on_tp_sb_changed),
GINT_TO_POINTER(2));
gtk_signal_connect (GTK_OBJECT (fonty_sb), "changed",
GTK_SIGNAL_FUNC (on_tp_sb_changed),
GINT_TO_POINTER(3));
gtk_signal_connect (GTK_OBJECT (Color), "clicked",
GTK_SIGNAL_FUNC (on_Color_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (tpclose), "clicked",
GTK_SIGNAL_FUNC (on_tpclose_clicked),
NULL);
return TextPlotDialog;
}
/*****************************************************************************
* select_session()
*****************************************************************************/
void
select_session(GtkWidget *widget, gpointer data)
{
SESSION *session = get_current_session();
PATCH *patch;
GtkWidget *dialog;
GtkWidget *label;
GtkEntry *entry = NULL;
char *directory = NULL;
gint response;
int need_select = 1;
unsigned int sess_num;
unsigned int part_num;
/* called as a gui callback */
/* the widgets we need to reference are callback args */
if (data == NULL) {
entry = GTK_ENTRY(session_entry);
}
else {
entry = GTK_ENTRY(data);
}
/* get name from entry widget or strip current patch directory */
directory = get_session_directory_from_entry(entry);
/* get session number from spin button if called from gui */
sess_num = (unsigned int)(gtk_adjustment_get_value(GTK_ADJUSTMENT(widget))) - 1;
/* only continue if we're really changing the session number */
if (sess_num != visible_sess_num) {
/* whether or not to save depends on memory mode */
switch (setting_bank_mem_mode) {
case BANK_MEM_AUTOSAVE:
/* no canceling in autosave mode */
need_select = 1;
/* save current session if modified */
if (session->modified) {
on_session_save_activate(NULL, directory);
}
break;
case BANK_MEM_WARN:
/* this is set now, and may be canceled */
need_select = 1;
/* if modified, warn about losing current patch and give option to save */
if (session->modified) {
/* create dialog with buttons */
dialog = gtk_dialog_new_with_buttons("WARNING: Session Modified",
GTK_WINDOW(main_window),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL,
"Ignore Changes",
GTK_RESPONSE_NO,
"Save and Select New",
GTK_RESPONSE_YES,
NULL);
gtk_window_set_wmclass(GTK_WINDOW(dialog), "phasex", "phasex-dialog");
gtk_window_set_role(GTK_WINDOW(dialog), "verify-save");
/* Alert message */
label = gtk_label_new("The current session has not been saved "
"since patches were last modified. Save "
"now before selecting new session?");
gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
gtk_misc_set_padding(GTK_MISC(label), 8, 8);
gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), label);
//widget_set_custom_font (dialog);
gtk_widget_show_all(dialog);
/* Run the dialog */
response = gtk_dialog_run(GTK_DIALOG(dialog));
switch (response) {
case GTK_RESPONSE_YES:
/* save session and set flag to select session from bank */
on_session_save_activate(NULL, NULL);
need_select = 1;
break;
case GTK_RESPONSE_NO:
/* don't save, but still set flag to select new */
need_select = 1;
break;
case GTK_RESPONSE_CANCEL:
/* set spin button back to
current session and don't
select new */
gtk_adjustment_set_value(GTK_ADJUSTMENT(session_adj), (visible_sess_num + 1));
need_select = 0;
break;
}
/* all finished with dialog now */
gtk_widget_destroy(dialog);
}
break;
case BANK_MEM_PROTECT:
/* explicitly don't save */
need_select = 1;
break;
}
/* free name, now that we're done with it */
if (directory != NULL) {
free(directory);
}
}
else if (widget != NULL) {
need_select = 0;
}
/* select session specified by spinbutton or init new session */
if (need_select) {
visible_sess_num = sess_num;
session_io_start = sess_num;
session = get_session(sess_num);
session_load_in_progress = 1;
/* place current session name into session entry */
update_gui_session_name();
for (part_num = 0; part_num < MAX_PARTS; part_num++) {
visible_prog_num[part_num] = session->prog_num[part_num];
/* set active patch for this part in engine */
patch = set_active_patch(sess_num, part_num, session->prog_num[part_num]);
init_patch_state(patch);
/* GUI changes for visible part only */
if (part_num == visible_part_num) {
update_gui_patch(patch, 0);
}
}
update_gui_session_modified();
session_load_in_progress = 0;
}
}
int
main (int argc, char **argv)
{
GtkWidget *control_window;
GtkWidget *vbbox;
GtkWidget *button;
GtkWidget *dialog;
GtkWidget *prop_editor;
GtkFileSystem *file_system;
GtkFileFilter *filter;
GtkWidget *preview_vbox;
GtkWidget *extra;
gtk_init (&argc, &argv);
#ifdef USE_GNOME_VFS
file_system = gtk_file_system_gnome_vfs_new ();
#else
file_system = gtk_file_system_unix_new ();
#endif
dialog = g_object_new (GTK_TYPE_FILE_CHOOSER_DIALOG,
"action", GTK_FILE_CHOOSER_ACTION_OPEN,
"file-system", file_system,
"title", "Select a file",
NULL);
gtk_dialog_add_buttons (GTK_DIALOG (dialog),
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
g_signal_connect (dialog, "selection-changed",
G_CALLBACK (print_selected), NULL);
g_signal_connect (dialog, "current-folder-changed",
G_CALLBACK (print_current_folder), NULL);
g_signal_connect (dialog, "response",
G_CALLBACK (response_cb), NULL);
/* Filters */
filter = gtk_file_filter_new ();
gtk_file_filter_set_name (filter, "All Files");
gtk_file_filter_add_pattern (filter, "*");
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter);
filter = gtk_file_filter_new ();
gtk_file_filter_set_name (filter, "No backup files");
gtk_file_filter_add_custom (filter, GTK_FILE_FILTER_DISPLAY_NAME,
no_backup_files_filter, NULL, NULL);
gtk_file_filter_add_mime_type (filter, "image/png");
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter);
/* Make this filter the default */
gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (dialog), filter);
filter = gtk_file_filter_new ();
gtk_file_filter_set_name (filter, "PNG and JPEG");
gtk_file_filter_add_mime_type (filter, "image/jpeg");
gtk_file_filter_add_mime_type (filter, "image/png");
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter);
/* Preview widget */
preview_vbox = gtk_vbox_new (0, FALSE);
gtk_file_chooser_set_preview_widget (GTK_FILE_CHOOSER (dialog), preview_vbox);
preview_label = gtk_label_new (NULL);
gtk_box_pack_start (GTK_BOX (preview_vbox), preview_label, TRUE, TRUE, 0);
gtk_misc_set_padding (GTK_MISC (preview_label), 6, 6);
preview_image = gtk_image_new ();
gtk_box_pack_start (GTK_BOX (preview_vbox), preview_image, TRUE, TRUE, 0);
gtk_misc_set_padding (GTK_MISC (preview_image), 6, 6);
update_preview_cb (GTK_FILE_CHOOSER (dialog));
g_signal_connect (dialog, "update-preview",
G_CALLBACK (update_preview_cb), NULL);
/* Extra widget */
extra = gtk_check_button_new_with_mnemonic ("Lar_t whoever asks about this button");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (extra), TRUE);
gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (dialog), extra);
/* Shortcuts */
gtk_file_chooser_add_shortcut_folder_uri (GTK_FILE_CHOOSER (dialog),
"file:///usr/share/pixmaps",
NULL);
/* Done with the dialog */
gtk_window_set_default_size (GTK_WINDOW (dialog), 600, 400);
/* show_all() to reveal bugs in composite widget handling */
gtk_widget_show_all (dialog);
/* Extra controls for manipulating the test environment
*/
prop_editor = create_prop_editor (G_OBJECT (dialog), GTK_TYPE_FILE_CHOOSER);
control_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
vbbox = gtk_vbutton_box_new ();
gtk_container_add (GTK_CONTAINER (control_window), vbbox);
button = gtk_button_new_with_mnemonic ("_Select all");
gtk_container_add (GTK_CONTAINER (vbbox), button);
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (gtk_file_chooser_select_all), dialog);
button = gtk_button_new_with_mnemonic ("_Unselect all");
gtk_container_add (GTK_CONTAINER (vbbox), button);
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (gtk_file_chooser_unselect_all), dialog);
gtk_widget_show_all (control_window);
gtk_main ();
return 0;
}
static void
hildon_find_toolbar_init (HildonFindToolbar *self)
{
GtkToolItem *label_container;
GtkToolItem *entry_combo_box_container;
GtkAlignment *alignment;
HildonFindToolbarPrivate *priv = HILDON_FIND_TOOLBAR_GET_PRIVATE (self);
g_assert (priv);
/* Create the label */
priv->label = gtk_label_new (_("ecdg_ti_find_toolbar_label"));
gtk_misc_set_padding (GTK_MISC (priv->label), FIND_LABEL_XPADDING,
FIND_LABEL_YPADDING);
label_container = gtk_tool_item_new ();
gtk_container_add (GTK_CONTAINER (label_container),
priv->label);
gtk_widget_show_all (GTK_WIDGET (label_container));
gtk_toolbar_insert (GTK_TOOLBAR (self), label_container, -1);
/* ComboBoxEntry for search prefix string / history list */
priv->entry_combo_box = GTK_COMBO_BOX_ENTRY (gtk_combo_box_entry_new ());
#ifdef MAEMO_GTK
g_signal_connect (hildon_find_toolbar_get_entry(priv),
"invalid_input",
G_CALLBACK(hildon_find_toolbar_emit_invalid_input), self);
#endif
entry_combo_box_container = gtk_tool_item_new ();
alignment = GTK_ALIGNMENT (gtk_alignment_new (0, 0.5, 1, 0));
gtk_tool_item_set_expand (entry_combo_box_container, TRUE);
gtk_container_add (GTK_CONTAINER (alignment),
GTK_WIDGET (priv->entry_combo_box));
gtk_container_add (GTK_CONTAINER (entry_combo_box_container),
GTK_WIDGET (alignment));
gtk_widget_show_all(GTK_WIDGET (entry_combo_box_container));
gtk_toolbar_insert (GTK_TOOLBAR (self), entry_combo_box_container, -1);
g_signal_connect (hildon_find_toolbar_get_entry (priv),
"activate",
G_CALLBACK(hildon_find_toolbar_entry_activate), self);
/* Find button */
priv->find_button = gtk_tool_button_new (
gtk_image_new_from_icon_name ("qgn_toolb_browser_gobutton",
HILDON_ICON_SIZE_TOOLBAR),
"Find");
g_signal_connect (priv->find_button, "clicked",
G_CALLBACK(hildon_find_toolbar_emit_search), self);
gtk_widget_show_all( GTK_WIDGET(priv->find_button));
gtk_toolbar_insert ( GTK_TOOLBAR(self), priv->find_button, -1);
gtk_widget_set_size_request (GTK_WIDGET (priv->find_button), 72, -1);
if ( GTK_WIDGET_CAN_FOCUS( GTK_BIN(priv->find_button)->child) )
GTK_WIDGET_UNSET_FLAGS(
GTK_BIN(priv->find_button)->child, GTK_CAN_FOCUS);
/* Separator */
priv->separator = gtk_separator_tool_item_new();
gtk_widget_show(GTK_WIDGET(priv->separator));
gtk_toolbar_insert (GTK_TOOLBAR(self), priv->separator, -1);
/* Close button */
priv->close_button = gtk_tool_button_new (
gtk_image_new_from_icon_name ("qgn_toolb_gene_close",
HILDON_ICON_SIZE_TOOLBAR),
"Close");
gtk_widget_set_size_request (GTK_WIDGET (priv->close_button), 72, -1);
g_signal_connect(priv->close_button, "clicked",
G_CALLBACK(hildon_find_toolbar_emit_close), self);
gtk_widget_show_all(GTK_WIDGET(priv->close_button));
gtk_toolbar_insert (GTK_TOOLBAR(self), priv->close_button, -1);
if ( GTK_WIDGET_CAN_FOCUS( GTK_BIN(priv->close_button)->child) )
GTK_WIDGET_UNSET_FLAGS(
GTK_BIN(priv->close_button)->child, GTK_CAN_FOCUS);
}
void
create_main_window (ContactsData *data)
{
GtkWidget *main_window;
GtkWidget *vbox7;
GtkWidget *main_menubar;
GtkWidget *contacts_menu;
GtkWidget *contacts_menu_menu;
GtkWidget *new_menuitem;
GtkWidget *edit_menuitem;
GtkWidget *delete_menuitem;
GtkWidget *contacts_import;
GtkWidget *contacts_quit;
GtkWidget *contact_menu;
GtkWidget *contact_menu_menu;
GtkWidget *contact_delete;
GtkWidget *edit_groups;
GtkWidget *contact_export;
GtkWidget *contact_quit;
GtkWidget *edit_menu;
GtkWidget *menuitem5_menu;
GtkWidget *cut;
GtkWidget *copy;
GtkWidget *paste;
GtkWidget *help_menu;
GtkWidget *menuitem7_menu;
GtkWidget *about1;
GtkWidget *main_notebook;
GtkWidget *main_hpane;
GtkWidget *contacts_vbox;
GtkWidget *scrolledwindow2;
GtkWidget *contacts_treeview;
GtkWidget *search_hbox;
GtkWidget *search_entry_hbox;
GtkWidget *search_entry;
GtkWidget *search_tab_hbox;
GtkWidget *symbols_radiobutton;
GSList *symbols_radiobutton_group = NULL;
GtkWidget *atog_radiobutton;
GtkWidget *hton_radiobutton;
GtkWidget *otou_radiobutton;
GtkWidget *vtoz_radiobutton;
GtkWidget *vbox3;
GtkWidget *summary_vbox;
GtkWidget *preview_header_hbox;
GtkWidget *preview_namegroup_vbox;
GtkWidget *summary_name_label;
GtkWidget *summary_group_label;
GtkWidget *photo_image;
GtkWidget *scrolledwindow3;
GtkWidget *viewport1;
GtkWidget *summary_table;
GtkWidget *summary_hbuttonbox;
GtkWidget *new_button;
GtkWidget *edit_button;
GtkWidget *delete_button;
GtkWidget *vbox4;
GtkWidget *scrolledwindow4;
GtkWidget *viewport2;
GtkWidget *edit_table;
GtkWidget *hbuttonbox2;
GtkWidget *add_field_button;
GtkWidget *remove_field_button;
GtkWidget *edit_done_button;
GtkWidget *widget;
GtkAccelGroup *accel_group;
ContactsUI *ui = data->ui;
GtkSizeGroup *size_group;
#ifdef HAVE_GCONF
GConfClient *client;
gchar *search;
gint width, height;
#endif
accel_group = gtk_accel_group_new ();
main_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (main_window), _("Contacts"));
gtk_window_set_icon_name (GTK_WINDOW (main_window), "contacts");
gtk_window_set_default_size (GTK_WINDOW (main_window), 320, 240);
vbox7 = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (main_window), vbox7);
main_menubar = gtk_menu_bar_new ();
gtk_box_pack_start (GTK_BOX (vbox7), main_menubar, FALSE, FALSE, 0);
contacts_menu = gtk_menu_item_new_with_mnemonic (_("C_ontacts"));
gtk_container_add (GTK_CONTAINER (main_menubar), contacts_menu);
contacts_menu_menu = gtk_menu_new ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (contacts_menu), contacts_menu_menu);
new_menuitem = gtk_image_menu_item_new_from_stock ("gtk-new", accel_group);
gtk_container_add (GTK_CONTAINER (contacts_menu_menu), new_menuitem);
edit_menuitem = gtk_image_menu_item_new_from_stock ("gtk-open", accel_group);
gtk_container_add (GTK_CONTAINER (contacts_menu_menu), edit_menuitem);
gtk_widget_set_sensitive (edit_menuitem, FALSE);
delete_menuitem = gtk_image_menu_item_new_from_stock ("gtk-delete", accel_group);
gtk_container_add (GTK_CONTAINER (contacts_menu_menu), delete_menuitem);
gtk_widget_set_sensitive (delete_menuitem, FALSE);
contacts_import = gtk_menu_item_new_with_mnemonic (_("_Import..."));
gtk_container_add (GTK_CONTAINER (contacts_menu_menu), contacts_import);
widget = gtk_separator_menu_item_new ();
gtk_container_add (GTK_CONTAINER (contacts_menu_menu), widget);
gtk_widget_set_sensitive (widget, FALSE);
contacts_quit = gtk_image_menu_item_new_from_stock ("gtk-quit", accel_group);
gtk_container_add (GTK_CONTAINER (contacts_menu_menu), contacts_quit);
contact_menu = gtk_menu_item_new_with_mnemonic (_("C_ontact"));
gtk_container_add (GTK_CONTAINER (main_menubar), contact_menu);
g_object_set (G_OBJECT (contact_menu), "no-show-all", TRUE, NULL);
contact_menu_menu = gtk_menu_new ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (contact_menu), contact_menu_menu);
contact_delete = gtk_image_menu_item_new_from_stock ("gtk-delete", accel_group);
gtk_container_add (GTK_CONTAINER (contact_menu_menu), contact_delete);
edit_groups = gtk_menu_item_new_with_mnemonic (_("_Groups"));
gtk_container_add (GTK_CONTAINER (contact_menu_menu), edit_groups);
contact_export = gtk_menu_item_new_with_mnemonic (_("_Export"));
gtk_container_add (GTK_CONTAINER (contact_menu_menu), contact_export);
widget = gtk_separator_menu_item_new ();
gtk_container_add (GTK_CONTAINER (contact_menu_menu), widget);
gtk_widget_set_sensitive (widget, FALSE);
contact_quit = gtk_image_menu_item_new_from_stock ("gtk-quit", accel_group);
gtk_container_add (GTK_CONTAINER (contact_menu_menu), contact_quit);
edit_menu = gtk_menu_item_new_with_mnemonic (_("Ed_it"));
gtk_container_add (GTK_CONTAINER (main_menubar), edit_menu);
menuitem5_menu = gtk_menu_new ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (edit_menu), menuitem5_menu);
cut = gtk_image_menu_item_new_from_stock ("gtk-cut", accel_group);
gtk_container_add (GTK_CONTAINER (menuitem5_menu), cut);
copy = gtk_image_menu_item_new_from_stock ("gtk-copy", accel_group);
gtk_container_add (GTK_CONTAINER (menuitem5_menu), copy);
paste = gtk_image_menu_item_new_from_stock ("gtk-paste", accel_group);
gtk_container_add (GTK_CONTAINER (menuitem5_menu), paste);
help_menu = gtk_menu_item_new_with_mnemonic (_("_Help"));
gtk_container_add (GTK_CONTAINER (main_menubar), help_menu);
menuitem7_menu = gtk_menu_new ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (help_menu), menuitem7_menu);
about1 = gtk_image_menu_item_new_from_stock ("gtk-about", accel_group);
gtk_container_add (GTK_CONTAINER (menuitem7_menu), about1);
main_notebook = gtk_notebook_new ();
gtk_box_pack_start (GTK_BOX (vbox7), main_notebook, TRUE, TRUE, 0);
GTK_WIDGET_UNSET_FLAGS (main_notebook, GTK_CAN_FOCUS);
gtk_notebook_set_show_tabs (GTK_NOTEBOOK (main_notebook), FALSE);
gtk_notebook_set_show_border (GTK_NOTEBOOK (main_notebook), FALSE);
main_hpane = gtk_hpaned_new ();
gtk_container_add (GTK_CONTAINER (main_notebook), main_hpane);
contacts_vbox = gtk_vbox_new (FALSE, 6);
gtk_paned_pack1 (GTK_PANED (main_hpane), contacts_vbox, FALSE, FALSE);
gtk_container_set_border_width (GTK_CONTAINER (contacts_vbox), 6);
groups_combobox = gtk_combo_box_new ();
GtkListStore *ls = gtk_list_store_new (1, G_TYPE_STRING);
GtkCellRenderer *renderer = gtk_cell_renderer_text_new ();
g_object_set (renderer, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
gtk_combo_box_set_row_separator_func (GTK_COMBO_BOX (groups_combobox),
groups_combo_seperator_func, NULL, NULL);
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (groups_combobox), renderer, TRUE);
gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (groups_combobox), renderer, "text", 0);
gtk_combo_box_set_model (GTK_COMBO_BOX (groups_combobox), GTK_TREE_MODEL(ls));
gtk_box_pack_start (GTK_BOX (contacts_vbox), groups_combobox, FALSE, TRUE, 0);
gtk_combo_box_set_focus_on_click (GTK_COMBO_BOX (groups_combobox), FALSE);
scrolledwindow2 = gtk_scrolled_window_new (NULL, NULL);
gtk_box_pack_start (GTK_BOX (contacts_vbox), scrolledwindow2, TRUE, TRUE, 0);
GTK_WIDGET_UNSET_FLAGS (scrolledwindow2, GTK_CAN_FOCUS);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow2), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow2), GTK_SHADOW_IN);
contacts_treeview = gtk_tree_view_new ();
gtk_container_add (GTK_CONTAINER (scrolledwindow2), contacts_treeview);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (contacts_treeview), FALSE);
gtk_tree_view_set_enable_search (GTK_TREE_VIEW (contacts_treeview), FALSE);
search_hbox = gtk_hbox_new (FALSE, 0);
gtk_box_pack_end (GTK_BOX (contacts_vbox), search_hbox, FALSE, TRUE, 0);
search_entry_hbox = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (search_hbox), search_entry_hbox, TRUE, TRUE, 0);
search_entry = gtk_entry_new ();
gtk_box_pack_end (GTK_BOX (search_entry_hbox), search_entry, TRUE, TRUE, 0);
gtk_entry_set_activates_default (GTK_ENTRY (search_entry), TRUE);
widget = gtk_label_new_with_mnemonic (_("_Search:"));
gtk_box_pack_start (GTK_BOX (search_entry_hbox), widget, FALSE, FALSE, 0);
gtk_misc_set_padding (GTK_MISC (widget), 6, 0);
gtk_label_set_mnemonic_widget (GTK_LABEL (widget), search_entry);
search_tab_hbox = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (search_hbox), search_tab_hbox, TRUE, TRUE, 0);
g_object_set (G_OBJECT (search_tab_hbox), "no-show-all", TRUE, NULL);
symbols_radiobutton = gtk_radio_button_new_with_mnemonic (NULL, _("0-9#"));
gtk_box_pack_start (GTK_BOX (search_tab_hbox), symbols_radiobutton, TRUE, FALSE, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (symbols_radiobutton), symbols_radiobutton_group);
symbols_radiobutton_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (symbols_radiobutton));
atog_radiobutton = gtk_radio_button_new_with_mnemonic (NULL, _("A-G"));
gtk_box_pack_start (GTK_BOX (search_tab_hbox), atog_radiobutton, TRUE, FALSE, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (atog_radiobutton), symbols_radiobutton_group);
symbols_radiobutton_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (atog_radiobutton));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (atog_radiobutton), TRUE);
hton_radiobutton = gtk_radio_button_new_with_mnemonic (NULL, _("H-N"));
gtk_box_pack_start (GTK_BOX (search_tab_hbox), hton_radiobutton, TRUE, FALSE, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (hton_radiobutton), symbols_radiobutton_group);
symbols_radiobutton_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (hton_radiobutton));
otou_radiobutton = gtk_radio_button_new_with_mnemonic (NULL, _("O-U"));
gtk_box_pack_start (GTK_BOX (search_tab_hbox), otou_radiobutton, TRUE, FALSE, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (otou_radiobutton), symbols_radiobutton_group);
symbols_radiobutton_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (otou_radiobutton));
vtoz_radiobutton = gtk_radio_button_new_with_mnemonic (NULL, _("V-Z"));
gtk_box_pack_start (GTK_BOX (search_tab_hbox), vtoz_radiobutton, TRUE, FALSE, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (vtoz_radiobutton), symbols_radiobutton_group);
symbols_radiobutton_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (vtoz_radiobutton));
vbox3 = gtk_vbox_new (FALSE, 6);
gtk_paned_pack2 (GTK_PANED (main_hpane), vbox3, TRUE, FALSE);
gtk_container_set_border_width (GTK_CONTAINER (vbox3), 6);
summary_vbox = gtk_vbox_new (FALSE, 6);
gtk_box_pack_start (GTK_BOX (vbox3), summary_vbox, TRUE, TRUE, 0);
preview_header_hbox = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (summary_vbox), preview_header_hbox, FALSE, TRUE, 0);
preview_namegroup_vbox = gtk_vbox_new (FALSE, 0);
summary_name_label = gtk_label_new (NULL);
gtk_box_pack_start (GTK_BOX (preview_namegroup_vbox), summary_name_label, TRUE, TRUE, 0);
GTK_WIDGET_SET_FLAGS (summary_name_label, GTK_CAN_FOCUS);
gtk_label_set_use_markup (GTK_LABEL (summary_name_label), TRUE);
gtk_label_set_selectable (GTK_LABEL (summary_name_label), TRUE);
gtk_misc_set_alignment (GTK_MISC (summary_name_label), 0, 0.5);
gtk_misc_set_padding (GTK_MISC (summary_name_label), 6, 0);
gtk_label_set_ellipsize (GTK_LABEL (summary_name_label), PANGO_ELLIPSIZE_END);
summary_group_label = gtk_label_new (NULL);
gtk_box_pack_start (GTK_BOX (preview_namegroup_vbox), summary_group_label, TRUE, TRUE, 0);
GTK_WIDGET_SET_FLAGS (summary_group_label, GTK_CAN_FOCUS);
gtk_label_set_use_markup (GTK_LABEL (summary_group_label), TRUE);
gtk_label_set_selectable (GTK_LABEL (summary_group_label), TRUE);
gtk_misc_set_alignment (GTK_MISC (summary_group_label), 0, 0.5);
gtk_misc_set_padding (GTK_MISC (summary_group_label), 6, 0);
gtk_label_set_ellipsize (GTK_LABEL (summary_group_label), PANGO_ELLIPSIZE_END);
gtk_box_pack_start (GTK_BOX (preview_header_hbox), preview_namegroup_vbox, TRUE, TRUE, 0);
/* load stock_person as the default icon so the image has the correct
* size before a contact is loaded */
photo_image = gtk_image_new_from_icon_name ("stock_person", GTK_ICON_SIZE_DIALOG);
gtk_box_pack_end (GTK_BOX (preview_header_hbox), photo_image, FALSE, TRUE, 6);
gtk_misc_set_padding (GTK_MISC (photo_image), 1, 0);
scrolledwindow3 = gtk_scrolled_window_new (NULL, NULL);
gtk_box_pack_start (GTK_BOX (summary_vbox), scrolledwindow3, TRUE, TRUE, 0);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow3), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
viewport1 = gtk_viewport_new (NULL, NULL);
gtk_container_add (GTK_CONTAINER (scrolledwindow3), viewport1);
summary_table = gtk_table_new (1, 2, FALSE);
gtk_container_add (GTK_CONTAINER (viewport1), summary_table);
gtk_table_set_row_spacings (GTK_TABLE (summary_table), 6);
gtk_table_set_col_spacings (GTK_TABLE (summary_table), 6);
summary_hbuttonbox = gtk_hbutton_box_new ();
gtk_box_pack_end (GTK_BOX (vbox3), summary_hbuttonbox, FALSE, FALSE, 0);
gtk_button_box_set_layout (GTK_BUTTON_BOX (summary_hbuttonbox), GTK_BUTTONBOX_END);
gtk_box_set_spacing (GTK_BOX (summary_hbuttonbox), 6);
new_button = gtk_button_new_from_stock ("gtk-new");
gtk_container_add (GTK_CONTAINER (summary_hbuttonbox), new_button);
GTK_WIDGET_SET_FLAGS (new_button, GTK_CAN_DEFAULT);
edit_button = gtk_button_new_from_stock ("gtk-edit");
gtk_container_add (GTK_CONTAINER (summary_hbuttonbox), edit_button);
gtk_widget_set_sensitive (edit_button, FALSE);
GTK_WIDGET_SET_FLAGS (edit_button, GTK_CAN_DEFAULT);
delete_button = gtk_button_new_from_stock ("gtk-delete");
gtk_container_add (GTK_CONTAINER (summary_hbuttonbox), delete_button);
gtk_widget_set_sensitive (delete_button, FALSE);
GTK_WIDGET_SET_FLAGS (delete_button, GTK_CAN_DEFAULT);
gtk_button_set_focus_on_click (GTK_BUTTON (delete_button), FALSE);
vbox4 = gtk_vbox_new (FALSE, 6);
gtk_container_add (GTK_CONTAINER (main_notebook), vbox4);
gtk_container_set_border_width (GTK_CONTAINER (vbox4), 6);
scrolledwindow4 = gtk_scrolled_window_new (NULL, NULL);
gtk_box_pack_start (GTK_BOX (vbox4), scrolledwindow4, TRUE, TRUE, 0);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow4), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
viewport2 = gtk_viewport_new (NULL, NULL);
gtk_container_add (GTK_CONTAINER (scrolledwindow4), viewport2);
edit_table = gtk_table_new (1, 2, FALSE);
gtk_container_add (GTK_CONTAINER (viewport2), edit_table);
gtk_container_set_border_width (GTK_CONTAINER (edit_table), 6);
gtk_table_set_row_spacings (GTK_TABLE (edit_table), 6);
hbuttonbox2 = gtk_hbutton_box_new ();
gtk_box_pack_start (GTK_BOX (vbox4), hbuttonbox2, FALSE, TRUE, 0);
gtk_button_box_set_layout (GTK_BUTTON_BOX (hbuttonbox2), GTK_BUTTONBOX_END);
gtk_box_set_spacing (GTK_BOX (hbuttonbox2), 6);
add_field_button = gtk_button_new_with_mnemonic (_("_Add Field"));
gtk_container_add (GTK_CONTAINER (hbuttonbox2), add_field_button);
GTK_WIDGET_SET_FLAGS (add_field_button, GTK_CAN_DEFAULT);
remove_field_button = gtk_button_new_with_mnemonic (_("_Remove Field"));
gtk_container_add (GTK_CONTAINER (hbuttonbox2), remove_field_button);
GTK_WIDGET_SET_FLAGS (remove_field_button, GTK_CAN_DEFAULT);
gtk_button_set_focus_on_click (GTK_BUTTON (remove_field_button), FALSE);
edit_done_button = gtk_button_new_from_stock ("gtk-close");
gtk_container_add (GTK_CONTAINER (hbuttonbox2), edit_done_button);
GTK_WIDGET_SET_FLAGS (edit_done_button, GTK_CAN_DEFAULT);
gtk_widget_grab_focus (contacts_treeview);
gtk_widget_grab_default (edit_button);
gtk_window_add_accel_group (GTK_WINDOW (main_window), accel_group);
/* Set up size group for bottom row of buttons and search */
size_group = gtk_size_group_new (GTK_SIZE_GROUP_VERTICAL);
gtk_size_group_add_widget (size_group, search_hbox);
gtk_size_group_add_widget (size_group, summary_hbuttonbox);
g_object_unref (size_group);
/* connect signals */
g_signal_connect (G_OBJECT (main_window), "delete-event",
G_CALLBACK (contacts_main_window_delete_event_cb), data);
g_signal_connect ((gpointer) main_window, "destroy",
G_CALLBACK (gtk_main_quit),
NULL);
g_signal_connect_swapped ((gpointer) main_window, "set_focus",
G_CALLBACK (contacts_edit_set_focus_cb),
GTK_OBJECT (remove_field_button));
g_signal_connect ((gpointer) contacts_quit, "activate",
G_CALLBACK (gtk_main_quit),
NULL);
g_signal_connect ((gpointer) contact_quit, "activate",
G_CALLBACK (gtk_main_quit),
NULL);
g_signal_connect_swapped ((gpointer) cut, "activate",
G_CALLBACK (contacts_cut_cb),
GTK_OBJECT (main_window));
g_signal_connect_swapped ((gpointer) copy, "activate",
G_CALLBACK (contacts_copy_cb),
GTK_OBJECT (main_window));
g_signal_connect_swapped ((gpointer) paste, "activate",
G_CALLBACK (contacts_paste_cb),
GTK_OBJECT (main_window));
g_signal_connect_swapped ((gpointer) about1, "activate",
G_CALLBACK (contacts_about_cb),
main_window);
g_signal_connect_swapped ((gpointer) groups_combobox, "changed",
G_CALLBACK (contacts_update_treeview),
data);
g_signal_connect_data ((gpointer) contacts_treeview, "key_press_event",
G_CALLBACK (contacts_treeview_search_cb),
GTK_OBJECT (search_entry),
NULL, G_CONNECT_AFTER | G_CONNECT_SWAPPED);
g_signal_connect ((gpointer) search_entry, "changed",
G_CALLBACK (contacts_search_changed_cb),
data);
g_signal_connect ((gpointer) symbols_radiobutton, "clicked",
G_CALLBACK (contacts_search_changed_cb),
data);
g_signal_connect ((gpointer) atog_radiobutton, "clicked",
G_CALLBACK (contacts_search_changed_cb),
data);
g_signal_connect ((gpointer) hton_radiobutton, "clicked",
G_CALLBACK (contacts_search_changed_cb),
data);
g_signal_connect ((gpointer) otou_radiobutton, "clicked",
G_CALLBACK (contacts_search_changed_cb),
data);
g_signal_connect ((gpointer) vtoz_radiobutton, "clicked",
G_CALLBACK (contacts_search_changed_cb),
data);
g_signal_connect ((gpointer) remove_field_button, "clicked",
G_CALLBACK (contacts_remove_field_cb),
NULL);
g_signal_connect (G_OBJECT (new_button), "clicked",
G_CALLBACK (contacts_new_cb), data);
g_signal_connect (G_OBJECT (new_menuitem), "activate",
G_CALLBACK (contacts_new_cb), data);
g_signal_connect (G_OBJECT (edit_button), "clicked",
G_CALLBACK (contacts_edit_cb), data);
g_signal_connect (G_OBJECT (contacts_treeview), "row_activated",
G_CALLBACK (contacts_treeview_edit_cb), data);
g_signal_connect (G_OBJECT (edit_menuitem), "activate",
G_CALLBACK (contacts_edit_cb), data);
g_signal_connect (G_OBJECT (delete_button), "clicked",
G_CALLBACK (contacts_delete_cb), data);
g_signal_connect (G_OBJECT (delete_menuitem), "activate",
G_CALLBACK (contacts_delete_cb), data);
g_signal_connect (G_OBJECT (contacts_import), "activate",
G_CALLBACK (contacts_import_cb), data);
g_signal_connect (G_OBJECT (edit_menu), "activate",
G_CALLBACK (contacts_edit_menu_activate_cb), data);
g_signal_connect (G_OBJECT (groups_combobox), "changed",
G_CALLBACK (groups_combobox_changed_cb), data);
ui->contact_delete = contact_delete;
ui->contact_export = contact_export;
ui->contact_menu = contact_menu;
ui->contacts_import = contacts_import;
ui->contacts_menu = contacts_menu;
ui->contacts_treeview = contacts_treeview;
ui->new_menuitem = new_menuitem;
ui->copy_menuitem = copy;
ui->cut_menuitem = cut;
ui->delete_menuitem = delete_menuitem;
ui->delete_button = delete_button;
ui->edit_menuitem = edit_menuitem;
ui->edit_button = edit_button;
ui->edit_done_button = edit_done_button;
ui->edit_groups = edit_groups;
ui->edit_menu = edit_menu;
ui->edit_table = edit_table;
ui->main_menubar = main_menubar;
ui->main_notebook = main_notebook;
ui->main_window = main_window;
ui->new_button = new_button;
ui->paste_menuitem = paste;
ui->photo_image = photo_image;
ui->preview_header_hbox = preview_header_hbox;
ui->add_field_button = add_field_button;
ui->remove_field_button = remove_field_button;
ui->search_entry = search_entry;
ui->search_entry_hbox = search_entry_hbox;
ui->search_hbox = search_hbox;
ui->search_tab_hbox = search_tab_hbox;
//ui->groups_combobox = groups_combobox;
ui->summary_hbuttonbox = summary_hbuttonbox;
ui->summary_name_label = summary_name_label;
ui->summary_group_label = summary_group_label;
ui->summary_table = summary_table;
ui->summary_vbox = summary_vbox;
#ifdef HAVE_GCONF
client = gconf_client_get_default ();
search = gconf_client_get_string (client, GCONF_KEY_SEARCH, NULL);
if (!search) {
gconf_client_set_string (
client, GCONF_KEY_SEARCH, "entry", NULL);
} else {
if (strcmp (search, "alphatab") == 0) {
gtk_widget_hide (search_entry_hbox);
gtk_widget_show (search_tab_hbox);
}
g_free (search);
}
gconf_client_add_dir (client, GCONF_PATH, GCONF_CLIENT_PRELOAD_NONE,
NULL);
gconf_client_notify_add (client, GCONF_KEY_SEARCH,
contacts_gconf_search_cb, data, NULL, NULL);
width = gconf_client_get_int (client, GCONF_PATH "/width", NULL);
height = gconf_client_get_int (client, GCONF_PATH "/height", NULL);
gtk_window_set_default_size (GTK_WINDOW (main_window), width, height);
#endif
}
GtkWidget*
create_window1 (void)
{
GtkWidget *window1;
GtkWidget *table1;
GtkWidget *table3;
GtkWidget *table5;
GtkWidget *button4;
GtkWidget *popupbutton;
GtkWidget *label4;
GtkWidget *reference_button;
GtkWidget *hseparator1;
GtkWidget *table9;
GtkWidget *label8;
GtkWidget *entry1;
GtkWidget *button3;
GtkWidget *button1;
GtkWidget *hseparator2;
GtkWidget *table10;
GtkWidget *frame8;
GtkWidget *scrolledwindow8;
GtkWidget *clist1;
GtkWidget *label9;
GtkWidget *myNotebook;
GtkWidget *scrolledwindow12;
GtkWidget *text1;
GtkWidget *label57;
GtkTooltips *tooltips;
tooltips = gtk_tooltips_new ();
window1 = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_object_set_data (GTK_OBJECT (window1), "window1", window1);
gtk_widget_set_usize (window1, 320, 240);
gtk_window_set_title (GTK_WINDOW (window1), _("mydict"));
table1 = gtk_table_new (5, 1, FALSE);
gtk_widget_ref (table1);
gtk_object_set_data_full (GTK_OBJECT (window1), "table1", table1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (table1);
gtk_container_add (GTK_CONTAINER (window1), table1);
gtk_container_set_border_width (GTK_CONTAINER (table1), 2);
table3 = gtk_table_new (1, 1, FALSE);
gtk_widget_ref (table3);
gtk_object_set_data_full (GTK_OBJECT (window1), "table3", table3,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (table3);
gtk_table_attach (GTK_TABLE (table1), table3, 0, 1, 4, 5,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
table5 = gtk_table_new (1, 4, FALSE);
gtk_widget_ref (table5);
gtk_object_set_data_full (GTK_OBJECT (window1), "table5", table5,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (table5);
gtk_table_attach (GTK_TABLE (table3), table5, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
button4 = gtk_button_new_with_label (_(" Quit "));
gtk_widget_ref (button4);
gtk_object_set_data_full (GTK_OBJECT (window1), "button4", button4,
(GtkDestroyNotify) gtk_widget_unref);
// gtk_widget_show (button4);
gtk_table_attach (GTK_TABLE (table5), button4, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_tooltips_set_tip (tooltips, button4, _("Give me comments"), NULL);
popupbutton = gtk_button_new_with_label (_("Popup Recite"));
gtk_widget_ref (popupbutton);
gtk_object_set_data_full (GTK_OBJECT (window1), "popupbutton", popupbutton,
(GtkDestroyNotify) gtk_widget_unref);
// gtk_widget_show (popupbutton);
gtk_table_attach (GTK_TABLE (table5), popupbutton, 3, 4, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
label4 = gtk_label_new (_(" MyDict , Powered by brains. "));
gtk_widget_ref (label4);
gtk_object_set_data_full (GTK_OBJECT (window1), "label4", label4,
(GtkDestroyNotify) gtk_widget_unref);
// gtk_widget_show (label4);
gtk_table_attach (GTK_TABLE (table5), label4, 2, 3, 0, 1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label4), 0, 0.5);
gtk_misc_set_padding (GTK_MISC (label4), 0, 7);
reference_button = gtk_button_new_with_label (_("Reference"));
gtk_widget_ref (reference_button);
gtk_object_set_data_full (GTK_OBJECT (window1), "reference_button", reference_button,
(GtkDestroyNotify) gtk_widget_unref);
// gtk_widget_show (reference_button);
gtk_table_attach (GTK_TABLE (table5), reference_button, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_container_set_border_width (GTK_CONTAINER (reference_button), 1);
hseparator1 = gtk_hseparator_new ();
gtk_widget_ref (hseparator1);
gtk_object_set_data_full (GTK_OBJECT (window1), "hseparator1", hseparator1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hseparator1);
gtk_table_attach (GTK_TABLE (table1), hseparator1, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_EXPAND),
(GtkAttachOptions) (0), 0, 0);
table9 = gtk_table_new (1, 4, FALSE);
gtk_widget_ref (table9);
gtk_object_set_data_full (GTK_OBJECT (window1), "table9", table9,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (table9);
gtk_table_attach (GTK_TABLE (table1), table9, 0, 1, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
label8 = gtk_label_new (_(" What is: "));
gtk_widget_ref (label8);
gtk_object_set_data_full (GTK_OBJECT (window1), "label8", label8,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label8);
gtk_table_attach (GTK_TABLE (table9), label8, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label8), 0, 0.5);
gtk_misc_set_padding (GTK_MISC (label8), 0, 5);
entry1 = gtk_entry_new ();
gtk_widget_ref (entry1);
gtk_object_set_data_full (GTK_OBJECT (window1), "entry1", entry1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (entry1);
gtk_table_attach (GTK_TABLE (table9), entry1, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_tooltips_set_tip (tooltips, entry1, _("Click Right button to clear the entry"), NULL);
button3 = gtk_button_new_with_label (_(" Search "));
gtk_widget_ref (button3);
gtk_object_set_data_full (GTK_OBJECT (window1), "button3", button3,
(GtkDestroyNotify) gtk_widget_unref);
// gtk_widget_show (button3);
gtk_table_attach (GTK_TABLE (table9), button3, 2, 3, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_tooltips_set_tip (tooltips, button3, _("Look up "), NULL);
button1 = gtk_button_new_with_label (_("Add"));
gtk_widget_ref (button1);
gtk_object_set_data_full (GTK_OBJECT (window1), "button1", button1,
(GtkDestroyNotify) gtk_widget_unref);
// gtk_widget_show (button1);
gtk_table_attach (GTK_TABLE (table9), button1, 3, 4, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_container_set_border_width (GTK_CONTAINER (button1), 2);
gtk_tooltips_set_tip (tooltips, button1, _("Need to remember"), NULL);
hseparator2 = gtk_hseparator_new ();
gtk_widget_ref (hseparator2);
gtk_object_set_data_full (GTK_OBJECT (window1), "hseparator2", hseparator2,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hseparator2);
gtk_table_attach (GTK_TABLE (table1), hseparator2, 0, 1, 2, 3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
/* */
table10 = gtk_table_new (1, 2, FALSE);
gtk_widget_ref (table10);
gtk_object_set_data_full (GTK_OBJECT (window1), "table10", table10,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (table10);
gtk_table_attach (GTK_TABLE (table1), table10, 0, 1, 3, 4,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
frame8 = gtk_frame_new (_("Relative Words"));
gtk_widget_ref (frame8);
gtk_object_set_data_full (GTK_OBJECT (window1), "frame8", frame8,
(GtkDestroyNotify) gtk_widget_unref);
// gtk_widget_show (frame8);
gtk_table_attach (GTK_TABLE (table10), frame8, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
gtk_widget_set_usize (frame8, 130, -2);
gtk_container_set_border_width (GTK_CONTAINER (frame8), 1);
gtk_frame_set_label_align (GTK_FRAME (frame8), 0.61, 0.5);
scrolledwindow8 = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_ref (scrolledwindow8);
gtk_object_set_data_full (GTK_OBJECT (window1), "scrolledwindow8", scrolledwindow8,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (scrolledwindow8);
gtk_container_add (GTK_CONTAINER (frame8), scrolledwindow8);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow8), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
clist1 = gtk_clist_new (1);
gtk_widget_ref (clist1);
gtk_object_set_data_full (GTK_OBJECT (window1), "clist1", clist1,
(GtkDestroyNotify) gtk_widget_unref);
// gtk_widget_show (clist1);
gtk_container_add (GTK_CONTAINER (scrolledwindow8), clist1);
gtk_clist_set_column_width (GTK_CLIST (clist1), 0, 80);
gtk_clist_column_titles_hide (GTK_CLIST (clist1));
gtk_clist_set_shadow_type (GTK_CLIST (clist1), GTK_SHADOW_ETCHED_IN);
label9 = gtk_label_new (_("label9"));
gtk_widget_ref (label9);
gtk_object_set_data_full (GTK_OBJECT (window1), "label9", label9,
(GtkDestroyNotify) gtk_widget_unref);
// gtk_widget_show (label9);
gtk_clist_set_column_widget (GTK_CLIST (clist1), 0, label9);
myNotebook = gtk_notebook_new ();
gtk_widget_ref (myNotebook);
gtk_object_set_data_full (GTK_OBJECT (window1), "myNotebook", myNotebook,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (myNotebook);
gtk_table_attach (GTK_TABLE (table10), myNotebook, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
gtk_notebook_set_scrollable (GTK_NOTEBOOK (myNotebook), TRUE);
scrolledwindow12 = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_ref (scrolledwindow12);
gtk_object_set_data_full (GTK_OBJECT (window1), "scrolledwindow12", scrolledwindow12,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (scrolledwindow12);
gtk_container_add (GTK_CONTAINER (myNotebook), scrolledwindow12);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow12), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
/* */
text1 = gtk_text_new (NULL, NULL);
gtk_widget_ref (text1);
gtk_object_set_data_full (GTK_OBJECT (window1), "text1", text1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (text1);
gtk_container_add (GTK_CONTAINER (scrolledwindow12), text1);
gtk_text_insert (GTK_TEXT (text1), NULL, NULL, NULL,
_("\nWelcome to gnuDict framework - mydict-client Gtk version\n\n\n\n\n\nNow check the plugins ......."), -1);
label57 = gtk_label_new (_("Welcome to mydict"));
gtk_widget_ref (label57);
gtk_object_set_data_full (GTK_OBJECT (window1), "label57", label57,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label57);
gtk_notebook_set_tab_label (GTK_NOTEBOOK (myNotebook), gtk_notebook_get_nth_page (GTK_NOTEBOOK (myNotebook), 0), label57);
gtk_signal_connect (GTK_OBJECT (window1), "destroy",
GTK_SIGNAL_FUNC (on_window1_destroy),
NULL);
gtk_signal_connect (GTK_OBJECT (button4), "clicked",
GTK_SIGNAL_FUNC (on_button4_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (popupbutton), "clicked",
GTK_SIGNAL_FUNC (on_popupbutton_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (reference_button), "clicked",
GTK_SIGNAL_FUNC (on_reference_button_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (entry1), "key_press_event",
GTK_SIGNAL_FUNC (on_entry1_key_press_event),
NULL);
gtk_signal_connect (GTK_OBJECT (entry1), "button_press_event",
GTK_SIGNAL_FUNC (on_entry1_button_press_event),
NULL);
gtk_signal_connect (GTK_OBJECT (button3), "clicked",
GTK_SIGNAL_FUNC (on_button3_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (button1), "clicked",
GTK_SIGNAL_FUNC (on_button1_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (clist1), "select_row",
GTK_SIGNAL_FUNC (on_clist1_select_row),
NULL);
gtk_signal_connect (GTK_OBJECT (clist1), "key_release_event",
GTK_SIGNAL_FUNC (on_clist1_key_release_event),
clist1);
gtk_signal_connect (GTK_OBJECT (myNotebook), "button_release_event",
GTK_SIGNAL_FUNC (on_myNotebook_button_press_event),
NULL);
gtk_object_set_data (GTK_OBJECT (window1), "tooltips", tooltips);
gtk_widget_grab_focus(entry1);
return window1;
}
void CagMisc::SetPadding(TInt aX, TInt aY)
{
gtk_misc_set_padding(GTK_MISC(iWidget), aX, aY);
}
GtkWidget*
create_preference (void)
{
GtkWidget *preference;
GtkWidget *vbox1;
GtkWidget *notebook1;
GtkWidget *vbox6;
GtkWidget *frame9;
GtkWidget *label36;
GtkWidget *hseparator4;
GtkWidget *frame10;
GtkWidget *label37;
GtkWidget *nonengbutton;
GtkWidget *label16;
GtkWidget *vbox7;
GtkWidget *frame18;
GtkWidget *reloadbutton;
GtkWidget *hseparator5;
GtkWidget *frame13;
GtkWidget *vbox8;
GtkWidget *hbox9;
GtkWidget *label41;
GtkObject *spinbutton1_adj;
GtkWidget *spinbutton1;
GtkWidget *button16;
GtkWidget *button17;
GtkWidget *label40;
GtkWidget *frame16;
GtkWidget *vbox10;
GtkWidget *scrolledwindow13;
GtkWidget *recitelist;
GtkWidget *label58;
GtkWidget *hbox12;
GtkWidget *recitedb;
GtkWidget *label25;
GtkWidget *hseparator3;
GtkWidget *hbox7;
GtkWidget *button11;
GtkWidget *label52;
GtkWidget *label43;
GtkWidget *label51;
GtkWidget *debugbutton;
preference = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_object_set_data (GTK_OBJECT (preference), "preference", preference);
gtk_widget_set_usize (preference, 300, -2);
gtk_window_set_title (GTK_WINDOW (preference), _("Preference"));
vbox1 = gtk_vbox_new (FALSE, 3);
gtk_widget_ref (vbox1);
gtk_object_set_data_full (GTK_OBJECT (preference), "vbox1", vbox1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (vbox1);
gtk_container_add (GTK_CONTAINER (preference), vbox1);
gtk_container_set_border_width (GTK_CONTAINER (vbox1), 3);
notebook1 = gtk_notebook_new ();
gtk_widget_ref (notebook1);
gtk_object_set_data_full (GTK_OBJECT (preference), "notebook1", notebook1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (notebook1);
gtk_box_pack_start (GTK_BOX (vbox1), notebook1, TRUE, TRUE, 0);
vbox6 = gtk_vbox_new (FALSE, 0);
gtk_widget_ref (vbox6);
gtk_object_set_data_full (GTK_OBJECT (preference), "vbox6", vbox6,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (vbox6);
gtk_container_add (GTK_CONTAINER (notebook1), vbox6);
frame9 = gtk_frame_new (_("MyDict"));
gtk_widget_ref (frame9);
gtk_object_set_data_full (GTK_OBJECT (preference), "frame9", frame9,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (frame9);
gtk_box_pack_start (GTK_BOX (vbox6), frame9, FALSE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (frame9), 2);
label36 = gtk_label_new (_("GNU Dict - Dictionary Framework\n- mydict-client package\nMyDict\nAuthor : Larry Cai <*****@*****.**>"));
gtk_widget_ref (label36);
gtk_object_set_data_full (GTK_OBJECT (preference), "label36", label36,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label36);
gtk_container_add (GTK_CONTAINER (frame9), label36);
hseparator4 = gtk_hseparator_new ();
gtk_widget_ref (hseparator4);
gtk_object_set_data_full (GTK_OBJECT (preference), "hseparator4", hseparator4,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hseparator4);
gtk_box_pack_start (GTK_BOX (vbox6), hseparator4, FALSE, TRUE, 5);
frame10 = gtk_frame_new (_("Techonology"));
gtk_widget_ref (frame10);
gtk_object_set_data_full (GTK_OBJECT (preference), "frame10", frame10,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (frame10);
gtk_box_pack_start (GTK_BOX (vbox6), frame10, TRUE, TRUE, 0);
label37 = gtk_label_new (_("Please visit\nhttp://sourceforge.net/projects/gnudict\nfor the Dictionary Techonology\n\nPowered by Glade & Brains\n\n\n"));
gtk_widget_ref (label37);
gtk_object_set_data_full (GTK_OBJECT (preference), "label37", label37,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label37);
gtk_container_add (GTK_CONTAINER (frame10), label37);
gtk_label_set_justify (GTK_LABEL (label37), GTK_JUSTIFY_LEFT);
nonengbutton = gtk_toggle_button_new_with_label (_("use locale for translation"));
gtk_widget_ref (nonengbutton);
gtk_object_set_data_full (GTK_OBJECT (preference), "nonengbutton", nonengbutton,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (nonengbutton);
gtk_box_pack_start (GTK_BOX (vbox6), nonengbutton, FALSE, FALSE, 0);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (nonengbutton), TRUE);
label16 = gtk_label_new (_("About"));
gtk_widget_ref (label16);
gtk_object_set_data_full (GTK_OBJECT (preference), "label16", label16,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label16);
gtk_notebook_set_tab_label (GTK_NOTEBOOK (notebook1), gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook1), 0), label16);
vbox7 = gtk_vbox_new (FALSE, 0);
gtk_widget_ref (vbox7);
gtk_object_set_data_full (GTK_OBJECT (preference), "vbox7", vbox7,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (vbox7);
gtk_container_add (GTK_CONTAINER (notebook1), vbox7);
frame18 = gtk_frame_new (_(" Dict"));
gtk_widget_ref (frame18);
gtk_object_set_data_full (GTK_OBJECT (preference), "frame18", frame18,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (frame18);
gtk_box_pack_start (GTK_BOX (vbox7), frame18, FALSE, TRUE, 0);
reloadbutton = gtk_button_new_with_label (_("reload my plugins"));
gtk_widget_ref (reloadbutton);
gtk_object_set_data_full (GTK_OBJECT (preference), "reloadbutton", reloadbutton,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (reloadbutton);
gtk_container_add (GTK_CONTAINER (frame18), reloadbutton);
gtk_widget_set_usize (reloadbutton, -2, 22);
hseparator5 = gtk_hseparator_new ();
gtk_widget_ref (hseparator5);
gtk_object_set_data_full (GTK_OBJECT (preference), "hseparator5", hseparator5,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hseparator5);
gtk_box_pack_start (GTK_BOX (vbox7), hseparator5, FALSE, TRUE, 0);
frame13 = gtk_frame_new (_("Recite"));
gtk_widget_ref (frame13);
gtk_object_set_data_full (GTK_OBJECT (preference), "frame13", frame13,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (frame13);
gtk_box_pack_start (GTK_BOX (vbox7), frame13, FALSE, TRUE, 0);
vbox8 = gtk_vbox_new (FALSE, 0);
gtk_widget_ref (vbox8);
gtk_object_set_data_full (GTK_OBJECT (preference), "vbox8", vbox8,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (vbox8);
gtk_container_add (GTK_CONTAINER (frame13), vbox8);
hbox9 = gtk_hbox_new (FALSE, 0);
gtk_widget_ref (hbox9);
gtk_object_set_data_full (GTK_OBJECT (preference), "hbox9", hbox9,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hbox9);
gtk_box_pack_start (GTK_BOX (vbox8), hbox9, FALSE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (hbox9), 1);
label41 = gtk_label_new (_("Interval:"));
gtk_widget_ref (label41);
gtk_object_set_data_full (GTK_OBJECT (preference), "label41", label41,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label41);
gtk_box_pack_start (GTK_BOX (hbox9), label41, FALSE, FALSE, 0);
gtk_misc_set_padding (GTK_MISC (label41), 4, 0);
spinbutton1_adj = gtk_adjustment_new (11, 0, 100, 1, 10, 10);
spinbutton1 = gtk_spin_button_new (GTK_ADJUSTMENT (spinbutton1_adj), 1, 0);
gtk_widget_ref (spinbutton1);
gtk_object_set_data_full (GTK_OBJECT (preference), "spinbutton1", spinbutton1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (spinbutton1);
gtk_box_pack_start (GTK_BOX (hbox9), spinbutton1, TRUE, TRUE, 0);
button16 = gtk_button_new_with_label (_("Default"));
gtk_widget_ref (button16);
gtk_object_set_data_full (GTK_OBJECT (preference), "button16", button16,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (button16);
gtk_box_pack_end (GTK_BOX (hbox9), button16, FALSE, FALSE, 2);
button17 = gtk_button_new_with_label (_("Update"));
gtk_widget_ref (button17);
gtk_object_set_data_full (GTK_OBJECT (preference), "button17", button17,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (button17);
gtk_box_pack_end (GTK_BOX (hbox9), button17, FALSE, FALSE, 2);
label40 = gtk_label_new (_("seconds"));
gtk_widget_ref (label40);
gtk_object_set_data_full (GTK_OBJECT (preference), "label40", label40,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label40);
gtk_box_pack_end (GTK_BOX (hbox9), label40, FALSE, FALSE, 0);
frame16 = gtk_frame_new (_("Recite Database"));
gtk_widget_ref (frame16);
gtk_object_set_data_full (GTK_OBJECT (preference), "frame16", frame16,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (frame16);
gtk_box_pack_start (GTK_BOX (vbox7), frame16, TRUE, TRUE, 0);
vbox10 = gtk_vbox_new (FALSE, 0);
gtk_widget_ref (vbox10);
gtk_object_set_data_full (GTK_OBJECT (preference), "vbox10", vbox10,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (vbox10);
gtk_container_add (GTK_CONTAINER (frame16), vbox10);
scrolledwindow13 = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_ref (scrolledwindow13);
gtk_object_set_data_full (GTK_OBJECT (preference), "scrolledwindow13", scrolledwindow13,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (scrolledwindow13);
gtk_box_pack_start (GTK_BOX (vbox10), scrolledwindow13, TRUE, TRUE, 0);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow13), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
recitelist = gtk_clist_new (1);
gtk_widget_ref (recitelist);
gtk_object_set_data_full (GTK_OBJECT (preference), "recitelist", recitelist,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (recitelist);
gtk_container_add (GTK_CONTAINER (scrolledwindow13), recitelist);
gtk_clist_set_column_width (GTK_CLIST (recitelist), 0, 80);
gtk_clist_column_titles_show (GTK_CLIST (recitelist));
label58 = gtk_label_new (_("Recite database list"));
gtk_widget_ref (label58);
gtk_object_set_data_full (GTK_OBJECT (preference), "label58", label58,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label58);
gtk_clist_set_column_widget (GTK_CLIST (recitelist), 0, label58);
hbox12 = gtk_hbox_new (TRUE, 0);
gtk_widget_ref (hbox12);
gtk_object_set_data_full (GTK_OBJECT (preference), "hbox12", hbox12,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hbox12);
gtk_box_pack_start (GTK_BOX (vbox10), hbox12, FALSE, TRUE, 0);
recitedb = gtk_button_new_with_label (_("reload list"));
gtk_widget_ref (recitedb);
gtk_object_set_data_full (GTK_OBJECT (preference), "recitedb", recitedb,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (recitedb);
gtk_box_pack_start (GTK_BOX (hbox12), recitedb, FALSE, FALSE, 0);
label25 = gtk_label_new (_("Options"));
gtk_widget_ref (label25);
gtk_object_set_data_full (GTK_OBJECT (preference), "label25", label25,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label25);
gtk_notebook_set_tab_label (GTK_NOTEBOOK (notebook1), gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook1), 1), label25);
hseparator3 = gtk_hseparator_new ();
gtk_widget_ref (hseparator3);
gtk_object_set_data_full (GTK_OBJECT (preference), "hseparator3", hseparator3,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hseparator3);
gtk_box_pack_start (GTK_BOX (vbox1), hseparator3, FALSE, TRUE, 3);
hbox7 = gtk_hbox_new (TRUE, 5);
gtk_widget_ref (hbox7);
gtk_object_set_data_full (GTK_OBJECT (preference), "hbox7", hbox7,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hbox7);
gtk_box_pack_start (GTK_BOX (vbox1), hbox7, FALSE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (hbox7), 3);
button11 = gtk_button_new_with_label (_("Quit"));
gtk_widget_ref (button11);
gtk_object_set_data_full (GTK_OBJECT (preference), "button11", button11,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (button11);
gtk_box_pack_start (GTK_BOX (hbox7), button11, FALSE, TRUE, 0);
label52 = gtk_label_new ("");
gtk_widget_ref (label52);
gtk_object_set_data_full (GTK_OBJECT (preference), "label52", label52,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label52);
gtk_box_pack_start (GTK_BOX (hbox7), label52, FALSE, FALSE, 0);
label43 = gtk_label_new (_("Thank you for using myDict"));
gtk_widget_ref (label43);
gtk_object_set_data_full (GTK_OBJECT (preference), "label43", label43,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label43);
gtk_box_pack_start (GTK_BOX (hbox7), label43, FALSE, FALSE, 0);
gtk_label_set_justify (GTK_LABEL (label43), GTK_JUSTIFY_LEFT);
label51 = gtk_label_new ("");
gtk_widget_ref (label51);
gtk_object_set_data_full (GTK_OBJECT (preference), "label51", label51,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label51);
gtk_box_pack_start (GTK_BOX (hbox7), label51, FALSE, FALSE, 0);
debugbutton = gtk_toggle_button_new_with_label (_("Debug"));
gtk_widget_ref (debugbutton);
gtk_object_set_data_full (GTK_OBJECT (preference), "debugbutton", debugbutton,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (debugbutton);
gtk_box_pack_start (GTK_BOX (hbox7), debugbutton, FALSE, TRUE, 0);
gtk_signal_connect (GTK_OBJECT (nonengbutton), "toggled",
GTK_SIGNAL_FUNC (on_nonengbutton_toggled),
NULL);
gtk_signal_connect (GTK_OBJECT (reloadbutton), "clicked",
GTK_SIGNAL_FUNC (on_reloadbutton_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (button16), "clicked",
GTK_SIGNAL_FUNC (on_default_timer_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (button17), "clicked",
GTK_SIGNAL_FUNC (on_update_timer_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (recitelist), "select_row",
GTK_SIGNAL_FUNC (on_recitelist_select_row),
NULL);
gtk_signal_connect (GTK_OBJECT (recitedb), "clicked",
GTK_SIGNAL_FUNC (on_recitedb_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (button11), "clicked",
GTK_SIGNAL_FUNC (on_button11_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (debugbutton), "toggled",
GTK_SIGNAL_FUNC (on_debugbutton_toggled),
NULL);
return preference;
}
GtkWidget * gw_dialog_box_create ( GtkWindow *window, gchar *title, gchar *text, GtkSignalFunc ok, GtkSignalFunc no, GtkSignalFunc cancel, gpointer data)
{
/*static */GtkWidget *w = NULL;
GtkWidget *label;
GtkWidget *button;
guint button_key;
GtkAccelGroup *accel;
gchar *text_utf8 = NULL;
#ifdef GW_DEBUG_GUI_COMPONENT
g_print ( "*** GW - %s (%d) :: %s()\n", __FILE__, __LINE__, __PRETTY_FUNCTION__);
#endif
if ( !w )
{
accel = gtk_accel_group_new ( );
w = gtk_dialog_new ( );
if ( window != NULL )
{
gtk_window_set_modal ( GTK_WINDOW ( w), TRUE);
gtk_window_set_transient_for ( GTK_WINDOW ( w), GTK_WINDOW ( window));
gtk_object_set_data ( GTK_OBJECT ( w), GW_REF_DIALOG_BOX_PARENT_WINDOW, window);
}
if ( data != NULL )
{
gtk_object_set_data ( GTK_OBJECT ( w), GW_REF_DIALOG_BOX_USER_DATA, data);
}
gtk_window_set_position ( GTK_WINDOW ( w), GTK_WIN_POS_CENTER);
gtk_container_set_border_width ( GTK_CONTAINER ( w), 10);
gtk_window_set_policy ( GTK_WINDOW ( w), FALSE, FALSE, TRUE);
#ifdef HAVE_GTK12
gtk_signal_connect ( GTK_OBJECT ( w), "destroy", GTK_SIGNAL_FUNC ( gtk_widget_destroyed), &w);
#endif
g_strdup_to_gtk_text ( title, text_utf8);
gtk_window_set_title ( GTK_WINDOW ( w), text_utf8);
g_free ( text_utf8);
g_strdup_to_gtk_text ( text, text_utf8);
label = gtk_label_new ( text_utf8);
g_free ( text_utf8);
gtk_misc_set_padding ( GTK_MISC ( label), 10, 10);
gtk_box_pack_start ( GTK_BOX ( GTK_DIALOG ( w)->vbox), label, TRUE, TRUE, 0);
button = gtk_button_new_with_label ( "");
g_strdup_to_gtk_text ( _( "_OK"), text_utf8);
button_key = gtk_label_parse_uline ( GTK_LABEL ( GTK_BIN ( button)->child), text_utf8);
g_free ( text_utf8);
gtk_widget_add_accelerator ( button, "clicked", accel, button_key, GDK_MOD1_MASK, 0);
if ( ok != NULL )
{
gtk_signal_connect ( GTK_OBJECT ( button), "clicked", GTK_SIGNAL_FUNC ( ok), w);
}
else
{
gtk_signal_connect_object ( GTK_OBJECT ( button), "clicked", GTK_SIGNAL_FUNC ( gtk_widget_destroy), GTK_OBJECT ( w));
}
gtk_box_pack_start ( GTK_BOX ( GTK_DIALOG ( w)->action_area), button, TRUE, TRUE, 0);
gtk_widget_grab_focus ( button);
button = gtk_button_new_with_label ( "");
g_strdup_to_gtk_text ( _("_No"), text_utf8);
button_key = gtk_label_parse_uline ( GTK_LABEL ( GTK_BIN ( button)->child), text_utf8);
g_free ( text_utf8);
gtk_widget_add_accelerator ( button, "clicked", accel, button_key, GDK_MOD1_MASK, 0);
if ( no != NULL )
{
gtk_signal_connect ( GTK_OBJECT ( button), "clicked", GTK_SIGNAL_FUNC ( no), w);
}
else
{
gtk_signal_connect_object ( GTK_OBJECT ( button), "clicked", GTK_SIGNAL_FUNC ( gtk_widget_destroy), GTK_OBJECT ( w));
}
gtk_box_pack_start ( GTK_BOX ( GTK_DIALOG ( w)->action_area), button, TRUE, TRUE, 0);
button = gtk_button_new_with_label ( "");
g_strdup_to_gtk_text ( _("_Cancel"), text_utf8);
button_key = gtk_label_parse_uline ( GTK_LABEL ( GTK_BIN ( button)->child), text_utf8);
g_free ( text_utf8);
gtk_widget_add_accelerator ( button, "clicked", accel, button_key, GDK_MOD1_MASK, 0);
if ( cancel != NULL )
{
gtk_signal_connect ( GTK_OBJECT ( button), "clicked", GTK_SIGNAL_FUNC ( cancel), w);
}
else
{
gtk_signal_connect_object ( GTK_OBJECT ( button), "clicked", GTK_SIGNAL_FUNC ( gtk_widget_destroy), GTK_OBJECT ( w));
}
gtk_box_pack_start ( GTK_BOX ( GTK_DIALOG ( w)->action_area), button, TRUE, TRUE, 0);
gtk_window_add_accel_group ( GTK_WINDOW ( w), accel);
}
if ( !GTK_WIDGET_VISIBLE ( w) )
{
gtk_widget_show_all ( w);
}
else
{
gtk_widget_destroy ( w);
}
return w;
}
GtkWidget*
create_popupRecite (void)
{
GtkWidget *popupRecite;
GtkWidget *hbox10;
GtkWidget *table12;
GtkWidget *scrolledwindow11;
GtkWidget *recitePopupText;
GtkWidget *vbox9;
GtkWidget *removebutton;
GtkWidget *button19;
GtkWidget *pausecheck;
GtkWidget *hbox11;
GtkWidget *label47;
GtkWidget *wordcheck;
GtkWidget *phoncheck;
GtkWidget *transcheck;
GtkWidget *vseparator1;
GtkWidget *label50;
GtkWidget *Backbutton;
GtkWidget *nextbutton;
popupRecite = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_object_set_data (GTK_OBJECT (popupRecite), "popupRecite", popupRecite);
gtk_widget_set_usize (popupRecite, 500, -2);
gtk_window_set_title (GTK_WINDOW (popupRecite), _("Recite"));
hbox10 = gtk_hbox_new (FALSE, 0);
gtk_widget_ref (hbox10);
gtk_object_set_data_full (GTK_OBJECT (popupRecite), "hbox10", hbox10,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hbox10);
gtk_container_add (GTK_CONTAINER (popupRecite), hbox10);
table12 = gtk_table_new (2, 2, FALSE);
gtk_widget_ref (table12);
gtk_object_set_data_full (GTK_OBJECT (popupRecite), "table12", table12,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (table12);
gtk_box_pack_start (GTK_BOX (hbox10), table12, TRUE, TRUE, 0);
scrolledwindow11 = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_ref (scrolledwindow11);
gtk_object_set_data_full (GTK_OBJECT (popupRecite), "scrolledwindow11", scrolledwindow11,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (scrolledwindow11);
gtk_table_attach (GTK_TABLE (table12), scrolledwindow11, 0, 1, 1, 2,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
gtk_widget_set_usize (scrolledwindow11, -2, 28);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow11), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
recitePopupText = gtk_text_new (NULL, NULL);
gtk_widget_ref (recitePopupText);
gtk_object_set_data_full (GTK_OBJECT (popupRecite), "recitePopupText", recitePopupText,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (recitePopupText);
gtk_container_add (GTK_CONTAINER (scrolledwindow11), recitePopupText);
gtk_widget_set_usize (recitePopupText, -2, 26);
vbox9 = gtk_vbox_new (FALSE, 0);
gtk_widget_ref (vbox9);
gtk_object_set_data_full (GTK_OBJECT (popupRecite), "vbox9", vbox9,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (vbox9);
gtk_table_attach (GTK_TABLE (table12), vbox9, 1, 2, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
removebutton = gtk_button_new_with_label (_("Remove"));
gtk_widget_ref (removebutton);
gtk_object_set_data_full (GTK_OBJECT (popupRecite), "removebutton", removebutton,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (removebutton);
gtk_box_pack_start (GTK_BOX (vbox9), removebutton, FALSE, FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (removebutton), 3);
button19 = gtk_button_new_with_label (_("Quit"));
gtk_widget_ref (button19);
gtk_object_set_data_full (GTK_OBJECT (popupRecite), "button19", button19,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (button19);
gtk_box_pack_start (GTK_BOX (vbox9), button19, FALSE, FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (button19), 3);
pausecheck = gtk_check_button_new_with_label (_("Pause"));
gtk_widget_ref (pausecheck);
gtk_object_set_data_full (GTK_OBJECT (popupRecite), "pausecheck", pausecheck,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (pausecheck);
gtk_table_attach (GTK_TABLE (table12), pausecheck, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
hbox11 = gtk_hbox_new (FALSE, 0);
gtk_widget_ref (hbox11);
gtk_object_set_data_full (GTK_OBJECT (popupRecite), "hbox11", hbox11,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hbox11);
gtk_table_attach (GTK_TABLE (table12), hbox11, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
label47 = gtk_label_new (_("Display: "));
gtk_widget_ref (label47);
gtk_object_set_data_full (GTK_OBJECT (popupRecite), "label47", label47,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label47);
gtk_box_pack_start (GTK_BOX (hbox11), label47, FALSE, FALSE, 0);
gtk_misc_set_padding (GTK_MISC (label47), 5, 0);
wordcheck = gtk_check_button_new_with_label (_("Word"));
gtk_widget_ref (wordcheck);
gtk_object_set_data_full (GTK_OBJECT (popupRecite), "wordcheck", wordcheck,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (wordcheck);
gtk_box_pack_start (GTK_BOX (hbox11), wordcheck, FALSE, FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (wordcheck), 1);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wordcheck), TRUE);
phoncheck = gtk_check_button_new_with_label (_("Phonetic"));
gtk_widget_ref (phoncheck);
gtk_object_set_data_full (GTK_OBJECT (popupRecite), "phoncheck", phoncheck,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (phoncheck);
gtk_box_pack_start (GTK_BOX (hbox11), phoncheck, FALSE, FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (phoncheck), 1);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (phoncheck), TRUE);
transcheck = gtk_check_button_new_with_label (_("Translation"));
gtk_widget_ref (transcheck);
gtk_object_set_data_full (GTK_OBJECT (popupRecite), "transcheck", transcheck,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (transcheck);
gtk_box_pack_start (GTK_BOX (hbox11), transcheck, FALSE, FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (transcheck), 1);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (transcheck), TRUE);
vseparator1 = gtk_vseparator_new ();
gtk_widget_ref (vseparator1);
gtk_object_set_data_full (GTK_OBJECT (popupRecite), "vseparator1", vseparator1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (vseparator1);
gtk_box_pack_start (GTK_BOX (hbox11), vseparator1, FALSE, TRUE, 0);
label50 = gtk_label_new ("");
gtk_widget_ref (label50);
gtk_object_set_data_full (GTK_OBJECT (popupRecite), "label50", label50,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label50);
gtk_box_pack_start (GTK_BOX (hbox11), label50, TRUE, FALSE, 0);
Backbutton = gtk_button_new_with_label (_("Back"));
gtk_widget_ref (Backbutton);
gtk_object_set_data_full (GTK_OBJECT (popupRecite), "Backbutton", Backbutton,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (Backbutton);
gtk_box_pack_start (GTK_BOX (hbox11), Backbutton, FALSE, FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (Backbutton), 2);
nextbutton = gtk_button_new_with_label (_("Next"));
gtk_widget_ref (nextbutton);
gtk_object_set_data_full (GTK_OBJECT (popupRecite), "nextbutton", nextbutton,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (nextbutton);
gtk_box_pack_start (GTK_BOX (hbox11), nextbutton, FALSE, FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (nextbutton), 2);
gtk_signal_connect (GTK_OBJECT (recitePopupText), "button_press_event",
GTK_SIGNAL_FUNC (on_recitePopupText_button_press_event),
NULL);
gtk_signal_connect (GTK_OBJECT (removebutton), "clicked",
GTK_SIGNAL_FUNC (on_removebutton_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (button19), "clicked",
GTK_SIGNAL_FUNC (on_quitReciteButton_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (pausecheck), "toggled",
GTK_SIGNAL_FUNC (on_pausecheck_toggled),
NULL);
gtk_signal_connect (GTK_OBJECT (wordcheck), "toggled",
GTK_SIGNAL_FUNC (on_wordcheck_toggled),
NULL);
gtk_signal_connect (GTK_OBJECT (phoncheck), "toggled",
GTK_SIGNAL_FUNC (on_phoncheck_toggled),
NULL);
gtk_signal_connect (GTK_OBJECT (transcheck), "toggled",
GTK_SIGNAL_FUNC (on_transcheck_toggled),
NULL);
gtk_signal_connect (GTK_OBJECT (Backbutton), "clicked",
GTK_SIGNAL_FUNC (on_Backbutton_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (nextbutton), "clicked",
GTK_SIGNAL_FUNC (on_nextbutton_clicked),
NULL);
return popupRecite;
}
static void
script_fu_console_interface (void)
{
ConsoleInterface console = { 0, };
GtkWidget *vbox;
GtkWidget *button;
GtkWidget *scrolled_window;
GtkWidget *hbox;
gimp_ui_init ("script-fu", FALSE);
console.input_id = -1;
console.history_max = 50;
console.dialog = gimp_dialog_new (_("Script-Fu Console"),
"script-fu-console",
NULL, 0,
gimp_standard_help_func, PROC_NAME,
GTK_STOCK_SAVE, RESPONSE_SAVE,
GTK_STOCK_CLEAR, RESPONSE_CLEAR,
GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
NULL);
gtk_dialog_set_alternative_button_order (GTK_DIALOG (console.dialog),
GTK_RESPONSE_CLOSE,
RESPONSE_CLEAR,
RESPONSE_SAVE,
-1);
g_object_add_weak_pointer (G_OBJECT (console.dialog),
(gpointer) &console.dialog);
g_signal_connect (console.dialog, "response",
G_CALLBACK (script_fu_console_response),
&console);
/* The main vbox */
vbox = gtk_vbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 12);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (console.dialog)->vbox), vbox,
TRUE, TRUE, 0);
gtk_widget_show (vbox);
/* The output text widget */
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_ALWAYS);
gtk_box_pack_start (GTK_BOX (vbox), scrolled_window, TRUE, TRUE, 0);
gtk_widget_show (scrolled_window);
console.console = gtk_text_buffer_new (NULL);
console.text_view = gtk_text_view_new_with_buffer (console.console);
g_object_unref (console.console);
gtk_text_view_set_editable (GTK_TEXT_VIEW (console.text_view), FALSE);
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (console.text_view),
GTK_WRAP_WORD);
gtk_text_view_set_left_margin (GTK_TEXT_VIEW (console.text_view), 6);
gtk_text_view_set_right_margin (GTK_TEXT_VIEW (console.text_view), 6);
gtk_widget_set_size_request (console.text_view, TEXT_WIDTH, TEXT_HEIGHT);
gtk_container_add (GTK_CONTAINER (scrolled_window), console.text_view);
gtk_widget_show (console.text_view);
gtk_text_buffer_create_tag (console.console, "strong",
"weight", PANGO_WEIGHT_BOLD,
"scale", PANGO_SCALE_LARGE,
NULL);
gtk_text_buffer_create_tag (console.console, "emphasis",
"style", PANGO_STYLE_OBLIQUE,
NULL);
{
const gchar * const greetings[] =
{
"strong", N_("Welcome to TinyScheme"),
NULL, "\n",
NULL, "Copyright (c) Dimitrios Souflis",
NULL, "\n",
"strong", N_("Script-Fu Console"),
NULL, " - ",
"emphasis", N_("Interactive Scheme Development"),
NULL, "\n"
};
GtkTextIter cursor;
gint i;
gtk_text_buffer_get_end_iter (console.console, &cursor);
for (i = 0; i < G_N_ELEMENTS (greetings); i += 2)
{
if (greetings[i])
gtk_text_buffer_insert_with_tags_by_name (console.console, &cursor,
gettext (greetings[i + 1]),
-1, greetings[i],
NULL);
else
gtk_text_buffer_insert (console.console, &cursor,
gettext (greetings[i + 1]), -1);
}
}
/* The current command */
hbox = gtk_hbox_new (FALSE, 6);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
console.cc = gtk_entry_new ();
gtk_box_pack_start (GTK_BOX (hbox), console.cc, TRUE, TRUE, 0);
gtk_widget_grab_focus (console.cc);
gtk_widget_show (console.cc);
g_signal_connect (console.cc, "key-press-event",
G_CALLBACK (script_fu_cc_key_function),
&console);
button = gtk_button_new_with_mnemonic (_("_Browse..."));
gtk_misc_set_padding (GTK_MISC (gtk_bin_get_child (GTK_BIN (button))), 2, 0);
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, TRUE, 0);
gtk_widget_show (button);
g_signal_connect (button, "clicked",
G_CALLBACK (script_fu_browse_callback),
&console);
/* Initialize the history */
console.history = g_list_append (console.history, NULL);
console.history_len = 1;
gtk_widget_show (console.dialog);
gtk_main ();
g_source_remove (console.input_id);
if (console.save_dialog)
gtk_widget_destroy (console.save_dialog);
if (console.dialog)
gtk_widget_destroy (console.dialog);
}
/**
* thunar_dialogs_show_job_ask_replace:
* @parent : the parent #GtkWindow or %NULL.
* @src_file : the #ThunarFile of the source file.
* @dst_file : the #ThunarFile of the destination file that
* may be replaced with the source file.
*
* Asks the user whether to replace the destination file with the
* source file identified by @src_file.
*
* Return value: the selected #ThunarJobResponse.
**/
ThunarJobResponse
thunar_dialogs_show_job_ask_replace (GtkWindow *parent,
ThunarFile *src_file,
ThunarFile *dst_file)
{
ThunarIconFactory *icon_factory;
ThunarPreferences *preferences;
ThunarDateStyle date_style;
GtkIconTheme *icon_theme;
GtkWidget *dialog;
GtkWidget *table;
GtkWidget *image;
GtkWidget *label;
GdkPixbuf *icon;
gchar *date_string;
gchar *size_string;
gchar *text;
gint response;
gboolean file_size_binary;
_thunar_return_val_if_fail (parent == NULL || GTK_IS_WINDOW (parent), THUNAR_JOB_RESPONSE_CANCEL);
_thunar_return_val_if_fail (THUNAR_IS_FILE (src_file), THUNAR_JOB_RESPONSE_CANCEL);
_thunar_return_val_if_fail (THUNAR_IS_FILE (dst_file), THUNAR_JOB_RESPONSE_CANCEL);
/* determine the style used to format dates */
preferences = thunar_preferences_get ();
g_object_get (G_OBJECT (preferences), "misc-date-style", &date_style, NULL);
g_object_get (G_OBJECT (preferences), "misc-file-size-binary", &file_size_binary, NULL);
g_object_unref (G_OBJECT (preferences));
/* setup the confirmation dialog */
dialog = gtk_dialog_new_with_buttons (_("Confirm to replace files"),
parent,
GTK_DIALOG_MODAL
| GTK_DIALOG_NO_SEPARATOR
| GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
_("S_kip All"), THUNAR_JOB_RESPONSE_NO_ALL,
_("_Skip"), THUNAR_JOB_RESPONSE_NO,
_("Replace _All"), THUNAR_JOB_RESPONSE_YES_ALL,
_("_Replace"), THUNAR_JOB_RESPONSE_YES,
NULL);
gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
THUNAR_JOB_RESPONSE_YES,
THUNAR_JOB_RESPONSE_YES_ALL,
THUNAR_JOB_RESPONSE_NO,
THUNAR_JOB_RESPONSE_NO_ALL,
GTK_RESPONSE_CANCEL,
-1);
gtk_dialog_set_default_response (GTK_DIALOG (dialog), THUNAR_JOB_RESPONSE_YES);
/* determine the icon factory to use */
icon_theme = gtk_icon_theme_get_for_screen (gtk_widget_get_screen (dialog));
icon_factory = thunar_icon_factory_get_for_icon_theme (icon_theme);
table = g_object_new (GTK_TYPE_TABLE,
"border-width", 10,
"n-columns", 3,
"n-rows", 5,
"row-spacing", 6,
"column-spacing", 5,
NULL);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), table, TRUE, TRUE, 0);
gtk_widget_show (table);
image = gtk_image_new_from_icon_name ("stock_folder-copy", GTK_ICON_SIZE_BUTTON);
gtk_misc_set_alignment (GTK_MISC (image), 0.5f, 0.0f);
gtk_misc_set_padding (GTK_MISC (image), 6, 6);
gtk_table_attach (GTK_TABLE (table), image, 0, 1, 0, 1, GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
gtk_widget_show (image);
if (thunar_file_is_symlink (dst_file))
{
text = g_strdup_printf (_("This folder already contains a symbolic link \"%s\"."),
thunar_file_get_display_name (dst_file));
}
else if (thunar_file_is_directory (dst_file))
{
text = g_strdup_printf (_("This folder already contains a folder \"%s\"."),
thunar_file_get_display_name (dst_file));
}
else
{
text = g_strdup_printf (_("This folder already contains a file \"%s\"."),
thunar_file_get_display_name (dst_file));
}
label = gtk_label_new (text);
gtk_misc_set_alignment (GTK_MISC (label), 0.0f, 0.5f);
gtk_label_set_attributes (GTK_LABEL (label), thunar_pango_attr_list_big ());
gtk_table_attach (GTK_TABLE (table), label, 1, 3, 0, 1, GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
g_free (text);
if (thunar_file_is_symlink (dst_file))
text = g_strdup_printf (Q_("ReplaceDialogPart1|Do you want to replace the link"));
else if (thunar_file_is_directory (dst_file))
text = g_strdup_printf (Q_("ReplaceDialogPart1|Do you want to replace the existing folder"));
else
text = g_strdup_printf (Q_("ReplaceDialogPart1|Do you want to replace the existing file"));
label = gtk_label_new (text);
gtk_misc_set_alignment (GTK_MISC (label), 0.0f, 0.5f);
gtk_table_attach (GTK_TABLE (table), label, 1, 3, 1, 2, GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
g_free (text);
icon = thunar_icon_factory_load_file_icon (icon_factory, dst_file, THUNAR_FILE_ICON_STATE_DEFAULT, 48);
image = gtk_image_new_from_pixbuf (icon);
gtk_misc_set_padding (GTK_MISC (image), 6, 6);
gtk_table_attach (GTK_TABLE (table), image, 1, 2, 2, 3, GTK_FILL, GTK_FILL, 0, 0);
g_object_unref (G_OBJECT (icon));
gtk_widget_show (image);
size_string = thunar_file_get_size_string_formatted (dst_file, file_size_binary);
date_string = thunar_file_get_date_string (dst_file, THUNAR_FILE_DATE_MODIFIED, date_style);
text = g_strdup_printf ("%s %s\n%s %s", _("Size:"), size_string, _("Modified:"), date_string);
label = gtk_label_new (text);
gtk_misc_set_alignment (GTK_MISC (label), 0.0f, 0.5f);
gtk_table_attach (GTK_TABLE (table), label, 2, 3, 2, 3, GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
g_free (size_string);
g_free (date_string);
g_free (text);
if (thunar_file_is_symlink (src_file))
text = g_strdup_printf (Q_("ReplaceDialogPart2|with the following link?"));
else if (thunar_file_is_directory (src_file))
text = g_strdup_printf (Q_("ReplaceDialogPart2|with the following folder?"));
else
text = g_strdup_printf (Q_("ReplaceDialogPart2|with the following file?"));
label = gtk_label_new (text);
gtk_misc_set_alignment (GTK_MISC (label), 0.0f, 0.5f);
gtk_table_attach (GTK_TABLE (table), label, 1, 3, 3, 4, GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
g_free (text);
icon = thunar_icon_factory_load_file_icon (icon_factory, src_file, THUNAR_FILE_ICON_STATE_DEFAULT, 48);
image = gtk_image_new_from_pixbuf (icon);
gtk_misc_set_padding (GTK_MISC (image), 6, 6);
gtk_table_attach (GTK_TABLE (table), image, 1, 2, 4, 5, GTK_FILL, GTK_FILL, 0, 0);
g_object_unref (G_OBJECT (icon));
gtk_widget_show (image);
size_string = thunar_file_get_size_string_formatted (src_file, file_size_binary);
date_string = thunar_file_get_date_string (src_file, THUNAR_FILE_DATE_MODIFIED, date_style);
text = g_strdup_printf ("%s %s\n%s %s", _("Size:"), size_string, _("Modified:"), date_string);
label = gtk_label_new (text);
gtk_misc_set_alignment (GTK_MISC (label), 0.0f, 0.5f);
gtk_table_attach (GTK_TABLE (table), label, 2, 3, 4, 5, GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
g_free (size_string);
g_free (date_string);
g_free (text);
/* run the dialog */
response = gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_destroy (dialog);
/* cleanup */
g_object_unref (G_OBJECT (icon_factory));
/* translate GTK responses */
if (G_UNLIKELY (response < 0))
response = THUNAR_JOB_RESPONSE_CANCEL;
return response;
}
static void configure (void)
{
if (config_win)
{
gtk_window_present ((GtkWindow *) config_win);
return;
}
config_win = gtk_dialog_new_with_buttons (_("LADSPA Host Settings"), NULL,
0, _("_Close"), GTK_RESPONSE_CLOSE, NULL);
gtk_window_set_default_size ((GtkWindow *) config_win, 480, 360);
GtkWidget * vbox = gtk_dialog_get_content_area ((GtkDialog *) config_win);
GtkWidget * hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start ((GtkBox *) vbox, hbox, 0, 0, 0);
GtkWidget * label = gtk_label_new (_("Module paths:"));
gtk_box_pack_start ((GtkBox *) hbox, label, 0, 0, 0);
label = gtk_label_new (0);
gtk_label_set_markup ((GtkLabel *) label,
_("<small>Separate multiple paths with a colon.\n"
"These paths are searched in addition to LADSPA_PATH.\n"
"After adding new paths, press Enter to scan for new plugins.</small>"));
gtk_misc_set_padding ((GtkMisc *) label, 12, 6);
gtk_misc_set_alignment ((GtkMisc *) label, 0, 0);
gtk_box_pack_start ((GtkBox *) vbox, label, 0, 0, 0);
GtkWidget * entry = gtk_entry_new ();
gtk_box_pack_start ((GtkBox *) hbox, entry, 1, 1, 0);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start ((GtkBox *) vbox, hbox, 1, 1, 0);
GtkWidget * vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_box_pack_start ((GtkBox *) hbox, vbox2, 1, 1, 0);
label = gtk_label_new (_("Available plugins:"));
gtk_box_pack_start ((GtkBox *) vbox2, label, 0, 0, 0);
GtkWidget * scrolled = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type ((GtkScrolledWindow *) scrolled, GTK_SHADOW_IN);
gtk_box_pack_start ((GtkBox *) vbox2, scrolled, 1, 1, 0);
plugin_list = create_plugin_list ();
gtk_container_add ((GtkContainer *) scrolled, plugin_list);
GtkWidget * hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start ((GtkBox *) vbox2, hbox2, 0, 0, 0);
GtkWidget * enable_button = gtk_button_new_with_label (_("Enable"));
gtk_box_pack_end ((GtkBox *) hbox2, enable_button, 0, 0, 0);
vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_box_pack_start ((GtkBox *) hbox, vbox2, 1, 1, 0);
label = gtk_label_new (_("Enabled plugins:"));
gtk_box_pack_start ((GtkBox *) vbox2, label, 0, 0, 0);
scrolled = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type ((GtkScrolledWindow *) scrolled, GTK_SHADOW_IN);
gtk_box_pack_start ((GtkBox *) vbox2, scrolled, 1, 1, 0);
loaded_list = create_loaded_list ();
gtk_container_add ((GtkContainer *) scrolled, loaded_list);
hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start ((GtkBox *) vbox2, hbox2, 0, 0, 0);
GtkWidget * disable_button = gtk_button_new_with_label (_("Disable"));
gtk_box_pack_end ((GtkBox *) hbox2, disable_button, 0, 0, 0);
GtkWidget * settings_button = gtk_button_new_with_label (_("Settings"));
gtk_box_pack_end ((GtkBox *) hbox2, settings_button, 0, 0, 0);
if (module_path)
gtk_entry_set_text ((GtkEntry *) entry, module_path);
g_signal_connect (config_win, "response", (GCallback) gtk_widget_destroy, NULL);
g_signal_connect (config_win, "destroy", (GCallback) gtk_widget_destroyed, & config_win);
g_signal_connect (entry, "activate", (GCallback) set_module_path, NULL);
g_signal_connect (plugin_list, "destroy", (GCallback) gtk_widget_destroyed, & plugin_list);
g_signal_connect (enable_button, "clicked", (GCallback) enable_selected, NULL);
g_signal_connect (loaded_list, "destroy", (GCallback) gtk_widget_destroyed, & loaded_list);
g_signal_connect (disable_button, "clicked", (GCallback) disable_selected, NULL);
g_signal_connect (settings_button, "clicked", (GCallback) configure_selected, NULL);
gtk_widget_show_all (config_win);
}
/**
* Display the About Dialog Box.
*/
void displayAbout(void) {
#if GTK_CHECK_VERSION(2,12,0)
GtkWidget *dialog;
const char *authors[] = {
"Development",
"Darran Kartaschew ([email protected])",
"\nTranslations",
"English - Darran Kartaschew",
"English (Australia) - Darran Kartaschew",
"Italian - Francesca Ciceri, Fabio Castelli (Muflone)",
"French - 'Coug'",
"German - Laurenz Kamp",
"Spanish - Google Translate",
"Danish - Cai Andersen",
"Russian - PuppyRus Linux team",
"Brazilian Portuguese - Rafael Ferreira",
NULL
};
dialog = gtk_about_dialog_new();
gtk_about_dialog_set_program_name(GTK_ABOUT_DIALOG(dialog), PACKAGE_NAME);
gtk_about_dialog_set_version(GTK_ABOUT_DIALOG(dialog), PACKAGE_VERSION);
gtk_about_dialog_set_copyright(GTK_ABOUT_DIALOG(dialog),
"Copyright 2009-2015, Darran Kartaschew\nReleased under the BSD License");
gtk_about_dialog_set_comments(GTK_ABOUT_DIALOG(dialog),
_("A simple MTP Client for Solaris 10\nand other UNIX / UNIX-like systems\n"));
gtk_about_dialog_set_license(GTK_ABOUT_DIALOG(dialog),
"gMTP License\n"
"------------\n\n"
"Copyright (C) 2009-2015, Darran Kartaschew.\n"
"All rights reserved.\n\n"
"Redistribution and use in source and binary forms, with or without "
"modification, are permitted provided that the following conditions are met:\n\n"
"* Redistributions of source code must retain the above copyright notice, "
"this list of conditions and the following disclaimer.\n\n"
"* Redistributions in binary form must reproduce the above copyright notice, "
"this list of conditions and the following disclaimer in the documentation "
"and/or other materials provided with the distribution. \n\n"
"* Neither the name of \"gMTP Development Team\" nor the names of its "
"contributors may be used to endorse or promote products derived from this "
"software without specific prior written permission. \n\n"
"THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" "
"AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE "
"IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE "
"ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE "
"LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR "
"CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF "
"SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS "
"INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN "
"CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) "
"ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE "
"POSSIBILITY OF SUCH DAMAGE.");
gtk_about_dialog_set_wrap_license(GTK_ABOUT_DIALOG(dialog), TRUE);
gtk_about_dialog_set_website(GTK_ABOUT_DIALOG(dialog), "http://gmtp.sourceforge.net");
gtk_about_dialog_set_logo(GTK_ABOUT_DIALOG(dialog), gdk_pixbuf_new_from_file(file_logo_png, NULL));
gtk_about_dialog_set_authors(GTK_ABOUT_DIALOG(dialog), authors);
gtk_about_dialog_set_translator_credits(GTK_ABOUT_DIALOG(dialog), _("translator-credits"));
gtk_dialog_run(GTK_DIALOG(dialog));
gtk_widget_destroy(dialog);
#else
GtkWidget *dialog, *vbox, *label, *label2, *label3, *label4, *label5, *image;
gchar *version_string;
gchar *gtk_version_string;
dialog = gtk_dialog_new_with_buttons(_("About gMTP"), GTK_WINDOW(windowMain),
(GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT),
_("_Close"), GTK_RESPONSE_CLOSE,
NULL);
gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_CLOSE);
gtk_window_set_resizable(GTK_WINDOW(dialog), FALSE);
#if HAVE_GTK3 == 0
gtk_dialog_set_has_separator(GTK_DIALOG(dialog), FALSE);
#endif
#if HAVE_GTK3 == 0
vbox = gtk_vbox_new(FALSE, 5);
#else
vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);
#endif
gtk_widget_show(vbox);
#if HAVE_GTK3 == 0
gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), vbox);
#else
gtk_container_add(GTK_CONTAINER(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), vbox);
#endif
// Add in our icon.
image = gtk_image_new_from_file(file_logo_png);
gtk_widget_show(image);
gtk_container_add(GTK_CONTAINER(vbox), image);
version_string = g_strconcat("<span size=\"xx-large\"><b>", PACKAGE_NAME, " v", PACKAGE_VERSION, "</b></span>", NULL);
label = gtk_label_new(version_string);
gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
gtk_widget_show(label);
gtk_container_add(GTK_CONTAINER(vbox), label);
label2 = gtk_label_new(_("A simple MTP Client for Solaris 10\nand other UNIX / UNIX-like systems\n"));
gtk_label_set_use_markup(GTK_LABEL(label2), TRUE);
gtk_label_set_justify(GTK_LABEL(label2), GTK_JUSTIFY_CENTER);
gtk_misc_set_padding(GTK_MISC(label2), 5, 0);
gtk_widget_show(label2);
gtk_container_add(GTK_CONTAINER(vbox), label2);
label5 = gtk_label_new("http://gmtp.sourceforge.net\n");
gtk_label_set_use_markup(GTK_LABEL(label5), TRUE);
gtk_widget_show(label5);
gtk_container_add(GTK_CONTAINER(vbox), label5);
label3 = gtk_label_new(_("<small>Copyright 2009-2014, Darran Kartaschew</small>\n<small>Released under the BSD License</small>"));
gtk_label_set_use_markup(GTK_LABEL(label3), TRUE);
gtk_widget_show(label3);
gtk_container_add(GTK_CONTAINER(vbox), label3);
gtk_version_string = g_strdup_printf("<small>Built with GTK v%d.%d.%d</small>\n", GTK_MAJOR_VERSION, GTK_MINOR_VERSION, GTK_MICRO_VERSION);
label4 = gtk_label_new(gtk_version_string);
gtk_label_set_use_markup(GTK_LABEL(label4), TRUE);
gtk_widget_show(label4);
gtk_container_add(GTK_CONTAINER(vbox), label4);
gtk_dialog_run(GTK_DIALOG(dialog));
gtk_widget_destroy(dialog);
g_free(version_string);
g_free(gtk_version_string);
#endif
}
