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 }