gint setup_game (GtkAction * action, gpointer data) { GtkWidget *box, *box2, *label, *button, *frame; GtkWidget *grid; GtkWidget *combo; gchar *ts; int i; if (setupdialog) { gtk_window_present (GTK_WINDOW (setupdialog)); return FALSE; } setupdialog = gtk_dialog_new_with_buttons (_("Tali Preferences"), GTK_WINDOW (window), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, NULL); gtk_box_set_spacing (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (setupdialog))), 2); gtk_window_set_resizable (GTK_WINDOW (setupdialog), FALSE); g_signal_connect (G_OBJECT (setupdialog), "delete_event", G_CALLBACK (setupdialog_destroy), NULL); button = gtk_button_new_from_stock (GTK_STOCK_OK); g_signal_connect (G_OBJECT (setupdialog), "response", G_CALLBACK (do_setup), NULL); grid = gtk_grid_new (); gtk_container_set_border_width (GTK_CONTAINER (grid), 5); gtk_grid_set_row_spacing (GTK_GRID (grid), 18); gtk_grid_set_column_spacing (GTK_GRID (grid), 18); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (setupdialog))), grid, FALSE, FALSE, 0); frame = games_frame_new (_("Human Players")); gtk_grid_attach (GTK_GRID (grid), frame, 0, 0, 1, 1); box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); gtk_container_add (GTK_CONTAINER (frame), box); /*--- Spinner (number of humans) ---*/ OriginalNumberOfHumans = NumberOfHumans; box2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12); gtk_box_pack_start (GTK_BOX (box), box2, FALSE, FALSE, 0); label = gtk_label_new_with_mnemonic (_("_Number of players:")); gtk_box_pack_start (GTK_BOX (box2), label, FALSE, FALSE, 0); HumanAdj = gtk_adjustment_new ((gfloat) NumberOfHumans, 1.0, 6.0, 1.0, 6.0, 0.0); HumanSpinner = gtk_spin_button_new (GTK_ADJUSTMENT (HumanAdj), 10, 0); gtk_label_set_mnemonic_widget (GTK_LABEL (label), HumanSpinner); g_signal_connect (G_OBJECT (HumanAdj), "value_changed", G_CALLBACK (MaxPlayersCheck), HumanAdj); gtk_box_pack_start (GTK_BOX (box2), HumanSpinner, TRUE, TRUE, 0); frame = games_frame_new (_("Computer Opponents")); gtk_grid_attach (GTK_GRID (grid), frame, 0, 1, 1, 1); box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); gtk_container_add (GTK_CONTAINER (frame), box); /*--- Button ---*/ button = gtk_check_button_new_with_mnemonic (_("_Delay between rolls")); gtk_box_pack_start (GTK_BOX (box), button, FALSE, FALSE, 0); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), DoDelay); g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (set_as_int), &tmpDoDelay); /*--- Spinner (number of computers) ---*/ OriginalNumberOfComputers = NumberOfComputers; box2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12); gtk_box_pack_start (GTK_BOX (box), box2, FALSE, FALSE, 0); label = gtk_label_new_with_mnemonic (_("N_umber of opponents:")); gtk_box_pack_start (GTK_BOX (box2), label, FALSE, FALSE, 0); ComputerAdj = gtk_adjustment_new ((gfloat) NumberOfComputers, 0.0, 5.0, 1.0, 5.0, 0.0); ComputerSpinner = gtk_spin_button_new (GTK_ADJUSTMENT (ComputerAdj), 10, 0); gtk_label_set_mnemonic_widget (GTK_LABEL (label), ComputerSpinner); g_signal_connect (G_OBJECT (ComputerAdj), "value_changed", G_CALLBACK (MaxPlayersCheck), ComputerAdj); gtk_box_pack_start (GTK_BOX (box2), ComputerSpinner, TRUE, TRUE, 0); box2 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 2); gtk_box_pack_start(GTK_BOX(box), box2, FALSE, FALSE, 0); label = gtk_label_new_with_mnemonic (_("_Difficulty:")); gtk_box_pack_start(GTK_BOX(box2), label, FALSE, FALSE, 0); combo = gtk_combo_box_text_new(); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), C_("difficulty", "Easy")); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), C_("difficulty", "Medium")); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), C_("difficulty", "Hard")); skill_level = 0; while (NUM_TRIALS > skill_level_table[skill_level].trials && skill_level < (SKILL_LEVEL_TABLE_SIZE - 1)) skill_level++; gtk_combo_box_set_active(GTK_COMBO_BOX(combo), skill_level); g_signal_connect (G_OBJECT (combo), "changed", G_CALLBACK (SetSkillLevel), combo); gtk_box_pack_start(GTK_BOX(box2), combo, FALSE, FALSE, 0); /*--- Combo (yahtzee or kismet style ----*/ frame = games_frame_new (_("Game Type")); gtk_grid_attach (GTK_GRID (grid), frame, 0, 2, 1, 1); combo = gtk_combo_box_text_new(); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), C_("game type", "Regular")); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), C_("game type", "Colors")); gtk_combo_box_set_active(GTK_COMBO_BOX(combo), game_type); NewGameType = game_type; g_signal_connect (G_OBJECT (combo), "changed", G_CALLBACK (SetGameType), combo); gtk_container_add (GTK_CONTAINER (frame), combo); /*--- PLAYER NAMES FRAME ----*/ frame = games_frame_new (_("Player Names")); gtk_grid_attach (GTK_GRID (grid), frame, 1, 0, 1, 3); box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); gtk_container_add (GTK_CONTAINER (frame), box); for (i = 0; i < MAX_NUMBER_OF_PLAYERS; i++) { box2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12); gtk_box_pack_start (GTK_BOX (box), box2, FALSE, FALSE, 0); ts = g_strdup_printf ("_%1d:", i + 1); label = gtk_label_new_with_mnemonic (ts); g_free (ts); gtk_box_pack_start (GTK_BOX (box2), label, FALSE, FALSE, 0); PlayerNames[i] = gtk_entry_new (); gtk_label_set_mnemonic_widget (GTK_LABEL (label), PlayerNames[i]); ts = g_strdup_printf ("PlayerName%1d", i + 1); gtk_widget_set_name (PlayerNames[i], ts); g_free (ts); gtk_entry_set_text (GTK_ENTRY (PlayerNames[i]), players[i].name); gtk_box_pack_start (GTK_BOX (box2), PlayerNames[i], FALSE, FALSE, 0); } gtk_widget_show_all (setupdialog); return FALSE; }
static gint mergeit (EContactMergingLookup *lookup) { GtkWidget *scrolled_window, *label, *hbox, *dropdown; GtkWidget *content_area; GtkWidget *dialog; GtkTable *table; EContactField field; gchar *string = NULL, *string1 = NULL; GList *use_email_attr_list, *contact_email_attr_list, *match_email_attr_list; GList *use_tel_attr_list, *contact_tel_attr_list, *match_tel_attr_list; GList *use_im_attr_list, *contact_im_attr_list, *match_im_attr_list; GList *use_sip_attr_list, *contact_sip_attr_list, *match_sip_attr_list; gint row = -1; gint value = 0, result; dialog = gtk_dialog_new (); gtk_window_set_title (GTK_WINDOW (dialog), _("Merge Contact")); gtk_container_set_border_width (GTK_CONTAINER (dialog), 5); content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog)); scrolled_window = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy ( GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); table = (GtkTable *) gtk_table_new (20, 2, FALSE); gtk_container_set_border_width ((GtkContainer *) table, 12); gtk_table_set_row_spacings (table, 6); gtk_table_set_col_spacings (table, 2); gtk_dialog_add_buttons ( GTK_DIALOG (dialog), _("_Cancel"), GTK_RESPONSE_CANCEL, _("_Merge"), GTK_RESPONSE_OK, NULL); /*we match all the string fields of the already existing contact and the new contact.*/ for (field = E_CONTACT_FULL_NAME; field != (E_CONTACT_LAST_SIMPLE_STRING -1); field++) { dropdown_data *data = NULL; string = (gchar *) e_contact_get_const (lookup->contact, field); string1 = (gchar *) e_contact_get_const (lookup->match, field); /*the field must exist in the new as well as the duplicate contact*/ if (string && *string) { if ((field >= E_CONTACT_FIRST_EMAIL_ID && field <= E_CONTACT_LAST_EMAIL_ID) || (field >= E_CONTACT_FIRST_PHONE_ID && field <= E_CONTACT_LAST_PHONE_ID) || (field >= E_CONTACT_IM_AIM_HOME_1 && field <= E_CONTACT_IM_ICQ_WORK_3) ) { /* ignore multival attributes, they are compared after this for-loop */ continue; } if (!(string1 && *string1) || (g_ascii_strcasecmp (string, string1))) { row++; label = gtk_label_new (e_contact_pretty_name (field)); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); gtk_box_pack_start (GTK_BOX (hbox), (GtkWidget *) label, FALSE, FALSE, 0); gtk_table_attach_defaults (table, (GtkWidget *) hbox, 0, 1, row, row + 1); data = g_new0 (dropdown_data, 1); dropdown = gtk_combo_box_text_new (); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (dropdown), string); if (string1 && *string1) gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (dropdown), string1); else gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (dropdown), ""); data->field = field; data->match = lookup->match; g_signal_connect ( dropdown, "changed", G_CALLBACK (dropdown_changed), data); g_object_set_data_full (G_OBJECT (dropdown), "eab-contact-merging::dropdown-data", data, g_free); if (field == E_CONTACT_NICKNAME || field == E_CONTACT_GIVEN_NAME || field == E_CONTACT_FAMILY_NAME || field == E_CONTACT_FULL_NAME) gtk_combo_box_set_active (GTK_COMBO_BOX (dropdown), 1); else gtk_combo_box_set_active (GTK_COMBO_BOX (dropdown), 0); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); gtk_box_pack_start (GTK_BOX (hbox), (GtkWidget *) dropdown, FALSE, FALSE, 0); gtk_table_attach_defaults (table, (GtkWidget *) hbox, 1, 2, row, row + 1); gtk_widget_show_all ((GtkWidget *) dropdown); } } } match_email_attr_list = e_contact_get_attributes (lookup->match, E_CONTACT_EMAIL); contact_email_attr_list = e_contact_get_attributes (lookup->contact, E_CONTACT_EMAIL); use_email_attr_list = NULL; create_dropdowns_for_multival_attr (match_email_attr_list, contact_email_attr_list, &use_email_attr_list, &row, table, _("Email")); match_tel_attr_list = e_contact_get_attributes (lookup->match, E_CONTACT_TEL); contact_tel_attr_list = e_contact_get_attributes (lookup->contact, E_CONTACT_TEL); use_tel_attr_list = NULL; create_dropdowns_for_multival_attr (match_tel_attr_list, contact_tel_attr_list, &use_tel_attr_list, &row, table, _("Phone")); match_sip_attr_list = e_contact_get_attributes (lookup->match, E_CONTACT_SIP); contact_sip_attr_list = e_contact_get_attributes (lookup->contact, E_CONTACT_SIP); use_sip_attr_list = NULL; create_dropdowns_for_multival_attr (match_sip_attr_list, contact_sip_attr_list, &use_sip_attr_list, &row, table, _("SIP")); match_im_attr_list = e_contact_get_attributes_set (lookup->match, im_fetch_set, G_N_ELEMENTS (im_fetch_set)); contact_im_attr_list = e_contact_get_attributes_set (lookup->contact, im_fetch_set, G_N_ELEMENTS (im_fetch_set)); use_im_attr_list = NULL; create_dropdowns_for_multival_attr (match_im_attr_list, contact_im_attr_list, &use_im_attr_list, &row, table, _("IM")); gtk_window_set_default_size (GTK_WINDOW (dialog), 420, 300); gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_window), GTK_WIDGET (table)); gtk_box_pack_start (GTK_BOX (content_area), GTK_WIDGET (scrolled_window), TRUE, TRUE, 0); gtk_widget_show (scrolled_window); g_signal_connect ( dialog, "map-event", G_CALLBACK (dialog_map), table); gtk_widget_show_all ((GtkWidget *) table); result = gtk_dialog_run (GTK_DIALOG (dialog)); switch (result) { gint ii; GList *ll; case GTK_RESPONSE_OK: set_attributes (lookup->match, E_CONTACT_EMAIL, use_email_attr_list); set_attributes (lookup->match, E_CONTACT_TEL, use_tel_attr_list); set_attributes (lookup->match, E_CONTACT_SIP, use_sip_attr_list); for (ii = 0; ii < G_N_ELEMENTS (im_fetch_set); ii++) { e_contact_set_attributes (lookup->match, im_fetch_set[ii], NULL); } for (ll = use_im_attr_list; ll; ll = ll->next) { EVCard *vcard; vcard = E_VCARD (lookup->match); e_vcard_append_attribute (vcard, e_vcard_attribute_copy ((EVCardAttribute *) ll->data)); } g_object_unref (lookup->contact); lookup->contact = g_object_ref (lookup->match); e_book_client_remove_contact ( lookup->book_client, lookup->match, NULL, remove_contact_ready_cb, lookup); value = 1; break; case GTK_RESPONSE_CANCEL: default: value = 0; break; } gtk_widget_destroy (dialog); g_list_free_full (match_email_attr_list, (GDestroyNotify) e_vcard_attribute_free); g_list_free_full (contact_email_attr_list, (GDestroyNotify) e_vcard_attribute_free); g_list_free (use_email_attr_list); g_list_free_full (match_tel_attr_list, (GDestroyNotify) e_vcard_attribute_free); g_list_free_full (contact_tel_attr_list, (GDestroyNotify) e_vcard_attribute_free); g_list_free (use_tel_attr_list); g_list_free_full (match_im_attr_list, (GDestroyNotify) e_vcard_attribute_free); g_list_free_full (contact_im_attr_list, (GDestroyNotify) e_vcard_attribute_free); g_list_free (use_im_attr_list); g_list_free_full (match_sip_attr_list, (GDestroyNotify) e_vcard_attribute_free); g_list_free_full (contact_sip_attr_list, (GDestroyNotify) e_vcard_attribute_free); g_list_free (use_sip_attr_list); return value; }
static void prefs_display_header_create(void) { GtkWidget *window; GtkWidget *vbox; GtkWidget *btn_hbox; GtkWidget *ok_btn; GtkWidget *cancel_btn; GtkWidget *confirm_area; GtkWidget *vbox1; GtkWidget *hbox1; GtkWidget *hdr_label; GtkWidget *hdr_combo; GtkWidget *btn_vbox; GtkWidget *reg_btn; GtkWidget *del_btn; GtkWidget *up_btn; GtkWidget *down_btn; GtkWidget *list_view_hbox; GtkWidget *list_view_hbox1; GtkWidget *list_view_hbox2; GtkWidget *list_view_scrolledwin; GtkWidget *headers_list_view; GtkWidget *hidden_headers_list_view; GtkWidget *checkbtn_other_headers; gint i; debug_print("Creating display header setting window...\n"); window = gtkut_window_new(GTK_WINDOW_TOPLEVEL, "prefs_display_header"); gtk_container_set_border_width (GTK_CONTAINER (window), 8); gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_CENTER); gtk_window_set_resizable(GTK_WINDOW (window), TRUE); vbox = gtk_vbox_new (FALSE, 6); gtk_widget_show (vbox); gtk_container_add (GTK_CONTAINER (window), vbox); btn_hbox = gtk_hbox_new (FALSE, 8); gtk_widget_show (btn_hbox); gtk_box_pack_end (GTK_BOX (vbox), btn_hbox, FALSE, FALSE, 0); gtkut_stock_button_set_create(&confirm_area, &cancel_btn, GTK_STOCK_CANCEL, &ok_btn, GTK_STOCK_OK, NULL, NULL); gtk_widget_show (confirm_area); gtk_box_pack_end (GTK_BOX(btn_hbox), confirm_area, FALSE, FALSE, 0); gtk_widget_grab_default (ok_btn); gtk_window_set_title (GTK_WINDOW(window), _("Displayed header configuration")); MANAGE_WINDOW_SIGNALS_CONNECT(window); g_signal_connect (G_OBJECT(window), "delete_event", G_CALLBACK(prefs_display_header_deleted), NULL); g_signal_connect (G_OBJECT(window), "key_press_event", G_CALLBACK(prefs_display_header_key_pressed), NULL); g_signal_connect (G_OBJECT(ok_btn), "clicked", G_CALLBACK(prefs_display_header_ok), NULL); g_signal_connect (G_OBJECT(cancel_btn), "clicked", G_CALLBACK(prefs_display_header_cancel), NULL); vbox1 = gtk_vbox_new (FALSE, VSPACING); gtk_widget_show (vbox1); gtk_box_pack_start (GTK_BOX (vbox), vbox1, TRUE, TRUE, 0); gtk_container_set_border_width (GTK_CONTAINER (vbox1), 2); hbox1 = gtk_hbox_new (FALSE, 8); gtk_widget_show (hbox1); gtk_box_pack_start (GTK_BOX (vbox1), hbox1, FALSE, TRUE, 0); hdr_label = gtk_label_new (_("Header name")); gtk_widget_show (hdr_label); gtk_box_pack_start (GTK_BOX (hbox1), hdr_label, FALSE, FALSE, 0); hdr_combo = gtk_combo_box_text_new_with_entry(); for(i=0; i < 9 ; i++) gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT (hdr_combo), (*defaults[i] == '-') ? defaults[i]+1 : defaults[i]); gtk_combo_box_set_active(GTK_COMBO_BOX(hdr_combo), 0); gtk_widget_show (hdr_combo); gtk_box_pack_start (GTK_BOX (hbox1), hdr_combo, TRUE, TRUE, 0); gtk_widget_set_size_request (hdr_combo, 150, -1); list_view_hbox = gtk_hbox_new (FALSE, 10); gtk_widget_show (list_view_hbox); gtk_box_pack_start (GTK_BOX (vbox1), list_view_hbox, TRUE, TRUE, 0); /* display headers list */ list_view_hbox1 = gtk_hbox_new (FALSE, 8); gtk_widget_show (list_view_hbox1); gtk_box_pack_start (GTK_BOX (list_view_hbox), list_view_hbox1, TRUE, TRUE, 0); list_view_scrolledwin = gtk_scrolled_window_new (NULL, NULL); gtk_widget_set_size_request (list_view_scrolledwin, 200, 210); gtk_widget_show (list_view_scrolledwin); gtk_box_pack_start (GTK_BOX (list_view_hbox1), list_view_scrolledwin, TRUE, TRUE, 0); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (list_view_scrolledwin), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(list_view_scrolledwin), GTK_SHADOW_IN); headers_list_view = prefs_display_header_list_view_create (_("Displayed Headers")); gtk_widget_show (headers_list_view); gtk_container_add(GTK_CONTAINER(list_view_scrolledwin), headers_list_view); gtk_tree_view_set_reorderable(GTK_TREE_VIEW(headers_list_view), TRUE); g_signal_connect(G_OBJECT(headers_list_view), "drag_end", G_CALLBACK(drag_end), headers_list_view); /* connect rows change for this list view's model */ g_signal_connect(G_OBJECT(gtk_tree_view_get_model(GTK_TREE_VIEW(headers_list_view))), "rows-reordered", G_CALLBACK(headers_list_model_rows_reordered), headers_list_view); btn_vbox = gtk_vbox_new (FALSE, 8); gtk_widget_show (btn_vbox); gtk_box_pack_start (GTK_BOX (list_view_hbox1), btn_vbox, FALSE, FALSE, 0); reg_btn = gtk_button_new_from_stock (GTK_STOCK_ADD); gtk_widget_show (reg_btn); gtk_box_pack_start (GTK_BOX (btn_vbox), reg_btn, FALSE, TRUE, 0); g_signal_connect (G_OBJECT (reg_btn), "clicked", G_CALLBACK (prefs_display_header_register_cb), GINT_TO_POINTER(FALSE)); del_btn = gtk_button_new_from_stock (GTK_STOCK_REMOVE); gtk_widget_show (del_btn); gtk_box_pack_start (GTK_BOX (btn_vbox), del_btn, FALSE, TRUE, 0); g_signal_connect (G_OBJECT (del_btn), "clicked", G_CALLBACK (prefs_display_header_delete_cb), headers_list_view); up_btn = gtk_button_new_from_stock (GTK_STOCK_GO_UP); gtk_widget_show (up_btn); gtk_box_pack_start (GTK_BOX (btn_vbox), up_btn, FALSE, FALSE, 0); g_signal_connect (G_OBJECT (up_btn), "clicked", G_CALLBACK (prefs_display_header_up), NULL); down_btn = gtk_button_new_from_stock (GTK_STOCK_GO_DOWN); gtk_widget_show (down_btn); gtk_box_pack_start (GTK_BOX (btn_vbox), down_btn, FALSE, FALSE, 0); g_signal_connect (G_OBJECT (down_btn), "clicked", G_CALLBACK (prefs_display_header_down), NULL); /* hidden headers list */ list_view_hbox2 = gtk_hbox_new (FALSE, 8); gtk_widget_show (list_view_hbox2); gtk_box_pack_start (GTK_BOX (list_view_hbox), list_view_hbox2, TRUE, TRUE, 0); list_view_scrolledwin = gtk_scrolled_window_new (NULL, NULL); gtk_widget_set_size_request (list_view_scrolledwin, 200, 210); gtk_widget_show (list_view_scrolledwin); gtk_box_pack_start (GTK_BOX (list_view_hbox2), list_view_scrolledwin, TRUE, TRUE, 0); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (list_view_scrolledwin), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(list_view_scrolledwin), GTK_SHADOW_IN); hidden_headers_list_view = prefs_display_header_list_view_create (_("Hidden headers")); gtk_widget_show (hidden_headers_list_view); gtk_container_add (GTK_CONTAINER (list_view_scrolledwin), hidden_headers_list_view); btn_vbox = gtk_vbox_new (FALSE, 8); gtk_widget_show (btn_vbox); gtk_box_pack_start (GTK_BOX (list_view_hbox2), btn_vbox, FALSE, FALSE, 0); reg_btn = gtk_button_new_from_stock (GTK_STOCK_ADD); gtk_widget_show (reg_btn); gtk_box_pack_start (GTK_BOX (btn_vbox), reg_btn, FALSE, TRUE, 0); g_signal_connect (G_OBJECT (reg_btn), "clicked", G_CALLBACK (prefs_display_header_register_cb), GINT_TO_POINTER(TRUE)); del_btn = gtk_button_new_from_stock (GTK_STOCK_DELETE); gtk_widget_show (del_btn); gtk_box_pack_start (GTK_BOX (btn_vbox), del_btn, FALSE, TRUE, 0); g_signal_connect (G_OBJECT (del_btn), "clicked", G_CALLBACK (prefs_display_header_delete_cb), hidden_headers_list_view); PACK_CHECK_BUTTON (vbox, checkbtn_other_headers, _("Show all unspecified headers")); SET_TOGGLE_SENSITIVITY (checkbtn_other_headers, list_view_hbox2); gtk_widget_show_all(window); dispheader.window = window; dispheader.ok_btn = ok_btn; dispheader.cancel_btn = cancel_btn; dispheader.hdr_combo = hdr_combo; dispheader.headers_list_view = headers_list_view; dispheader.hidden_headers_list_view = hidden_headers_list_view; dispheader.other_headers = checkbtn_other_headers; }
void gui_init(dt_lib_module_t *self) { /* initialize ui widgets */ dt_lib_tool_filter_t *d = (dt_lib_tool_filter_t *)g_malloc0(sizeof(dt_lib_tool_filter_t)); self->data = (void *)d; self->widget = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 2); /**/ GtkWidget *widget; /* list label */ widget = gtk_label_new(_("view")); gtk_box_pack_start(GTK_BOX(self->widget), widget, FALSE, FALSE, 4); d->comparator = widget = gtk_toggle_button_new_with_label(comparators[dt_collection_get_rating_comparator(darktable.collection)]); gtk_box_pack_start(GTK_BOX(self->widget), widget, FALSE, FALSE, 4); g_signal_connect(G_OBJECT(widget), "toggled", G_CALLBACK(_lib_filter_compare_button_changed), (gpointer)self); gtk_widget_add_events(widget, GDK_SCROLL_MASK); g_signal_connect(G_OBJECT(widget), "scroll-event", G_CALLBACK(_comparator_scolled), self); /* create the filter combobox */ d->filter = widget = gtk_combo_box_text_new(); gtk_box_pack_start(GTK_BOX(self->widget), widget, FALSE, FALSE, 0); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(widget), _("all")); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(widget), _("unstarred only")); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(widget), "★"); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(widget), "★ ★"); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(widget), "★ ★ ★"); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(widget), "★ ★ ★ ★"); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(widget), "★ ★ ★ ★ ★"); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(widget), _("rejected only")); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(widget), _("all except rejected")); /* select the last selected value */ gtk_combo_box_set_active(GTK_COMBO_BOX(widget), dt_collection_get_rating(darktable.collection)); g_signal_connect(G_OBJECT(widget), "changed", G_CALLBACK(_lib_filter_combobox_changed), (gpointer)self); /* sort by label */ widget = gtk_label_new(_("sort by")); gtk_box_pack_start(GTK_BOX(self->widget), widget, FALSE, FALSE, 4); /* sort combobox */ d->sort = widget = gtk_combo_box_text_new(); gtk_box_pack_start(GTK_BOX(self->widget), widget, FALSE, FALSE, 0); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(widget), _("filename")); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(widget), _("time")); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(widget), _("rating")); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(widget), _("id")); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(widget), _("color label")); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(widget), _("group")); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(widget), _("full path")); /* select the last selected value */ gtk_combo_box_set_active(GTK_COMBO_BOX(widget), dt_collection_get_sort_field(darktable.collection)); g_signal_connect(G_OBJECT(widget), "changed", G_CALLBACK(_lib_filter_sort_combobox_changed), (gpointer)self); /* reverse order checkbutton */ d->reverse = widget = dtgtk_togglebutton_new(dtgtk_cairo_paint_solid_arrow, CPF_DO_NOT_USE_BORDER | CPF_STYLE_BOX | CPF_DIRECTION_UP); if(darktable.collection->params.descending) dtgtk_togglebutton_set_paint(DTGTK_TOGGLEBUTTON(widget), dtgtk_cairo_paint_solid_arrow, CPF_DO_NOT_USE_BORDER | CPF_STYLE_BOX | CPF_DIRECTION_DOWN); gtk_box_pack_start(GTK_BOX(self->widget), widget, FALSE, FALSE, 0); /* select the last value and connect callback */ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget), dt_collection_get_sort_descending(darktable.collection)); g_signal_connect(G_OBJECT(widget), "toggled", G_CALLBACK(_lib_filter_reverse_button_changed), (gpointer)self); /* initialize proxy */ darktable.view_manager->proxy.filter.module = self; darktable.view_manager->proxy.filter.reset_filter = _lib_filter_reset; g_signal_connect_swapped(G_OBJECT(d->comparator), "map", G_CALLBACK(_lib_filter_sync_combobox_and_comparator), self); }
static GtkWidget * gth_file_tool_resize_get_options (GthFileTool *base) { GthFileToolResize *self = (GthFileToolResize *) base; cairo_surface_t *source; GtkWidget *window; GtkWidget *viewer_page; GtkWidget *viewer; GtkAllocation allocation; int preview_width; int preview_height; GtkWidget *options; char *text; source = gth_image_viewer_page_tool_get_source (GTH_IMAGE_VIEWER_PAGE_TOOL (self)); if (source == NULL) return NULL; self->priv->original_width = cairo_image_surface_get_width (source); self->priv->original_height = cairo_image_surface_get_height (source); window = gth_file_tool_get_window (base); viewer_page = gth_browser_get_viewer_page (GTH_BROWSER (window)); viewer = gth_image_viewer_page_get_image_viewer (GTH_IMAGE_VIEWER_PAGE (viewer_page)); gtk_widget_get_allocation (GTK_WIDGET (viewer), &allocation); preview_width = self->priv->original_width; preview_height = self->priv->original_height; if (scale_keeping_ratio (&preview_width, &preview_height, allocation.width, allocation.height, FALSE)) self->priv->preview = _cairo_image_surface_scale_fast (source, preview_width, preview_height); else self->priv->preview = cairo_surface_reference (source); _gtk_widget_get_screen_size (window, &self->priv->screen_width, &self->priv->screen_height); self->priv->new_image = NULL; self->priv->new_width = self->priv->original_width; self->priv->new_height = self->priv->original_height; self->priv->high_quality = g_settings_get_boolean (self->priv->settings, PREF_RESIZE_HIGH_QUALITY); self->priv->unit = g_settings_get_enum (self->priv->settings, PREF_RESIZE_UNIT); self->priv->builder = _gtk_builder_new_from_file ("resize-options.ui", "file_tools"); self->priv->apply_to_original = FALSE; update_dimensione_info_label (self, "original_dimensions_label", self->priv->original_width, self->priv->original_height, TRUE); options = _gtk_builder_get_widget (self->priv->builder, "options"); gtk_widget_show (options); if (self->priv->unit == GTH_UNIT_PIXELS) { gtk_spin_button_set_digits (GTK_SPIN_BUTTON (GET_WIDGET ("resize_width_spinbutton")), 0); gtk_spin_button_set_digits (GTK_SPIN_BUTTON (GET_WIDGET ("resize_height_spinbutton")), 0); gtk_spin_button_set_value (GTK_SPIN_BUTTON (GET_WIDGET ("resize_width_spinbutton")), g_settings_get_double (self->priv->settings, PREF_RESIZE_WIDTH)); gtk_spin_button_set_value (GTK_SPIN_BUTTON (GET_WIDGET ("resize_height_spinbutton")), g_settings_get_double (self->priv->settings, PREF_RESIZE_HEIGHT)); } else if (self->priv->unit == GTH_UNIT_PERCENTAGE) { gtk_spin_button_set_digits (GTK_SPIN_BUTTON (GET_WIDGET ("resize_width_spinbutton")), 2); gtk_spin_button_set_digits (GTK_SPIN_BUTTON (GET_WIDGET ("resize_height_spinbutton")), 2); gtk_spin_button_set_value (GTK_SPIN_BUTTON (GET_WIDGET ("resize_width_spinbutton")), g_settings_get_double (self->priv->settings, PREF_RESIZE_WIDTH)); gtk_spin_button_set_value (GTK_SPIN_BUTTON (GET_WIDGET ("resize_height_spinbutton")), g_settings_get_double (self->priv->settings, PREF_RESIZE_HEIGHT)); } gtk_combo_box_set_active (GTK_COMBO_BOX (GET_WIDGET ("unit_combobox")), self->priv->unit); self->priv->ratio_combobox = _gtk_combo_box_new_with_texts (_("None"), _("Square"), NULL); text = g_strdup_printf (_("%d x %d (Image)"), self->priv->original_width, self->priv->original_height); gtk_label_set_text (GTK_LABEL (GET_WIDGET ("image_size_label")), text); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (self->priv->ratio_combobox), text); g_free (text); text = g_strdup_printf (_("%d x %d (Screen)"), self->priv->screen_width, self->priv->screen_height); gtk_label_set_text (GTK_LABEL (GET_WIDGET ("screen_size_label")), text); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (self->priv->ratio_combobox), text); g_free (text); _gtk_combo_box_append_texts (GTK_COMBO_BOX_TEXT (self->priv->ratio_combobox), _("5:4"), _("4:3 (DVD, Book)"), _("7:5"), _("3:2 (Postcard)"), _("16:10"), _("16:9 (DVD)"), _("1.85:1"), _("2.39:1"), _("Custom"), NULL); gtk_widget_show (self->priv->ratio_combobox); gtk_box_pack_start (GTK_BOX (GET_WIDGET ("ratio_combobox_box")), self->priv->ratio_combobox, TRUE, TRUE, 0); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (GET_WIDGET ("high_quality_checkbutton")), self->priv->high_quality); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (GET_WIDGET ("invert_ratio_checkbutton")), g_settings_get_boolean (self->priv->settings, PREF_RESIZE_ASPECT_RATIO_INVERT)); gtk_spin_button_set_value (GTK_SPIN_BUTTON (GET_WIDGET ("ratio_w_spinbutton")), MAX (g_settings_get_int (self->priv->settings, PREF_RESIZE_ASPECT_RATIO_WIDTH), 1)); gtk_spin_button_set_value (GTK_SPIN_BUTTON (GET_WIDGET ("ratio_h_spinbutton")), MAX (g_settings_get_int (self->priv->settings, PREF_RESIZE_ASPECT_RATIO_HEIGHT), 1)); g_signal_connect_swapped (GET_WIDGET ("options_close_button"), "clicked", G_CALLBACK (gtk_widget_hide), GET_WIDGET ("options_dialog")); g_signal_connect (GET_WIDGET ("options_dialog"), "delete-event", G_CALLBACK (gtk_widget_hide_on_delete), NULL); g_signal_connect (GET_WIDGET ("resize_width_spinbutton"), "value-changed", G_CALLBACK (selection_width_value_changed_cb), self); g_signal_connect (GET_WIDGET ("resize_height_spinbutton"), "value-changed", G_CALLBACK (selection_height_value_changed_cb), self); g_signal_connect (GET_WIDGET ("high_quality_checkbutton"), "toggled", G_CALLBACK (high_quality_checkbutton_toggled_cb), self); g_signal_connect (GET_WIDGET ("unit_combobox"), "changed", G_CALLBACK (unit_combobox_changed_cb), self); g_signal_connect (self->priv->ratio_combobox, "changed", G_CALLBACK (ratio_combobox_changed_cb), self); g_signal_connect (GET_WIDGET ("ratio_w_spinbutton"), "value_changed", G_CALLBACK (ratio_value_changed_cb), self); g_signal_connect (GET_WIDGET ("ratio_h_spinbutton"), "value_changed", G_CALLBACK (ratio_value_changed_cb), self); g_signal_connect (GET_WIDGET ("invert_ratio_checkbutton"), "toggled", G_CALLBACK (invert_ratio_changed_cb), self); g_signal_connect (GET_WIDGET ("image_size_button"), "clicked", G_CALLBACK (image_size_button_clicked_cb), self); g_signal_connect (GET_WIDGET ("screen_size_button"), "clicked", G_CALLBACK (screen_size_button_clicked_cb), self); gtk_combo_box_set_active (GTK_COMBO_BOX (self->priv->ratio_combobox), g_settings_get_enum (self->priv->settings, PREF_RESIZE_ASPECT_RATIO)); gth_image_viewer_set_zoom_quality (GTH_IMAGE_VIEWER (viewer), GTH_ZOOM_QUALITY_HIGH); return options; }
GtkWidget * stream_prefs_show(void) { GtkWidget *main_vb, *main_tb, *label, *combo_box; GtkWidget *sample, *colorsel; int width, height, i; const gchar *mt[] = { "Marked packet foreground", /* MFG_IDX 0*/ "Marked packet background", /* MBG_IDX 1*/ "Ignored packet foreground", /* IFG_IDX 2*/ "Ignored packet background", /* IBG_IDX 3*/ "TCP stream client foreground", /* CFG_IDX 4*/ "TCP stream client background", /* CBG_IDX 5*/ "TCP stream server foreground", /* SFG_IDX 6*/ "TCP stream server background" /* SBG_IDX 7*/ }; int mcount = sizeof(mt) / sizeof (gchar *); GtkTextBuffer *buf; GtkTextIter iter; PangoLayout *layout; color_t_to_gdkcolor(&tcolors[MFG_IDX], &prefs.gui_marked_fg); color_t_to_gdkcolor(&tcolors[MBG_IDX], &prefs.gui_marked_bg); color_t_to_gdkcolor(&tcolors[IFG_IDX], &prefs.gui_ignored_fg); color_t_to_gdkcolor(&tcolors[IBG_IDX], &prefs.gui_ignored_bg); color_t_to_gdkcolor(&tcolors[CFG_IDX], &prefs.st_client_fg); color_t_to_gdkcolor(&tcolors[CBG_IDX], &prefs.st_client_bg); color_t_to_gdkcolor(&tcolors[SFG_IDX], &prefs.st_server_fg); color_t_to_gdkcolor(&tcolors[SBG_IDX], &prefs.st_server_bg); curcolor = &tcolors[CFG_IDX]; /* Enclosing containers for each row of widgets */ main_vb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 5, FALSE); gtk_container_set_border_width(GTK_CONTAINER(main_vb), 5); main_tb = gtk_table_new(3, 3, FALSE); gtk_box_pack_start(GTK_BOX(main_vb), main_tb, FALSE, FALSE, 0); gtk_table_set_row_spacings(GTK_TABLE(main_tb), 10); gtk_table_set_col_spacings(GTK_TABLE(main_tb), 15); gtk_widget_show(main_tb); label = gtk_label_new("Set:"); gtk_misc_set_alignment(GTK_MISC(label), 1.0f, 0.5f); gtk_table_attach_defaults(GTK_TABLE(main_tb), label, 0, 1, 0, 1); gtk_widget_show(label); /* We have to create this now, and configure it below. */ colorsel = gtk_color_selection_new(); combo_box = gtk_combo_box_text_new(); for (i = 0; i < mcount; i++){ gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo_box), mt[i]); } gtk_combo_box_set_active(GTK_COMBO_BOX(combo_box), CFG_IDX); g_signal_connect(combo_box, "changed", G_CALLBACK(update_current_color), colorsel); gtk_table_attach(GTK_TABLE(main_tb), combo_box, 1, 2, 0, 1, GTK_SHRINK, GTK_SHRINK, 0, 0); gtk_widget_show(combo_box); sample = gtk_text_view_new(); layout = gtk_widget_create_pango_layout(sample, SAMPLE_SERVER_TEXT); pango_layout_get_pixel_size(layout, &width, &height); g_object_unref(G_OBJECT(layout)); gtk_widget_set_size_request(sample, width, height * 2); gtk_text_view_set_editable(GTK_TEXT_VIEW(sample), FALSE); buf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(sample)); gtk_text_buffer_get_start_iter(buf, &iter); gtk_text_buffer_create_tag(buf, "marked", "foreground-gdk", &tcolors[MFG_IDX], "background-gdk", &tcolors[MBG_IDX], NULL); gtk_text_buffer_create_tag(buf, "ignored", "foreground-gdk", &tcolors[IFG_IDX], "background-gdk", &tcolors[IBG_IDX], NULL); gtk_text_buffer_create_tag(buf, "client", "foreground-gdk", &tcolors[CFG_IDX], "background-gdk", &tcolors[CBG_IDX], NULL); gtk_text_buffer_create_tag(buf, "server", "foreground-gdk", &tcolors[SFG_IDX], "background-gdk", &tcolors[SBG_IDX], NULL); gtk_text_buffer_insert_with_tags_by_name(buf, &iter, SAMPLE_MARKED_TEXT, -1, "marked", NULL); gtk_text_buffer_insert_with_tags_by_name(buf, &iter, SAMPLE_IGNORED_TEXT, -1, "ignored", NULL); gtk_text_buffer_insert_with_tags_by_name(buf, &iter, SAMPLE_CLIENT_TEXT, -1, "client", NULL); gtk_text_buffer_insert_with_tags_by_name(buf, &iter, SAMPLE_SERVER_TEXT, -1, "server", NULL); gtk_table_attach_defaults(GTK_TABLE(main_tb), sample, 2, 3, 0, 2); gtk_widget_show(sample); gtk_color_selection_set_current_color(GTK_COLOR_SELECTION(colorsel), curcolor); gtk_table_attach(GTK_TABLE(main_tb), colorsel, 0, 3, 2, 3, GTK_SHRINK, GTK_SHRINK, 0, 0); g_object_set_data(G_OBJECT(colorsel), STREAM_SAMPLE_KEY, sample); g_signal_connect(colorsel, "color-changed", G_CALLBACK(update_text_color), NULL); gtk_widget_show(colorsel); gtk_widget_show(main_vb); return(main_vb); }
static void simple_cell_area (void) { GtkWidget *window, *widget; GtkWidget *iconview, *frame, *vbox, *hbox; window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (window), "CellArea expand and alignments"); iconview = simple_iconview (); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4); frame = gtk_frame_new (NULL); gtk_widget_show (hbox); gtk_widget_show (frame); gtk_widget_set_valign (frame, GTK_ALIGN_CENTER); gtk_widget_set_halign (frame, GTK_ALIGN_FILL); gtk_container_add (GTK_CONTAINER (frame), iconview); gtk_box_pack_end (GTK_BOX (hbox), frame, TRUE, TRUE); /* Now add some controls */ vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 4); gtk_widget_show (vbox); gtk_box_pack_end (GTK_BOX (hbox), vbox, FALSE, FALSE); widget = gtk_combo_box_text_new (); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Horizontal"); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Vertical"); gtk_combo_box_set_active (GTK_COMBO_BOX (widget), 0); gtk_widget_show (widget); gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE); g_signal_connect (G_OBJECT (widget), "changed", G_CALLBACK (orientation_changed), iconview); widget = gtk_check_button_new_with_label ("Align 2nd Cell"); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), FALSE); gtk_widget_show (widget); gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE); g_signal_connect (G_OBJECT (widget), "toggled", G_CALLBACK (align_cell_2_toggled), iconview); widget = gtk_check_button_new_with_label ("Align 3rd Cell"); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), TRUE); gtk_widget_show (widget); gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE); g_signal_connect (G_OBJECT (widget), "toggled", G_CALLBACK (align_cell_3_toggled), iconview); widget = gtk_check_button_new_with_label ("Expand 1st Cell"); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), FALSE); gtk_widget_show (widget); gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE); g_signal_connect (G_OBJECT (widget), "toggled", G_CALLBACK (expand_cell_1_toggled), iconview); widget = gtk_check_button_new_with_label ("Expand 2nd Cell"); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), TRUE); gtk_widget_show (widget); gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE); g_signal_connect (G_OBJECT (widget), "toggled", G_CALLBACK (expand_cell_2_toggled), iconview); widget = gtk_check_button_new_with_label ("Expand 3rd Cell"); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), FALSE); gtk_widget_show (widget); gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE); g_signal_connect (G_OBJECT (widget), "toggled", G_CALLBACK (expand_cell_3_toggled), iconview); gtk_container_add (GTK_CONTAINER (window), hbox); gtk_widget_show (window); }
static void dlg_photo_importer (GthBrowser *browser, GFile *source, DlgImporterSourceType selector_type) { DialogData *data; GtkCellRenderer *renderer; GthFileDataSort *sort_type; GList *tests, *scan; char *general_filter; int i, active_filter; int i_general; if (gth_browser_get_dialog (browser, "photo_importer") != NULL) { gtk_window_present (GTK_WINDOW (gth_browser_get_dialog (browser, "photo_importer"))); return; } data = g_new0 (DialogData, 1); data->browser = browser; data->builder = gtk_builder_new_from_resource ("/org/gnome/gThumb/photo_importer/data/ui/photo-importer.ui"); data->settings = g_settings_new (GTHUMB_PHOTO_IMPORTER_SCHEMA); data->selector_type = selector_type; data->source = _g_object_ref (source); data->cancellable = g_cancellable_new (); data->vfs_source = g_object_new (GTH_TYPE_FILE_SOURCE_VFS, NULL); gth_file_source_monitor_entry_points (GTH_FILE_SOURCE (data->vfs_source)); /* Get the widgets. */ data->dialog = _gtk_builder_get_widget (data->builder, "photo_importer_dialog"); _gtk_window_resize_to_fit_screen_height (data->dialog, 580); gth_browser_set_dialog (browser, "photo_importer", data->dialog); g_object_set_data (G_OBJECT (data->dialog), "dialog_data", data); if (data->selector_type == DLG_IMPORTER_SOURCE_TYPE_DEVICE) { gtk_window_set_title (GTK_WINDOW (data->dialog), _("Import from Removable Device")); data->device_list_store = gtk_list_store_new (SOURCE_LIST_COLUMNS, G_TYPE_OBJECT, G_TYPE_ICON, G_TYPE_STRING); data->device_chooser = gtk_combo_box_new_with_model (GTK_TREE_MODEL (data->device_list_store)); gtk_widget_show (data->device_chooser); gtk_box_pack_start (GTK_BOX (GET_WIDGET ("source_box")), data->device_chooser, TRUE, TRUE, 0); gtk_label_set_mnemonic_widget (GTK_LABEL (GET_WIDGET ("source_label")), data->device_chooser); renderer = gtk_cell_renderer_pixbuf_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (data->device_chooser), renderer, FALSE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (data->device_chooser), renderer, "gicon", SOURCE_LIST_COLUMN_ICON, NULL); renderer = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (data->device_chooser), renderer, TRUE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (data->device_chooser), renderer, "text", SOURCE_LIST_COLUMN_NAME, NULL); g_object_unref (data->device_list_store); } else { if (data->source == NULL) { if (GTH_IS_FILE_SOURCE_VFS (gth_browser_get_location_source (browser))) data->source = _g_object_ref (gth_browser_get_location (browser)); if (data->source == NULL) data->source = g_file_new_for_uri (get_home_uri ()); } gtk_window_set_title (GTK_WINDOW (data->dialog), _("Import from Folder")); data->folder_chooser = gtk_file_chooser_button_new (_("Choose a folder"), GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER); gtk_label_set_mnemonic_widget (GTK_LABEL (GET_WIDGET ("source_label")), data->folder_chooser); gtk_file_chooser_set_file (GTK_FILE_CHOOSER (data->folder_chooser), data->source, NULL); gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (data->folder_chooser), FALSE); gtk_widget_show (data->folder_chooser); gtk_box_pack_start (GTK_BOX (GET_WIDGET ("source_box")), data->folder_chooser, TRUE, TRUE, 0); } data->file_list = gth_file_list_new (gth_grid_view_new (), GTH_FILE_LIST_MODE_NORMAL, FALSE); sort_type = gth_main_get_sort_type ("file::mtime"); gth_file_list_set_sort_func (GTH_FILE_LIST (data->file_list), sort_type->cmp_func, FALSE); gth_file_list_enable_thumbs (GTH_FILE_LIST (data->file_list), TRUE); gth_file_list_set_ignore_hidden (GTH_FILE_LIST (data->file_list), TRUE); gth_file_list_set_thumb_size (GTH_FILE_LIST (data->file_list), 128); gth_file_list_set_caption (GTH_FILE_LIST (data->file_list), "standard::display-name,gth::file::display-size"); gtk_widget_show (data->file_list); gtk_box_pack_start (GTK_BOX (GET_WIDGET ("filelist_box")), data->file_list, TRUE, TRUE, 0); tests = gth_main_get_registered_objects_id (GTH_TYPE_TEST); general_filter = "file::type::is_media"; /* default value */ active_filter = 0; data->filter_combobox = gtk_combo_box_text_new (); for (i = 0, i_general = -1, scan = tests; scan; scan = scan->next, i++) { const char *registered_test_id = scan->data; GthTest *test; if (strncmp (registered_test_id, "file::type::", 12) != 0) continue; i_general += 1; test = gth_main_get_registered_object (GTH_TYPE_TEST, registered_test_id); if (strcmp (registered_test_id, general_filter) == 0) { active_filter = i_general; gth_file_list_set_filter (GTH_FILE_LIST (data->file_list), test); } data->general_tests = g_list_prepend (data->general_tests, g_strdup (gth_test_get_id (test))); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (data->filter_combobox), gth_test_get_display_name (test)); g_object_unref (test); } data->general_tests = g_list_reverse (data->general_tests); gtk_combo_box_set_active (GTK_COMBO_BOX (data->filter_combobox), active_filter); gtk_widget_show (data->filter_combobox); gtk_container_add (GTK_CONTAINER (GET_WIDGET ("filter_box")), data->filter_combobox); gtk_label_set_mnemonic_widget (GTK_LABEL (GET_WIDGET ("filter_label")), data->filter_combobox); gtk_label_set_use_underline (GTK_LABEL (GET_WIDGET ("filter_label")), TRUE); _g_string_list_free (tests); data->tags_entry = gth_tags_entry_new (GTH_TAGS_ENTRY_MODE_POPUP); gtk_widget_show (data->tags_entry); gtk_box_pack_start (GTK_BOX (GET_WIDGET ("tags_entry_box")), data->tags_entry, TRUE, TRUE, 0); gtk_label_set_mnemonic_widget (GTK_LABEL (GET_WIDGET ("tags_label")), data->tags_entry); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (GET_WIDGET ("delete_checkbutton")), g_settings_get_boolean (data->settings, PREF_PHOTO_IMPORTER_DELETE_FROM_DEVICE)); data->preferences_dialog = gth_import_preferences_dialog_new (); gtk_window_set_transient_for (GTK_WINDOW (data->preferences_dialog), GTK_WINDOW (data->dialog)); gtk_box_pack_start (GTK_BOX (GET_WIDGET ("destination_button_box")), gth_import_destination_button_new (GTH_IMPORT_PREFERENCES_DIALOG (data->preferences_dialog)), TRUE, TRUE, 0); gtk_widget_show_all (GET_WIDGET ("destination_button_box")); /* Set the signals handlers. */ g_signal_connect (G_OBJECT (data->dialog), "delete-event", G_CALLBACK (dialog_delete_event_cb), data); g_signal_connect (GET_WIDGET ("ok_button"), "clicked", G_CALLBACK (ok_clicked_cb), data); g_signal_connect (GET_WIDGET ("cancel_button"), "clicked", G_CALLBACK (close_dialog), data); if (data->selector_type == DLG_IMPORTER_SOURCE_TYPE_DEVICE) g_signal_connect (data->device_chooser, "changed", G_CALLBACK (device_chooser_changed_cb), data); else g_signal_connect (data->folder_chooser, "selection-changed", G_CALLBACK (folder_chooser_file_set_cb), data); g_signal_connect (data->filter_combobox, "changed", G_CALLBACK (filter_combobox_changed_cb), data); g_signal_connect (gth_file_view_get_model (GTH_FILE_VIEW (gth_file_list_get_view (GTH_FILE_LIST (data->file_list)))), "visibility_changed", G_CALLBACK (file_store_changed_cb), data); g_signal_connect (gth_file_list_get_view (GTH_FILE_LIST (data->file_list)), "file-selection-changed", G_CALLBACK (file_view_selection_changed_cb), data); data->entry_points_changed_id = g_signal_connect (gth_main_get_default_monitor (), "entry-points-changed", G_CALLBACK (entry_points_changed_cb), data); g_signal_connect_after (GET_WIDGET ("event_entry"), "changed", G_CALLBACK (event_entry_changed_cb), data); /* Run dialog. */ gtk_window_set_transient_for (GTK_WINDOW (data->dialog), GTK_WINDOW (browser)); gtk_window_set_modal (GTK_WINDOW (data->dialog), FALSE); gtk_widget_show (data->dialog); gth_import_preferences_dialog_set_event (GTH_IMPORT_PREFERENCES_DIALOG (data->preferences_dialog), gtk_entry_get_text (GTK_ENTRY (GET_WIDGET ("event_entry")))); if (data->selector_type == DLG_IMPORTER_SOURCE_TYPE_DEVICE) update_device_source_list (data); else load_file_list (data); }
void initGUI(int argc, char *argv[]) { gtk_init (&argc, &argv); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_default_size(GTK_WINDOW (window), WINDOW_WIDTH, WINDOW_HEIGHT); gtk_window_set_title (GTK_WINDOW (window), "EECE 412 VPN"); g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL); vBox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 1); clientServerModeHBox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 1); messageHBox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 1); serverDetailsHBox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 1); continueButtonsHBox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 1); modeLabel = gtk_label_new("Mode:"); modeComboBox = gtk_combo_box_text_new(); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(modeComboBox), "Client"); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(modeComboBox), "Server"); gtk_combo_box_set_active(GTK_COMBO_BOX(modeComboBox), 0); messageLabel = gtk_label_new("Message:"); messageEntry = gtk_entry_new(); serverName = gtk_entry_new(); gtk_entry_set_text(GTK_ENTRY(serverName), "127.0.0.1"); gtk_entry_set_max_length(GTK_ENTRY(serverName), 15); serverNameLabel = gtk_label_new("Server name:"); serverStatusButton = gtk_toggle_button_new_with_label("Start!"); clientStatusButton = gtk_toggle_button_new_with_label("Connect!"); portNumber = gtk_entry_new(); gtk_entry_set_text(GTK_ENTRY(portNumber), "12000"); gtk_entry_set_max_length(GTK_ENTRY(portNumber), 5); portNumberLabel = gtk_label_new("Port:"); sharedKey = gtk_entry_new(); gtk_entry_set_text(GTK_ENTRY(sharedKey), "SHAREDKEY"); sharedKeyLabel = gtk_label_new("Shared key:"); messageSendButton = gtk_button_new_with_label("Send"); continueButton = gtk_button_new_with_label("Continue"); autoContinueButton = gtk_toggle_button_new_with_label("Auto Continue"); scrolledAuthenticationWindow = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW(scrolledAuthenticationWindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_min_content_height (GTK_SCROLLED_WINDOW(scrolledAuthenticationWindow), 200); scrolledEncryptedTextWindow = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW(scrolledEncryptedTextWindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_min_content_height (GTK_SCROLLED_WINDOW(scrolledEncryptedTextWindow), 200); scrolledPlaintextWindow = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW(scrolledPlaintextWindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_min_content_height (GTK_SCROLLED_WINDOW(scrolledPlaintextWindow), 200); authenticationTextLog = gtk_text_view_new(); gtk_text_view_set_editable(GTK_TEXT_VIEW(authenticationTextLog), FALSE); gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(authenticationTextLog), FALSE); authenticationTextLogLabel = gtk_label_new("Authentication text:"); encryptedTextLog = gtk_text_view_new(); gtk_text_view_set_editable(GTK_TEXT_VIEW(encryptedTextLog), FALSE); gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(encryptedTextLog), FALSE); encryptedTextLogLabel = gtk_label_new("Encrypted text:"); plainTextLog = gtk_text_view_new(); gtk_text_view_set_editable(GTK_TEXT_VIEW(plainTextLog), FALSE); gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(plainTextLog), FALSE); plainTextLogLabel = gtk_label_new("Plain text:"); // SIGNALS g_signal_connect (modeComboBox, "changed", G_CALLBACK(onModeChanged), NULL); g_signal_connect (messageSendButton, "clicked", G_CALLBACK(onSendButtonClicked), NULL); g_signal_connect(serverStatusButton, "toggled", G_CALLBACK(onServerStatusChanged), NULL); g_signal_connect(clientStatusButton, "toggled", G_CALLBACK(onClientStatusChanged), NULL); g_signal_connect(continueButton, "clicked", G_CALLBACK(onContinuePressed), NULL); g_signal_connect(autoContinueButton, "toggled", G_CALLBACK(onAutoContinueStatusChanged), NULL); gtk_container_add (GTK_CONTAINER(window), vBox); gtk_box_pack_start (GTK_BOX(clientServerModeHBox), modeLabel, FALSE, TRUE, 1); gtk_box_pack_start (GTK_BOX(clientServerModeHBox), modeComboBox, TRUE, TRUE, 1); gtk_box_pack_start (GTK_BOX(serverDetailsHBox), serverNameLabel, FALSE, FALSE, 1); gtk_box_pack_start (GTK_BOX(serverDetailsHBox), serverName, TRUE, TRUE, 1); gtk_box_pack_start (GTK_BOX(serverDetailsHBox), portNumberLabel, FALSE, FALSE, 1); gtk_box_pack_start (GTK_BOX(serverDetailsHBox), portNumber, TRUE, TRUE, 1); gtk_box_pack_start (GTK_BOX(serverDetailsHBox), sharedKeyLabel, FALSE, FALSE, 1); gtk_box_pack_start (GTK_BOX(serverDetailsHBox), sharedKey, TRUE, TRUE, 1); gtk_box_pack_start (GTK_BOX(serverDetailsHBox), clientStatusButton, FALSE, FALSE, 1); gtk_box_pack_start (GTK_BOX(serverDetailsHBox), serverStatusButton, FALSE, FALSE, 1); gtk_box_pack_start (GTK_BOX(messageHBox), messageLabel, FALSE, FALSE, 1); gtk_box_pack_start (GTK_BOX(messageHBox), messageEntry, TRUE, TRUE, 1); gtk_box_pack_start (GTK_BOX(messageHBox), messageSendButton, FALSE, FALSE, 1); gtk_box_pack_start (GTK_BOX(continueButtonsHBox), continueButton, TRUE, TRUE, 1); gtk_box_pack_start (GTK_BOX(continueButtonsHBox), autoContinueButton, TRUE, TRUE, 1); gtk_container_add (GTK_CONTAINER(vBox), clientServerModeHBox); gtk_container_add (GTK_CONTAINER(vBox), serverDetailsHBox); gtk_container_add (GTK_CONTAINER(vBox), messageHBox); gtk_container_add (GTK_CONTAINER(vBox), continueButtonsHBox); gtk_container_add (GTK_CONTAINER(vBox), authenticationTextLogLabel); gtk_container_add(GTK_CONTAINER(scrolledAuthenticationWindow), authenticationTextLog); gtk_container_add (GTK_CONTAINER(vBox), scrolledAuthenticationWindow); gtk_container_add (GTK_CONTAINER(vBox), encryptedTextLogLabel); gtk_container_add(GTK_CONTAINER(scrolledEncryptedTextWindow), encryptedTextLog); gtk_container_add (GTK_CONTAINER(vBox), scrolledEncryptedTextWindow); gtk_container_add (GTK_CONTAINER(vBox), plainTextLogLabel); gtk_container_add(GTK_CONTAINER(scrolledPlaintextWindow), plainTextLog); gtk_container_add (GTK_CONTAINER(vBox), scrolledPlaintextWindow); gtk_widget_show_all (window); gtk_widget_hide(serverStatusButton); }
/* * Set up the airpcap toolbar for the new capture interface */ void airpcap_set_toolbar_start_capture(airpcap_if_info_t* if_info) { GtkWidget *airpcap_toolbar_label; GtkWidget *toolbar_channel_cb; GtkWidget *airpcap_toolbar_channel_lb; GtkWidget *airpcap_toolbar_channel_offset; GtkWidget *airpcap_toolbar_channel_offset_lb; GtkWidget *airpcap_toolbar_button; GtkWidget *airpcap_toolbar_fcs; GtkWidget *airpcap_toolbar_fcs_lb; GtkWidget *airpcap_toolbar_decryption; GtkWidget *airpcap_toolbar_decryption_lb; GtkWidget *airpcap_toolbar_keys_button; gchar *if_label_text; airpcap_toolbar_label = g_object_get_data(G_OBJECT(wireless_tb),AIRPCAP_TOOLBAR_INTERFACE_KEY); toolbar_channel_cb = g_object_get_data(G_OBJECT(wireless_tb),AIRPCAP_TOOLBAR_CHANNEL_KEY); airpcap_toolbar_channel_lb = g_object_get_data(G_OBJECT(wireless_tb),AIRPCAP_TOOLBAR_CHANNEL_LABEL_KEY); airpcap_toolbar_channel_offset = g_object_get_data(G_OBJECT(wireless_tb),AIRPCAP_TOOLBAR_CHANNEL_OFFSET_KEY); airpcap_toolbar_channel_offset_lb = g_object_get_data(G_OBJECT(wireless_tb),AIRPCAP_TOOLBAR_CHANNEL_OFFSET_LABEL_KEY); airpcap_toolbar_fcs = g_object_get_data(G_OBJECT(wireless_tb),AIRPCAP_TOOLBAR_FCS_FILTER_KEY); airpcap_toolbar_fcs_lb = g_object_get_data(G_OBJECT(wireless_tb),AIRPCAP_TOOLBAR_FCS_FILTER_LABEL_KEY); airpcap_toolbar_button = g_object_get_data(G_OBJECT(wireless_tb),AIRPCAP_TOOLBAR_ADVANCED_KEY); airpcap_toolbar_decryption = g_object_get_data(G_OBJECT(wireless_tb),AIRPCAP_TOOLBAR_DECRYPTION_KEY); airpcap_toolbar_decryption_lb = g_object_get_data(G_OBJECT(wireless_tb),AIRPCAP_TOOLBAR_DECRYPTION_LABEL_KEY); airpcap_toolbar_keys_button = g_object_get_data(G_OBJECT(wireless_tb),AIRPCAP_TOOLBAR_KEY_MANAGEMENT_KEY); /* The current interface is an airpcap interface */ if(if_info != NULL) { gtk_widget_set_sensitive(wireless_tb,TRUE); gtk_widget_set_sensitive(airpcap_toolbar_label,TRUE); gtk_widget_set_sensitive(toolbar_channel_cb,TRUE); gtk_widget_set_sensitive(airpcap_toolbar_channel_lb,TRUE); gtk_widget_set_sensitive(airpcap_toolbar_channel_offset,TRUE); gtk_widget_set_sensitive(airpcap_toolbar_channel_offset_lb,TRUE); gtk_widget_set_sensitive(airpcap_toolbar_fcs,FALSE); gtk_widget_set_sensitive(airpcap_toolbar_fcs_lb,FALSE); gtk_widget_set_sensitive(airpcap_toolbar_button,FALSE); gtk_widget_set_sensitive(airpcap_toolbar_button,FALSE); gtk_widget_set_sensitive(airpcap_toolbar_decryption,FALSE); gtk_widget_set_sensitive(airpcap_toolbar_decryption_lb,FALSE); gtk_widget_set_sensitive(airpcap_toolbar_keys_button,FALSE); /*decryption check box*/ g_signal_handlers_block_by_func (airpcap_toolbar_decryption,airpcap_toolbar_encryption_cb, wireless_tb); if(if_info->DecryptionOn == AIRPCAP_DECRYPTION_ON) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(airpcap_toolbar_decryption),TRUE); else gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(airpcap_toolbar_decryption),FALSE); g_signal_handlers_unblock_by_func (airpcap_toolbar_decryption,airpcap_toolbar_encryption_cb, wireless_tb); if_label_text = g_strdup_printf("Current Wireless Interface: #%s", airpcap_get_if_string_number(if_info)); gtk_label_set_text(GTK_LABEL(airpcap_toolbar_label),if_label_text); g_free(if_label_text); change_airpcap_settings = FALSE; if (if_info->pSupportedChannels != NULL && if_info->numSupportedChannels > 0){ guint i = 0; for (; i<if_info->numSupportedChannels; i++){ gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT(toolbar_channel_cb), ieee80211_mhz_to_str(if_info->pSupportedChannels[i].Frequency)); } } airpcap_update_channel_combo(GTK_WIDGET(toolbar_channel_cb),if_info); airpcap_update_channel_offset_combo(if_info, if_info->channelInfo.Frequency, airpcap_toolbar_channel_offset, TRUE); change_airpcap_settings = TRUE; } else /* Current interface is NOT an AirPcap one... */ { gtk_widget_set_sensitive(wireless_tb,FALSE); gtk_widget_set_sensitive(airpcap_toolbar_label,FALSE); gtk_widget_set_sensitive(toolbar_channel_cb,FALSE); gtk_widget_set_sensitive(airpcap_toolbar_channel_lb,FALSE); gtk_widget_set_sensitive(airpcap_toolbar_channel_offset,FALSE); gtk_widget_set_sensitive(airpcap_toolbar_channel_offset_lb,FALSE); gtk_widget_set_sensitive(airpcap_toolbar_fcs,FALSE); gtk_widget_set_sensitive(airpcap_toolbar_fcs_lb,FALSE); gtk_widget_set_sensitive(airpcap_toolbar_button,FALSE); gtk_widget_set_sensitive(airpcap_toolbar_button,FALSE); gtk_widget_set_sensitive(airpcap_toolbar_decryption,FALSE); gtk_widget_set_sensitive(airpcap_toolbar_decryption_lb,FALSE); gtk_widget_set_sensitive(airpcap_toolbar_keys_button,FALSE); } }
/** * bastile_gpgme_generate_show: * @sksrc: the gpgme source * @parent: the parent window * @name: The user name, can be NULL if not available * @email: The user's email address, can be NULL if not available * @comment: The comment to add to the key. Can be NULL * * Shows the gpg key generation dialog, sets default entries. * */ void bastile_gpgme_generate_show (BastileGpgmeSource *sksrc, GtkWindow *parent, const gchar * name, const gchar *email, const gchar *comment) { BastileWidget *swidget; GtkWidget *widget, *datetime; time_t expires; guint i; swidget = bastile_widget_new ("pgp-generate", parent); /* Widget already present */ if (swidget == NULL) return; if (name) { widget = bastile_widget_get_widget (swidget, "name-entry"); g_return_if_fail (widget != NULL); gtk_entry_set_text(GTK_ENTRY(widget),name); } if (email) { widget = bastile_widget_get_widget (swidget, "email-entry"); g_return_if_fail (widget != NULL); gtk_entry_set_text(GTK_ENTRY(widget),email); } if (comment) { widget = bastile_widget_get_widget (swidget, "comment-entry"); g_return_if_fail (widget != NULL); gtk_entry_set_text(GTK_ENTRY(widget),comment); } widget = bastile_widget_get_widget (swidget, "pgp-image"); g_return_if_fail (widget != NULL); gtk_image_set_from_stock (GTK_IMAGE (widget), BASTILE_STOCK_SECRET, GTK_ICON_SIZE_DIALOG); /* The algoritms */ widget = bastile_widget_get_widget (swidget, "algorithm-choice"); g_return_if_fail (widget != NULL); #if GTK_CHECK_VERSION (2,91,2) gtk_combo_box_text_remove (GTK_COMBO_BOX_TEXT (widget), 0); for(i = 0; i < G_N_ELEMENTS(available_algorithms); i++) gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), _(available_algorithms[i].desc)); #else gtk_combo_box_remove_text (GTK_COMBO_BOX (widget), 0); for(i = 0; i < G_N_ELEMENTS(available_algorithms); i++) gtk_combo_box_append_text (GTK_COMBO_BOX (widget), _(available_algorithms[i].desc)); #endif gtk_combo_box_set_active (GTK_COMBO_BOX (widget), 0); on_gpgme_generate_algorithm_changed (GTK_COMBO_BOX (widget), swidget); expires = time (NULL); expires += (60 * 60 * 24 * 365); /* Seconds in a year */ /* Default expiry date */ widget = bastile_widget_get_widget (swidget, "expiry-date-container"); g_return_if_fail (widget != NULL); datetime = egg_datetime_new_from_time_t (expires); gtk_box_pack_start (GTK_BOX (widget), datetime, TRUE, TRUE, 0); gtk_widget_set_sensitive (datetime, FALSE); gtk_widget_show_all (widget); g_object_ref (sksrc); g_object_set_data_full (G_OBJECT (swidget), "source", sksrc, g_object_unref); on_gpgme_generate_entry_changed (NULL, swidget); }
/* * Update the channel offset of the given combobox according to the given frequency. */ void airpcap_update_channel_offset_combo(airpcap_if_info_t* if_info, guint chan_freq, GtkWidget *channel_offset_cb, gboolean set) { gint current_offset; gint new_offset; guint i; gint active_idx = 0; gint idx_count = -1; if (!if_info || airpcap_if_is_any(if_info) || if_info->pSupportedChannels == NULL || if_info->numSupportedChannels < 1) { gtk_widget_set_sensitive(GTK_WIDGET(channel_offset_cb),FALSE); gtk_combo_box_set_active(GTK_COMBO_BOX(channel_offset_cb), -1); return; } new_offset = current_offset = if_info->channelInfo.ExtChannel; /* Clear out the list */ while (gtk_tree_model_iter_n_children(gtk_combo_box_get_model(GTK_COMBO_BOX(channel_offset_cb)), NULL) > 0) { gtk_combo_box_text_remove(GTK_COMBO_BOX_TEXT(channel_offset_cb), 0); } gtk_widget_set_sensitive(GTK_WIDGET(channel_offset_cb), TRUE); for (i = 0; i < if_info->numSupportedChannels; i++) { if (if_info->pSupportedChannels[i].Frequency == chan_freq) { /* If we can't be low or high, nudge the offset to 0 */ if (current_offset == -1 && !(if_info->pSupportedChannels[i].Flags & FLAG_CAN_BE_LOW)) { new_offset = 0; } else if (current_offset == 1 && !(if_info->pSupportedChannels[i].Flags & FLAG_CAN_BE_HIGH)) { new_offset = 0; } if ((if_info->pSupportedChannels[i].Flags & FLAG_CAN_BE_LOW)) { gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT(channel_offset_cb), "-1"); idx_count++; if (new_offset == -1) { active_idx = idx_count; } } gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT(channel_offset_cb), "0"); idx_count++; if (new_offset == 0) { active_idx = idx_count; } if ((if_info->pSupportedChannels[i].Flags & FLAG_CAN_BE_HIGH)){ gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT(channel_offset_cb), "+1"); idx_count++; if (new_offset == 1) { active_idx = idx_count; } } break; } } gtk_combo_box_set_active(GTK_COMBO_BOX(channel_offset_cb), active_idx); if (set) { change_airpcap_settings = TRUE; if_info->channelInfo.ExtChannel = new_offset; if (!airpcap_update_frequency_and_offset(if_info)){ simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"Adapter failed to be set with the following settings: Frequency - %d Extension Channel - %d", if_info->channelInfo.Frequency, if_info->channelInfo.ExtChannel); } } if (idx_count < 1) { gtk_widget_set_sensitive(channel_offset_cb, FALSE); } }
static TrayData * create_tray_on_screen (GdkScreen *screen, gboolean force) { GtkWidget *window, *hbox, *vbox, *button, *combo, *label; TrayData *data; n_windows++; if (!force && na_tray_manager_check_running (screen)) { GtkWidget *dialog; dialog = gtk_message_dialog_new (NULL, 0, GTK_MESSAGE_WARNING, GTK_BUTTONS_YES_NO, "Override tray manager?"); gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog), "There is already a tray manager running on screen %d.", gdk_screen_get_number (screen)); gtk_window_set_screen (GTK_WINDOW (dialog), screen); g_signal_connect (dialog, "response", G_CALLBACK (warning_dialog_response_cb), screen); gtk_window_present (GTK_WINDOW (dialog)); g_object_weak_ref (G_OBJECT (dialog), (GWeakNotify) maybe_quit, NULL); return NULL; } data = g_new0 (TrayData, 1); data->screen = screen; data->screen_num = gdk_screen_get_number (screen); data->window = window = gtk_window_new (GTK_WINDOW_TOPLEVEL); g_object_weak_ref (G_OBJECT (window), (GWeakNotify) maybe_quit, NULL); vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 6); gtk_container_add (GTK_CONTAINER (window), vbox); button = gtk_button_new_with_mnemonic ("_Add another tray"); g_signal_connect (button, "clicked", G_CALLBACK (add_tray_cb), data); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 12); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); label = gtk_label_new_with_mnemonic ("_Orientation:"); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); combo = gtk_combo_box_text_new (); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), "Horizontal"); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), "Vertical"); g_signal_connect (combo, "changed", G_CALLBACK (orientation_changed_cb), data); gtk_box_pack_start (GTK_BOX (hbox), combo, FALSE, FALSE, 0); label = gtk_label_new (NULL); data->count_label = GTK_LABEL (label); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); data->tray = na_tray_new_for_screen (screen, GTK_ORIENTATION_HORIZONTAL); gtk_box_pack_start (GTK_BOX (vbox), GTK_WIDGET (data->tray), TRUE, TRUE, 0); data->box = gtk_bin_get_child (GTK_BIN (gtk_bin_get_child (GTK_BIN (data->tray)))); g_signal_connect_after (data->box, "add", G_CALLBACK (tray_added_cb), data); g_signal_connect_after (data->box, "remove", G_CALLBACK (tray_removed_cb), data); gtk_combo_box_set_active (GTK_COMBO_BOX (combo), 0); gtk_window_set_screen (GTK_WINDOW (window), screen); gtk_window_set_default_size (GTK_WINDOW (window), -1, 200); /* gtk_window_set_resizable (GTK_WINDOW (window), FALSE); */ gtk_widget_show_all (window); update_child_count (data); return data; }
GtkWidget *main_window(){ GtkWidget *vbox, *hpane, *vpane, *swin, *vbox2, *stage_width_entry, *stage_height_entry, *rectangle_button; WebKitWebView *web_view; ClutterActor *stage; ClutterColor stage_bg_color = { 128, 128, 128, 255 }, white = { 255, 255, 255, 255 } ; // Create widgets app.window = gtk_window_new(GTK_WINDOW_TOPLEVEL); vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); app.menubar = gtk_menu_bar_new(); app.toolbar = gtk_toolbar_new(); hpane = gtk_paned_new(GTK_ORIENTATION_HORIZONTAL); vpane = gtk_paned_new(GTK_ORIENTATION_VERTICAL); app.statusbar = gtk_statusbar_new(); app.stage = gtk_clutter_embed_new(); app.notebook = gtk_notebook_new(); web_view= WEBKIT_WEB_VIEW(webkit_web_view_new()); swin = gtk_scrolled_window_new(NULL, NULL); vbox2 = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); stage_width_entry = gtk_spin_button_new_with_range(0, 9999, 1); stage_height_entry = gtk_spin_button_new_with_range(0, 9999, 1); app.colorpicker = gtk_color_button_new(); app.fileselector = gtk_file_chooser_button_new("Background image", GTK_FILE_CHOOSER_ACTION_OPEN); app.background_repeat_select = gtk_combo_box_text_new(); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(app.background_repeat_select), "no-repeat"); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(app.background_repeat_select), "repeat-x"); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(app.background_repeat_select), "repeat-y"); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(app.background_repeat_select), "repeat-xy"); stage = gtk_clutter_embed_get_stage(GTK_CLUTTER_EMBED(app.stage)); rectangle_button = gtk_button_new_from_stock(GTK_STOCK_NEW); app.mainstage = clutter_rectangle_new_with_color(&white); // Pack widgets gtk_container_add(GTK_CONTAINER(app.window), vbox); gtk_box_pack_start(GTK_BOX(vbox), app.menubar, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox), app.toolbar, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox), app.notebook, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(vbox), app.statusbar, FALSE, FALSE, 0); gtk_notebook_append_page(GTK_NOTEBOOK(app.notebook), vpane, gtk_label_new("Animator")); gtk_notebook_append_page(GTK_NOTEBOOK(app.notebook), swin, gtk_label_new("Browser")); gtk_notebook_append_page(GTK_NOTEBOOK(app.notebook), gtk_label_new("tbc"), gtk_label_new("Source")); gtk_container_add(GTK_CONTAINER(swin), GTK_WIDGET(web_view)); gtk_paned_pack1(GTK_PANED(vpane), hpane, TRUE, TRUE); gtk_paned_pack2(GTK_PANED(vpane), gtk_label_new("Timeline"), FALSE, TRUE); gtk_paned_pack1(GTK_PANED(hpane), app.stage,TRUE, TRUE); gtk_paned_pack2(GTK_PANED(hpane), vbox2, FALSE, TRUE); gtk_box_pack_start(GTK_BOX(vbox2), stage_width_entry, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox2), stage_height_entry, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox2), app.colorpicker, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox2), app.fileselector, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox2), app.background_repeat_select, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox2), rectangle_button, FALSE, FALSE, 0); //Setup widgets gtk_paned_set_position(GTK_PANED(hpane), 600); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(swin), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); webkit_web_view_load_uri(web_view, "http://www.webkitgtk.org/"); gtk_widget_set_size_request(app.stage, 800, 600); gtk_paned_set_position(GTK_PANED(hpane), 600); gtk_spin_button_set_value(GTK_SPIN_BUTTON(stage_width_entry), 300); gtk_spin_button_set_value(GTK_SPIN_BUTTON(stage_height_entry), 200); g_object_set_data(G_OBJECT(stage_width_entry), "type", "width"); g_object_set_data(G_OBJECT(stage_height_entry), "type", "height"); clutter_stage_set_user_resizable(CLUTTER_STAGE(stage), FALSE); gtk_color_button_set_use_alpha(GTK_COLOR_BUTTON(app.colorpicker), TRUE); gtk_combo_box_set_active(GTK_COMBO_BOX(app.background_repeat_select), 0); clutter_actor_set_background_color(stage, &stage_bg_color); clutter_actor_set_size(app.mainstage, 400, 300); clutter_actor_set_position(app.mainstage, 100, 100); clutter_actor_add_child(stage, app.mainstage); clutter_actor_show(app.mainstage); clutter_actor_show(stage); // Connect signals g_signal_connect(app.fileselector, "file-set", G_CALLBACK(on_file_set), NULL); g_signal_connect(app.window, "destroy", G_CALLBACK(gtk_main_quit), NULL); g_signal_connect(stage_width_entry, "value-changed", G_CALLBACK(on_stage_dim_changed), stage); g_signal_connect(stage_height_entry, "value-changed", G_CALLBACK(on_stage_dim_changed), stage); g_signal_connect(rectangle_button, "clicked", G_CALLBACK(on_new_button_clicked), NULL); return (app.window); }
GtkWidget* create_converterdlg (void) { GtkWidget *converterdlg; GtkWidget *dialog_vbox6; GtkWidget *hbox105; GtkWidget *vbox26; GtkWidget *hbox67; GtkWidget *label103; GtkWidget *hbox68; GtkWidget *output_folder; GtkWidget *converter_output_browse; GtkWidget *write_to_source_folder; GtkWidget *preserve_folders; GtkWidget *bypass_same_format; GtkWidget *retag_after_copy; GtkWidget *hbox100; GtkWidget *label122; GtkWidget *hbox101; GtkWidget *output_file; GtkWidget *custom6; GtkWidget *hbox69; GtkWidget *label104; GtkWidget *hbox90; GtkWidget *encoder; GtkWidget *edit_encoder_presets; GtkWidget *image469; GtkWidget *hbox86; GtkWidget *label114; GtkWidget *hbox91; GtkWidget *dsp_preset; GtkWidget *edit_dsp_presets; GtkWidget *image470; GtkWidget *hbox88; GtkWidget *label116; GObject *numthreads_adj; GtkWidget *numthreads; GtkWidget *hbox89; GtkWidget *label117; GtkWidget *output_format; GtkWidget *hbox99; GtkWidget *label121; GtkWidget *overwrite_action; GtkWidget *scrolledwindow9; GtkWidget *preview_tree; GtkWidget *dialog_action_area5; GtkWidget *converter_cancel; GtkWidget *converter_ok; converterdlg = gtk_dialog_new (); gtk_widget_set_size_request (converterdlg, 720, -1); gtk_window_set_title (GTK_WINDOW (converterdlg), "Converter"); gtk_window_set_position (GTK_WINDOW (converterdlg), GTK_WIN_POS_MOUSE); gtk_window_set_modal (GTK_WINDOW (converterdlg), TRUE); gtk_window_set_destroy_with_parent (GTK_WINDOW (converterdlg), TRUE); gtk_window_set_type_hint (GTK_WINDOW (converterdlg), GDK_WINDOW_TYPE_HINT_DIALOG); gtk_dialog_set_has_separator (GTK_DIALOG (converterdlg), FALSE); dialog_vbox6 = gtk_dialog_get_content_area (GTK_DIALOG (converterdlg)); gtk_widget_show (dialog_vbox6); hbox105 = gtk_hbox_new (FALSE, 0); gtk_widget_show (hbox105); gtk_box_pack_start (GTK_BOX (dialog_vbox6), hbox105, TRUE, TRUE, 0); vbox26 = gtk_vbox_new (FALSE, 8); gtk_widget_show (vbox26); gtk_box_pack_start (GTK_BOX (hbox105), vbox26, FALSE, TRUE, 0); gtk_container_set_border_width (GTK_CONTAINER (vbox26), 12); hbox67 = gtk_hbox_new (FALSE, 8); gtk_widget_show (hbox67); gtk_box_pack_start (GTK_BOX (vbox26), hbox67, FALSE, TRUE, 0); label103 = gtk_label_new (_("Output folder:")); gtk_widget_show (label103); gtk_box_pack_start (GTK_BOX (hbox67), label103, FALSE, FALSE, 0); hbox68 = gtk_hbox_new (FALSE, 0); gtk_widget_show (hbox68); gtk_box_pack_start (GTK_BOX (hbox67), hbox68, TRUE, TRUE, 0); output_folder = gtk_entry_new (); gtk_widget_show (output_folder); gtk_box_pack_start (GTK_BOX (hbox68), output_folder, TRUE, TRUE, 0); gtk_entry_set_invisible_char (GTK_ENTRY (output_folder), 9679); converter_output_browse = gtk_button_new_with_mnemonic ("..."); gtk_widget_show (converter_output_browse); gtk_box_pack_start (GTK_BOX (hbox68), converter_output_browse, FALSE, FALSE, 0); write_to_source_folder = gtk_check_button_new_with_mnemonic (_("Write to source track folder")); gtk_widget_show (write_to_source_folder); gtk_box_pack_start (GTK_BOX (vbox26), write_to_source_folder, FALSE, FALSE, 0); preserve_folders = gtk_check_button_new_with_mnemonic (_("Preserve folder structure")); gtk_widget_show (preserve_folders); gtk_box_pack_start (GTK_BOX (vbox26), preserve_folders, FALSE, FALSE, 0); bypass_same_format = gtk_check_button_new_with_mnemonic (_("Copy if the format is not changing")); gtk_widget_show (bypass_same_format); gtk_box_pack_start (GTK_BOX (vbox26), bypass_same_format, FALSE, FALSE, 0); retag_after_copy = gtk_check_button_new_with_mnemonic (_("Re-tag after copy")); gtk_widget_show (retag_after_copy); gtk_box_pack_start (GTK_BOX (vbox26), retag_after_copy, FALSE, FALSE, 0); hbox100 = gtk_hbox_new (FALSE, 8); gtk_widget_show (hbox100); gtk_box_pack_start (GTK_BOX (vbox26), hbox100, FALSE, TRUE, 0); label122 = gtk_label_new (_("Output file name:")); gtk_widget_show (label122); gtk_box_pack_start (GTK_BOX (hbox100), label122, FALSE, FALSE, 0); hbox101 = gtk_hbox_new (FALSE, 0); gtk_widget_show (hbox101); gtk_box_pack_start (GTK_BOX (hbox100), hbox101, TRUE, TRUE, 0); output_file = gtk_entry_new (); gtk_widget_show (output_file); gtk_box_pack_start (GTK_BOX (hbox101), output_file, TRUE, TRUE, 0); gtk_widget_set_tooltip_text (output_file, _("Extension (e.g. .mp3) will be appended automatically.\nLeave the field empty for default (%artist% - %title%).")); gtk_entry_set_invisible_char (GTK_ENTRY (output_file), 8226); custom6 = title_formatting_help_link_create ("custom6", "", "", 0, 0); gtk_widget_show (custom6); gtk_box_pack_start (GTK_BOX (hbox101), custom6, TRUE, TRUE, 0); gtk_widget_set_can_focus(custom6, FALSE); gtk_widget_set_can_default(custom6, FALSE); hbox69 = gtk_hbox_new (FALSE, 8); gtk_widget_show (hbox69); gtk_box_pack_start (GTK_BOX (vbox26), hbox69, FALSE, TRUE, 0); label104 = gtk_label_new (_("Encoder:")); gtk_widget_show (label104); gtk_box_pack_start (GTK_BOX (hbox69), label104, FALSE, FALSE, 0); hbox90 = gtk_hbox_new (FALSE, 0); gtk_widget_show (hbox90); gtk_box_pack_start (GTK_BOX (hbox69), hbox90, TRUE, TRUE, 0); encoder = gtk_combo_box_text_new (); gtk_widget_show (encoder); gtk_box_pack_start (GTK_BOX (hbox90), encoder, TRUE, TRUE, 0); edit_encoder_presets = gtk_button_new (); gtk_widget_show (edit_encoder_presets); gtk_box_pack_start (GTK_BOX (hbox90), edit_encoder_presets, FALSE, FALSE, 0); image469 = gtk_image_new_from_stock ("gtk-edit", GTK_ICON_SIZE_BUTTON); gtk_widget_show (image469); gtk_container_add (GTK_CONTAINER (edit_encoder_presets), image469); hbox86 = gtk_hbox_new (FALSE, 8); gtk_widget_show (hbox86); gtk_box_pack_start (GTK_BOX (vbox26), hbox86, FALSE, TRUE, 0); label114 = gtk_label_new (_("DSP preset:")); gtk_widget_show (label114); gtk_box_pack_start (GTK_BOX (hbox86), label114, FALSE, FALSE, 0); hbox91 = gtk_hbox_new (FALSE, 0); gtk_widget_show (hbox91); gtk_box_pack_start (GTK_BOX (hbox86), hbox91, TRUE, TRUE, 0); dsp_preset = gtk_combo_box_text_new (); gtk_widget_show (dsp_preset); gtk_box_pack_start (GTK_BOX (hbox91), dsp_preset, TRUE, TRUE, 0); edit_dsp_presets = gtk_button_new (); gtk_widget_show (edit_dsp_presets); gtk_box_pack_start (GTK_BOX (hbox91), edit_dsp_presets, FALSE, FALSE, 0); image470 = gtk_image_new_from_stock ("gtk-edit", GTK_ICON_SIZE_BUTTON); gtk_widget_show (image470); gtk_container_add (GTK_CONTAINER (edit_dsp_presets), image470); hbox88 = gtk_hbox_new (FALSE, 8); gtk_box_pack_start (GTK_BOX (vbox26), hbox88, FALSE, TRUE, 0); label116 = gtk_label_new (_("Number of threads:")); gtk_widget_show (label116); gtk_box_pack_start (GTK_BOX (hbox88), label116, FALSE, FALSE, 0); numthreads_adj = G_OBJECT(gtk_adjustment_new (1, 0, 100, 1, 10, 0)); numthreads = gtk_spin_button_new (GTK_ADJUSTMENT (numthreads_adj), 1, 0); gtk_widget_show (numthreads); gtk_box_pack_start (GTK_BOX (hbox88), numthreads, TRUE, TRUE, 0); hbox89 = gtk_hbox_new (FALSE, 8); gtk_widget_show (hbox89); gtk_box_pack_start (GTK_BOX (vbox26), hbox89, FALSE, TRUE, 0); label117 = gtk_label_new (_("Output sample format:")); gtk_widget_show (label117); gtk_box_pack_start (GTK_BOX (hbox89), label117, FALSE, FALSE, 0); output_format = gtk_combo_box_text_new (); gtk_widget_show (output_format); gtk_box_pack_start (GTK_BOX (hbox89), output_format, TRUE, TRUE, 0); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (output_format), _("Keep source format")); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (output_format), _("8 bit signed int")); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (output_format), _("16 bit signed int")); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (output_format), _("24 bit signed int")); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (output_format), _("32 bit signed int")); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (output_format), _("32 bit float")); hbox99 = gtk_hbox_new (FALSE, 8); gtk_widget_show (hbox99); gtk_box_pack_start (GTK_BOX (vbox26), hbox99, FALSE, TRUE, 0); label121 = gtk_label_new (_("When file exists:")); gtk_widget_show (label121); gtk_box_pack_start (GTK_BOX (hbox99), label121, FALSE, FALSE, 0); overwrite_action = gtk_combo_box_text_new (); gtk_widget_show (overwrite_action); gtk_box_pack_start (GTK_BOX (hbox99), overwrite_action, TRUE, TRUE, 0); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (overwrite_action), _("Skip")); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (overwrite_action), _("Prompt")); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (overwrite_action), _("Overwrite")); scrolledwindow9 = gtk_scrolled_window_new (NULL, NULL); gtk_widget_show (scrolledwindow9); gtk_box_pack_start (GTK_BOX (hbox105), scrolledwindow9, TRUE, TRUE, 0); gtk_container_set_border_width (GTK_CONTAINER (scrolledwindow9), 12); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow9), GTK_SHADOW_IN); preview_tree = gtk_tree_view_new (); gtk_widget_show (preview_tree); gtk_container_add (GTK_CONTAINER (scrolledwindow9), preview_tree); gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (preview_tree), TRUE); dialog_action_area5 = gtk_dialog_get_action_area (GTK_DIALOG (converterdlg)); gtk_widget_show (dialog_action_area5); gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area5), GTK_BUTTONBOX_END); converter_cancel = gtk_button_new_from_stock ("gtk-cancel"); gtk_widget_show (converter_cancel); gtk_dialog_add_action_widget (GTK_DIALOG (converterdlg), converter_cancel, GTK_RESPONSE_CANCEL); gtk_widget_set_can_default(converter_cancel, TRUE); converter_ok = gtk_button_new_from_stock ("gtk-ok"); gtk_widget_show (converter_ok); gtk_dialog_add_action_widget (GTK_DIALOG (converterdlg), converter_ok, GTK_RESPONSE_OK); gtk_widget_set_can_default(converter_ok, TRUE); g_signal_connect ((gpointer) output_folder, "changed", G_CALLBACK (on_output_folder_changed), NULL); g_signal_connect ((gpointer) converter_output_browse, "clicked", G_CALLBACK (on_converter_output_browse_clicked), NULL); g_signal_connect ((gpointer) preserve_folders, "toggled", G_CALLBACK (on_preserve_folders_toggled), NULL); g_signal_connect ((gpointer) bypass_same_format, "toggled", G_CALLBACK (on_bypass_same_format_toggled), NULL); g_signal_connect ((gpointer) retag_after_copy, "toggled", G_CALLBACK (on_retag_after_copy_toggled), NULL); g_signal_connect ((gpointer) encoder, "changed", G_CALLBACK (on_converter_encoder_changed), NULL); g_signal_connect ((gpointer) edit_encoder_presets, "clicked", G_CALLBACK (on_edit_encoder_presets_clicked), NULL); g_signal_connect ((gpointer) dsp_preset, "changed", G_CALLBACK (on_converter_dsp_preset_changed), NULL); g_signal_connect ((gpointer) edit_dsp_presets, "clicked", G_CALLBACK (on_edit_dsp_presets_clicked), NULL); g_signal_connect ((gpointer) numthreads, "changed", G_CALLBACK (on_numthreads_changed), NULL); g_signal_connect ((gpointer) output_format, "changed", G_CALLBACK (on_converter_output_format_changed), NULL); g_signal_connect ((gpointer) overwrite_action, "changed", G_CALLBACK (on_overwrite_action_changed), NULL); /* Store pointers to all widgets, for use by lookup_widget(). */ GLADE_HOOKUP_OBJECT_NO_REF (converterdlg, converterdlg, "converterdlg"); GLADE_HOOKUP_OBJECT_NO_REF (converterdlg, dialog_vbox6, "dialog_vbox6"); GLADE_HOOKUP_OBJECT (converterdlg, hbox105, "hbox105"); GLADE_HOOKUP_OBJECT (converterdlg, vbox26, "vbox26"); GLADE_HOOKUP_OBJECT (converterdlg, hbox67, "hbox67"); GLADE_HOOKUP_OBJECT (converterdlg, label103, "label103"); GLADE_HOOKUP_OBJECT (converterdlg, hbox68, "hbox68"); GLADE_HOOKUP_OBJECT (converterdlg, output_folder, "output_folder"); GLADE_HOOKUP_OBJECT (converterdlg, converter_output_browse, "converter_output_browse"); GLADE_HOOKUP_OBJECT (converterdlg, write_to_source_folder, "write_to_source_folder"); GLADE_HOOKUP_OBJECT (converterdlg, preserve_folders, "preserve_folders"); GLADE_HOOKUP_OBJECT (converterdlg, bypass_same_format, "bypass_same_format"); GLADE_HOOKUP_OBJECT (converterdlg, retag_after_copy, "retag_after_copy"); GLADE_HOOKUP_OBJECT (converterdlg, hbox100, "hbox100"); GLADE_HOOKUP_OBJECT (converterdlg, label122, "label122"); GLADE_HOOKUP_OBJECT (converterdlg, hbox101, "hbox101"); GLADE_HOOKUP_OBJECT (converterdlg, output_file, "output_file"); GLADE_HOOKUP_OBJECT (converterdlg, custom6, "custom6"); GLADE_HOOKUP_OBJECT (converterdlg, hbox69, "hbox69"); GLADE_HOOKUP_OBJECT (converterdlg, label104, "label104"); GLADE_HOOKUP_OBJECT (converterdlg, hbox90, "hbox90"); GLADE_HOOKUP_OBJECT (converterdlg, encoder, "encoder"); GLADE_HOOKUP_OBJECT (converterdlg, edit_encoder_presets, "edit_encoder_presets"); GLADE_HOOKUP_OBJECT (converterdlg, image469, "image469"); GLADE_HOOKUP_OBJECT (converterdlg, hbox86, "hbox86"); GLADE_HOOKUP_OBJECT (converterdlg, label114, "label114"); GLADE_HOOKUP_OBJECT (converterdlg, hbox91, "hbox91"); GLADE_HOOKUP_OBJECT (converterdlg, dsp_preset, "dsp_preset"); GLADE_HOOKUP_OBJECT (converterdlg, edit_dsp_presets, "edit_dsp_presets"); GLADE_HOOKUP_OBJECT (converterdlg, image470, "image470"); GLADE_HOOKUP_OBJECT (converterdlg, hbox88, "hbox88"); GLADE_HOOKUP_OBJECT (converterdlg, label116, "label116"); GLADE_HOOKUP_OBJECT (converterdlg, numthreads, "numthreads"); GLADE_HOOKUP_OBJECT (converterdlg, hbox89, "hbox89"); GLADE_HOOKUP_OBJECT (converterdlg, label117, "label117"); GLADE_HOOKUP_OBJECT (converterdlg, output_format, "output_format"); GLADE_HOOKUP_OBJECT (converterdlg, hbox99, "hbox99"); GLADE_HOOKUP_OBJECT (converterdlg, label121, "label121"); GLADE_HOOKUP_OBJECT (converterdlg, overwrite_action, "overwrite_action"); GLADE_HOOKUP_OBJECT (converterdlg, scrolledwindow9, "scrolledwindow9"); GLADE_HOOKUP_OBJECT (converterdlg, preview_tree, "preview_tree"); GLADE_HOOKUP_OBJECT_NO_REF (converterdlg, dialog_action_area5, "dialog_action_area5"); GLADE_HOOKUP_OBJECT (converterdlg, converter_cancel, "converter_cancel"); GLADE_HOOKUP_OBJECT (converterdlg, converter_ok, "converter_ok"); return converterdlg; }
static GtkWidget* create_notepage_fileselect() { GtkWidget *grid_main; GtkWidget *grid_controls; GtkWidget *label1; // *label2; GtkWidget *file_select; GtkWidget *button_process_configfile; // create a treestore to store parsed data GtkTreeStore *store; GtkWidget *tree; store = gtk_tree_store_new (N_COLUMNS, G_TYPE_STRING, G_TYPE_STRING); // create a view tree = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store)); // view now holds a reference. Get rid of our own reference: g_object_unref (G_OBJECT (store)); // setup tree view setup_config_file_treeview (GTK_TREE_VIEW(tree)); // setup config file data FileData * config_file = init_config_file(GTK_TREE_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(tree)))); label1 = gtk_label_new("Select config file"); gtk_label_set_line_wrap(GTK_LABEL(label1), TRUE); file_select = gtk_combo_box_text_new(); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(file_select), "gtk_config_file_1.conf"); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(file_select), "gtk_config_file_2.conf"); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(file_select), "pdpgui_gs_params_default.conf"); g_signal_connect (file_select, "changed", G_CALLBACK(select_file), (gpointer)(config_file) ); // aesthetic: give this a standard icon button_process_configfile = gtk_button_new_with_label ("Load from file"); g_signal_connect (button_process_configfile, "clicked", G_CALLBACK(load_from_file), (gpointer)(config_file)); grid_main = gtk_grid_new(); grid_controls = gtk_grid_new(); gtk_grid_attach (GTK_GRID(grid_controls), label1, 0, 0, 1, 1); gtk_grid_attach (GTK_GRID(grid_controls), file_select, 0, 1, 1, 1); gtk_grid_attach (GTK_GRID(grid_controls), config_file->filename_label, 0, 2, 1, 1); gtk_grid_attach (GTK_GRID(grid_controls), button_process_configfile, 0, 3, 1, 1); // gtk_widget_set_vexpand (GTK_WIDGET(grid_controls), TRUE); gtk_grid_attach (GTK_GRID(grid_main), grid_controls, 0, 0, 1, 1); gtk_grid_attach (GTK_GRID(grid_main), tree, 1, 0, 1, 1); gtk_grid_set_column_spacing (GTK_GRID(grid_main), 30); gtk_widget_set_vexpand (GTK_WIDGET(grid_main), TRUE); gtk_widget_set_hexpand (GTK_WIDGET(grid_main), TRUE); gtk_widget_show_all(grid_main); g_signal_connect (G_OBJECT(grid_main), "destroy", G_CALLBACK (destroy_notepage_fileselect), (gpointer)config_file); return (grid_main); }
GtkWidget* create_convpreset_editor (void) { GtkWidget *convpreset_editor; GtkWidget *dialog_vbox7; GtkWidget *vbox27; GtkWidget *hbox70; GtkWidget *label105; GtkWidget *title; GtkWidget *hbox96; GtkWidget *label120; GtkWidget *ext; GtkWidget *hbox72; GtkWidget *label106; GtkWidget *hbox93; GtkWidget *encoder; GtkWidget *custom4; GtkWidget *label124; GtkWidget *hbox73; GtkWidget *label107; GtkWidget *method; GtkWidget *frame9; GtkWidget *alignment21; GtkWidget *table2; GtkWidget *apev2; GtkWidget *id3v1; GtkWidget *oggvorbis; GtkWidget *flac; GtkWidget *hbox104; GtkWidget *id3v2; GtkWidget *id3v2_version; GtkWidget *mp4; GtkWidget *label125; GtkWidget *dialog_action_area6; GtkWidget *convpreset_cancel; GtkWidget *convpreset_ok; convpreset_editor = gtk_dialog_new (); gtk_window_set_title (GTK_WINDOW (convpreset_editor), _("Edit Encoder Preset")); gtk_window_set_modal (GTK_WINDOW (convpreset_editor), TRUE); gtk_window_set_type_hint (GTK_WINDOW (convpreset_editor), GDK_WINDOW_TYPE_HINT_DIALOG); dialog_vbox7 = gtk_dialog_get_content_area (GTK_DIALOG (convpreset_editor)); gtk_widget_show (dialog_vbox7); vbox27 = gtk_vbox_new (FALSE, 8); gtk_widget_show (vbox27); gtk_box_pack_start (GTK_BOX (dialog_vbox7), vbox27, TRUE, TRUE, 0); gtk_container_set_border_width (GTK_CONTAINER (vbox27), 12); hbox70 = gtk_hbox_new (FALSE, 8); gtk_widget_show (hbox70); gtk_box_pack_start (GTK_BOX (vbox27), hbox70, FALSE, TRUE, 0); label105 = gtk_label_new (_("Title:")); gtk_widget_show (label105); gtk_box_pack_start (GTK_BOX (hbox70), label105, FALSE, FALSE, 0); title = gtk_entry_new (); gtk_widget_show (title); gtk_box_pack_start (GTK_BOX (hbox70), title, TRUE, TRUE, 0); gtk_entry_set_text (GTK_ENTRY (title), _("Untitled Encoder")); gtk_entry_set_invisible_char (GTK_ENTRY (title), 9679); gtk_entry_set_activates_default (GTK_ENTRY (title), TRUE); hbox96 = gtk_hbox_new (FALSE, 9); gtk_widget_show (hbox96); gtk_box_pack_start (GTK_BOX (vbox27), hbox96, FALSE, TRUE, 0); label120 = gtk_label_new (_("Output file extension:")); gtk_widget_show (label120); gtk_box_pack_start (GTK_BOX (hbox96), label120, FALSE, FALSE, 0); ext = gtk_entry_new (); gtk_widget_show (ext); gtk_box_pack_start (GTK_BOX (hbox96), ext, TRUE, TRUE, 0); gtk_widget_set_tooltip_text (ext, _("E.g. mp3")); gtk_entry_set_invisible_char (GTK_ENTRY (ext), 9679); gtk_entry_set_activates_default (GTK_ENTRY (ext), TRUE); hbox72 = gtk_hbox_new (FALSE, 8); gtk_widget_show (hbox72); gtk_box_pack_start (GTK_BOX (vbox27), hbox72, FALSE, TRUE, 0); label106 = gtk_label_new (_("Command line:")); gtk_widget_show (label106); gtk_box_pack_start (GTK_BOX (hbox72), label106, FALSE, FALSE, 0); hbox93 = gtk_hbox_new (FALSE, 0); gtk_widget_show (hbox93); gtk_box_pack_start (GTK_BOX (hbox72), hbox93, TRUE, TRUE, 0); encoder = gtk_entry_new (); gtk_widget_show (encoder); gtk_box_pack_start (GTK_BOX (hbox93), encoder, TRUE, TRUE, 0); gtk_widget_set_tooltip_text (encoder, _("Example: lame - %o\n%i for input file, %o for output file, - for stdin")); gtk_entry_set_invisible_char (GTK_ENTRY (encoder), 9679); gtk_entry_set_activates_default (GTK_ENTRY (encoder), TRUE); custom4 = encoder_cmdline_help_link_create ("custom4", "", "", 0, 0); gtk_widget_show (custom4); gtk_box_pack_start (GTK_BOX (hbox93), custom4, TRUE, TRUE, 0); gtk_widget_set_can_focus(custom4, FALSE); gtk_widget_set_can_default(custom4, FALSE); label124 = gtk_label_new (_("<small>%o - output file name\n%i - temporary input file name</small>")); gtk_widget_show (label124); gtk_box_pack_start (GTK_BOX (vbox27), label124, FALSE, FALSE, 0); gtk_label_set_use_markup (GTK_LABEL (label124), TRUE); hbox73 = gtk_hbox_new (FALSE, 8); gtk_widget_show (hbox73); gtk_box_pack_start (GTK_BOX (vbox27), hbox73, FALSE, TRUE, 0); label107 = gtk_label_new (_("Method:")); gtk_widget_show (label107); gtk_box_pack_start (GTK_BOX (hbox73), label107, FALSE, FALSE, 0); method = gtk_combo_box_text_new (); gtk_widget_show (method); gtk_box_pack_start (GTK_BOX (hbox73), method, TRUE, TRUE, 0); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (method), _("Pipe")); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (method), _("Temp File")); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (method), _("Source File")); frame9 = gtk_frame_new (NULL); gtk_widget_show (frame9); gtk_box_pack_start (GTK_BOX (vbox27), frame9, FALSE, FALSE, 0); alignment21 = gtk_alignment_new (0.5, 0.5, 1, 1); gtk_widget_show (alignment21); gtk_container_add (GTK_CONTAINER (frame9), alignment21); gtk_alignment_set_padding (GTK_ALIGNMENT (alignment21), 0, 0, 12, 0); table2 = gtk_table_new (2, 3, FALSE); gtk_widget_show (table2); gtk_container_add (GTK_CONTAINER (alignment21), table2); gtk_container_set_border_width (GTK_CONTAINER (table2), 8); gtk_table_set_col_spacings (GTK_TABLE (table2), 8); apev2 = gtk_check_button_new_with_mnemonic (_("APEv2")); gtk_widget_show (apev2); gtk_table_attach (GTK_TABLE (table2), apev2, 1, 2, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); id3v1 = gtk_check_button_new_with_mnemonic (_("ID3v1")); gtk_widget_show (id3v1); gtk_table_attach (GTK_TABLE (table2), id3v1, 2, 3, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); oggvorbis = gtk_check_button_new_with_mnemonic (_("OggVorbis")); gtk_widget_show (oggvorbis); gtk_table_attach (GTK_TABLE (table2), oggvorbis, 2, 3, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); flac = gtk_check_button_new_with_mnemonic (_("FLAC")); gtk_widget_show (flac); gtk_table_attach (GTK_TABLE (table2), flac, 1, 2, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); hbox104 = gtk_hbox_new (FALSE, 0); gtk_widget_show (hbox104); gtk_table_attach (GTK_TABLE (table2), hbox104, 0, 1, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); id3v2 = gtk_check_button_new_with_mnemonic (_("ID3v2")); gtk_widget_show (id3v2); gtk_box_pack_start (GTK_BOX (hbox104), id3v2, FALSE, FALSE, 0); id3v2_version = gtk_combo_box_text_new (); gtk_widget_show (id3v2_version); gtk_box_pack_start (GTK_BOX (hbox104), id3v2_version, TRUE, TRUE, 0); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (id3v2_version), "2.3"); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (id3v2_version), "2.4"); mp4 = gtk_check_button_new_with_mnemonic (_("MP4")); gtk_widget_show (mp4); gtk_table_attach (GTK_TABLE (table2), mp4, 0, 1, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); label125 = gtk_label_new (_("<b>Tag writer</b>")); gtk_widget_show (label125); gtk_frame_set_label_widget (GTK_FRAME (frame9), label125); gtk_label_set_use_markup (GTK_LABEL (label125), TRUE); dialog_action_area6 = gtk_dialog_get_action_area (GTK_DIALOG (convpreset_editor)); gtk_widget_show (dialog_action_area6); gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area6), GTK_BUTTONBOX_END); convpreset_cancel = gtk_button_new_from_stock ("gtk-cancel"); gtk_widget_show (convpreset_cancel); gtk_dialog_add_action_widget (GTK_DIALOG (convpreset_editor), convpreset_cancel, GTK_RESPONSE_CANCEL); gtk_widget_set_can_default(convpreset_cancel, TRUE); convpreset_ok = gtk_button_new_from_stock ("gtk-ok"); gtk_widget_show (convpreset_ok); gtk_dialog_add_action_widget (GTK_DIALOG (convpreset_editor), convpreset_ok, GTK_RESPONSE_OK); gtk_widget_set_can_default(convpreset_ok, TRUE); g_signal_connect ((gpointer) encoder, "changed", G_CALLBACK (on_encoder_changed), NULL); /* Store pointers to all widgets, for use by lookup_widget(). */ GLADE_HOOKUP_OBJECT_NO_REF (convpreset_editor, convpreset_editor, "convpreset_editor"); GLADE_HOOKUP_OBJECT_NO_REF (convpreset_editor, dialog_vbox7, "dialog_vbox7"); GLADE_HOOKUP_OBJECT (convpreset_editor, vbox27, "vbox27"); GLADE_HOOKUP_OBJECT (convpreset_editor, hbox70, "hbox70"); GLADE_HOOKUP_OBJECT (convpreset_editor, label105, "label105"); GLADE_HOOKUP_OBJECT (convpreset_editor, title, "title"); GLADE_HOOKUP_OBJECT (convpreset_editor, hbox96, "hbox96"); GLADE_HOOKUP_OBJECT (convpreset_editor, label120, "label120"); GLADE_HOOKUP_OBJECT (convpreset_editor, ext, "ext"); GLADE_HOOKUP_OBJECT (convpreset_editor, hbox72, "hbox72"); GLADE_HOOKUP_OBJECT (convpreset_editor, label106, "label106"); GLADE_HOOKUP_OBJECT (convpreset_editor, hbox93, "hbox93"); GLADE_HOOKUP_OBJECT (convpreset_editor, encoder, "encoder"); GLADE_HOOKUP_OBJECT (convpreset_editor, custom4, "custom4"); GLADE_HOOKUP_OBJECT (convpreset_editor, label124, "label124"); GLADE_HOOKUP_OBJECT (convpreset_editor, hbox73, "hbox73"); GLADE_HOOKUP_OBJECT (convpreset_editor, label107, "label107"); GLADE_HOOKUP_OBJECT (convpreset_editor, method, "method"); GLADE_HOOKUP_OBJECT (convpreset_editor, frame9, "frame9"); GLADE_HOOKUP_OBJECT (convpreset_editor, alignment21, "alignment21"); GLADE_HOOKUP_OBJECT (convpreset_editor, table2, "table2"); GLADE_HOOKUP_OBJECT (convpreset_editor, apev2, "apev2"); GLADE_HOOKUP_OBJECT (convpreset_editor, id3v1, "id3v1"); GLADE_HOOKUP_OBJECT (convpreset_editor, oggvorbis, "oggvorbis"); GLADE_HOOKUP_OBJECT (convpreset_editor, flac, "flac"); GLADE_HOOKUP_OBJECT (convpreset_editor, hbox104, "hbox104"); GLADE_HOOKUP_OBJECT (convpreset_editor, id3v2, "id3v2"); GLADE_HOOKUP_OBJECT (convpreset_editor, id3v2_version, "id3v2_version"); GLADE_HOOKUP_OBJECT (convpreset_editor, mp4, "mp4"); GLADE_HOOKUP_OBJECT (convpreset_editor, label125, "label125"); GLADE_HOOKUP_OBJECT_NO_REF (convpreset_editor, dialog_action_area6, "dialog_action_area6"); GLADE_HOOKUP_OBJECT (convpreset_editor, convpreset_cancel, "convpreset_cancel"); GLADE_HOOKUP_OBJECT (convpreset_editor, convpreset_ok, "convpreset_ok"); return convpreset_editor; }
int main (int argc, char **argv) { GtkWidget *window; GtkWidget *sw; GtkWidget *tv; GtkWidget *box; GtkWidget *combo_box; GtkTreeModel *model; GdkContentFormats *targets; gint i; gtk_init (); if (g_getenv ("RTL")) gtk_widget_set_default_direction (GTK_TEXT_DIR_RTL); our_pixbuf = gdk_pixbuf_new_from_xpm_data ((const char **) book_closed_xpm); #if 0 models[MODEL_TYPES] = GTK_TREE_MODEL (gtk_tree_model_types_new ()); #endif models[MODEL_LIST] = create_list_model (); models[MODEL_TREE] = create_tree_model (); model = create_list_model (); models[MODEL_SORTED_LIST] = gtk_tree_model_sort_new_with_model (model); g_object_unref (model); model = create_tree_model (); models[MODEL_SORTED_TREE] = gtk_tree_model_sort_new_with_model (model); g_object_unref (model); models[MODEL_EMPTY_LIST] = GTK_TREE_MODEL (gtk_list_store_new (1, G_TYPE_INT)); models[MODEL_EMPTY_TREE] = GTK_TREE_MODEL (gtk_tree_store_new (1, G_TYPE_INT)); models[MODEL_NULL] = NULL; run_automated_tests (); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL); gtk_window_set_default_size (GTK_WINDOW (window), 430, 400); box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_container_add (GTK_CONTAINER (window), box); tv = gtk_tree_view_new_with_model (models[0]); g_signal_connect (tv, "row-activated", G_CALLBACK (on_row_activated), NULL); targets = gdk_content_formats_new (row_targets, G_N_ELEMENTS (row_targets)); gtk_tree_view_enable_model_drag_source (GTK_TREE_VIEW (tv), GDK_BUTTON1_MASK, targets, GDK_ACTION_MOVE | GDK_ACTION_COPY); gtk_tree_view_enable_model_drag_dest (GTK_TREE_VIEW (tv), targets, GDK_ACTION_MOVE | GDK_ACTION_COPY); gdk_content_formats_unref (targets); /* Model menu */ combo_box = gtk_combo_box_text_new (); gtk_widget_set_halign (combo_box, GTK_ALIGN_CENTER); for (i = 0; i < MODEL_LAST; i++) gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo_box), model_names[i]); gtk_container_add (GTK_CONTAINER (box), combo_box); g_signal_connect (combo_box, "changed", G_CALLBACK (model_selected), tv); /* Columns menu */ combo_box = gtk_combo_box_text_new (); gtk_widget_set_halign (combo_box, GTK_ALIGN_CENTER); for (i = 0; i < COLUMNS_LAST; i++) gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo_box), column_type_names[i]); gtk_container_add (GTK_CONTAINER (box), combo_box); set_columns_type (GTK_TREE_VIEW (tv), COLUMNS_LOTS); gtk_combo_box_set_active (GTK_COMBO_BOX (combo_box), COLUMNS_LOTS); g_signal_connect (combo_box, "changed", G_CALLBACK (columns_selected), tv); sw = gtk_scrolled_window_new (NULL, NULL); gtk_widget_set_hexpand (sw, TRUE); gtk_widget_set_vexpand (sw, TRUE); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_container_add (GTK_CONTAINER (box), sw); gtk_container_add (GTK_CONTAINER (sw), tv); gtk_widget_show (window); gtk_main (); return 0; }
static GtkWidget *MoveFilterSetup(movefilter aamf[MAX_FILTER_PLIES][MAX_FILTER_PLIES], int *pfOK) { GtkWidget *pwSetup; GtkWidget *pwFrame; int i, j; movefiltersetupwidget *pmfsw; GtkWidget *pwNotebook; GtkWidget *pwvbox; pwSetup = gtk_vbox_new(FALSE, 4); pmfsw = (movefiltersetupwidget *) g_malloc(sizeof(movefiltersetupwidget)); /* predefined settings */ /* output widget (with "User defined", or "Large" etc */ pwFrame = gtk_frame_new(_("Predefined move filters:")); gtk_box_pack_start(GTK_BOX(pwSetup), pwFrame, TRUE, TRUE, 0); pmfsw->pwOptionMenu = gtk_combo_box_text_new(); for (i = 0; i <= NUM_MOVEFILTER_SETTINGS; i++) { if (i < NUM_MOVEFILTER_SETTINGS) gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(pmfsw->pwOptionMenu), Q_(aszMoveFilterSettings[i])); else gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(pmfsw->pwOptionMenu), _("user defined")); } g_signal_connect(G_OBJECT(pmfsw->pwOptionMenu), "changed", G_CALLBACK(SetupSettingsMenuActivate), pmfsw); gtk_container_add(GTK_CONTAINER(pwFrame), pmfsw->pwOptionMenu); /* notebook with pages for each ply */ pwNotebook = gtk_notebook_new(); gtk_box_pack_start(GTK_BOX(pwSetup), pwNotebook, FALSE, FALSE, 0); for (i = 0; i < MAX_FILTER_PLIES; ++i) { char *sz = g_strdup_printf(_("%d-ply"), i + 1); pwvbox = gtk_vbox_new(FALSE, 4); gtk_notebook_append_page(GTK_NOTEBOOK(pwNotebook), pwvbox, gtk_label_new(sz)); g_free(sz); for (j = 0; j <= i; ++j) { sz = g_strdup_printf(_("%d-ply"), j); pwFrame = gtk_frame_new(sz); g_free(sz); gtk_box_pack_start(GTK_BOX(pwvbox), pwFrame, FALSE, FALSE, 4); gtk_container_add(GTK_CONTAINER(pwFrame), MoveFilterPage(i, j, aamf, pmfsw)); } } g_object_set_data_full(G_OBJECT(pwSetup), "user_data", pmfsw, g_free); pmfsw->pfOK = pfOK; pmfsw->pmf = aamf[0]; MoveFilterSetupSetValues(aamf, pmfsw); return pwSetup; }
int main (int argc, char **argv) { GdkScreen *screen; GtkWidget *nb; GtkWidget *general_vbox; GtkWidget *behaviour_vbox; GtkWidget *placement_vbox; GtkWidget *widget; GtkWidget *vbox; GtkWidget *vbox1; GtkWidget *hbox; GtkWidget *hbox1; GtkWidget *hbox2; GtkWidget *hbox3; GtkWidget *content_area; gchar *str; const char *current_wm; int i; bindtextdomain (GETTEXT_PACKAGE, MATELOCALEDIR); bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8"); textdomain (GETTEXT_PACKAGE); gtk_init (&argc, &argv); screen = gdk_display_get_default_screen (gdk_display_get_default ()); current_wm = gdk_x11_screen_get_window_manager_name (screen); if (g_strcmp0 (current_wm, WM_COMMON_METACITY) == 0) { mate_metacity_config_tool (); return 0; } if (g_strcmp0 (current_wm, WM_COMMON_MARCO) != 0) { wm_unsupported (); return 1; } marco_settings = g_settings_new (MARCO_SCHEMA); /* Window */ dialog_win = gtk_dialog_new_with_buttons (_("Window Preferences"), NULL, GTK_DIALOG_MODAL, GTK_STOCK_HELP, GTK_RESPONSE_HELP, GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, NULL); //gtk_window_set_resizable (GTK_WINDOW (dialog_win), FALSE); gtk_window_set_icon_name (GTK_WINDOW (dialog_win), "preferences-system-windows"); gtk_container_set_border_width (GTK_CONTAINER (dialog_win), 10); nb = gtk_notebook_new (); general_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); behaviour_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); placement_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); widget = gtk_label_new (_("General")); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); gtk_box_pack_start (GTK_BOX (hbox), general_vbox, FALSE, FALSE, 6); gtk_notebook_append_page (GTK_NOTEBOOK (nb), hbox, widget); widget = gtk_label_new (_("Behaviour")); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); gtk_box_pack_start (GTK_BOX (hbox), behaviour_vbox, FALSE, FALSE, 6); gtk_notebook_append_page (GTK_NOTEBOOK (nb), hbox, widget); widget = gtk_label_new (_("Placement")); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); gtk_box_pack_start (GTK_BOX (hbox), placement_vbox, FALSE, FALSE, 6); gtk_notebook_append_page (GTK_NOTEBOOK (nb), hbox, widget); /* Compositing manager */ widget = title_label_new (N_("Compositing Manager")); gtk_box_pack_start (GTK_BOX (general_vbox), widget, FALSE, FALSE, 6); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); hbox1 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); compositing_checkbutton = gtk_check_button_new_with_mnemonic (_("Enable software _compositing window manager")); compositing_fast_alt_tab_checkbutton = gtk_check_button_new_with_mnemonic (_("Disable _thumbnails in Alt-Tab")); gtk_box_pack_start (GTK_BOX (vbox), compositing_checkbutton, FALSE, FALSE, 6); gtk_box_pack_start (GTK_BOX (hbox1), compositing_fast_alt_tab_checkbutton, FALSE, FALSE, 6); gtk_box_pack_start (GTK_BOX (vbox), hbox1, FALSE, FALSE, 6); gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 6); gtk_box_pack_start (GTK_BOX (general_vbox), hbox, FALSE, FALSE, 6); /* Titlebar buttons */ widget = title_label_new (N_("Titlebar Buttons")); gtk_box_pack_start (GTK_BOX (general_vbox), widget, FALSE, FALSE, 6); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); widget = gtk_label_new (_("Position:")); gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 6); titlebar_layout_optionmenu = gtk_combo_box_text_new (); gtk_box_pack_start (GTK_BOX (hbox), titlebar_layout_optionmenu, FALSE, FALSE, 6); gtk_box_pack_start (GTK_BOX (general_vbox), hbox, FALSE, FALSE, 6); /* New Windows */ widget = title_label_new (N_("New Windows")); gtk_box_pack_start (GTK_BOX (placement_vbox), widget, FALSE, FALSE, 6); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); center_new_windows_checkbutton = gtk_check_button_new_with_mnemonic (_("Center _new windows")); gtk_box_pack_start (GTK_BOX (hbox), center_new_windows_checkbutton, FALSE, FALSE, 6); gtk_box_pack_start (GTK_BOX (placement_vbox), hbox, FALSE, FALSE, 6); /* Window Snapping */ widget = title_label_new (N_("Window Snapping")); gtk_box_pack_start (GTK_BOX (placement_vbox), widget, FALSE, FALSE, 6); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); side_by_side_tiling_checkbutton = gtk_check_button_new_with_mnemonic (_("Enable side by side _tiling")); gtk_box_pack_start (GTK_BOX (hbox), side_by_side_tiling_checkbutton, FALSE, FALSE, 6); gtk_box_pack_start (GTK_BOX (placement_vbox), hbox, FALSE, FALSE, 6); /* Window Selection */ widget = title_label_new (N_("Window Selection")); gtk_box_pack_start (GTK_BOX (behaviour_vbox), widget, FALSE, FALSE, 6); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); vbox1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); hbox1 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); hbox3 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); focus_mode_checkbutton = gtk_check_button_new_with_mnemonic (_("_Select windows when the mouse moves over them")); gtk_box_pack_start (GTK_BOX (vbox), focus_mode_checkbutton, FALSE, FALSE, 6); focus_mode_mouse_checkbutton = gtk_check_button_new_with_mnemonic (_("U_nselect windows when the mouse leaves them")); gtk_box_pack_start (GTK_BOX (hbox1), focus_mode_mouse_checkbutton, FALSE, FALSE, 6); gtk_box_pack_start (GTK_BOX (vbox1), hbox1, FALSE, FALSE, 6); autoraise_checkbutton = gtk_check_button_new_with_mnemonic (_("_Raise selected windows after an interval")); gtk_box_pack_start (GTK_BOX (hbox2), autoraise_checkbutton, FALSE, FALSE, 6); gtk_box_pack_start (GTK_BOX (vbox1), hbox2, FALSE, FALSE, 6); autoraise_delay_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); autoraise_delay_slider = gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL, 0, 10, 0.2); widget = gtk_label_new_with_mnemonic (_("_Interval before raising:")); gtk_box_pack_start (GTK_BOX (autoraise_delay_hbox), widget, FALSE, FALSE, 6); gtk_box_pack_start (GTK_BOX (autoraise_delay_hbox), autoraise_delay_slider, TRUE, TRUE, 6); gtk_label_set_mnemonic_widget (GTK_LABEL (widget), autoraise_delay_slider); widget = gtk_label_new (_("seconds")); gtk_range_set_increments (GTK_RANGE (autoraise_delay_slider), 0.2, 1.0); gtk_box_pack_start (GTK_BOX (autoraise_delay_hbox), widget, FALSE, FALSE, 6); gtk_box_pack_start (GTK_BOX (vbox1), autoraise_delay_hbox, FALSE, FALSE, 6); gtk_box_pack_start (GTK_BOX (hbox3), vbox1, FALSE, FALSE, 6); gtk_box_pack_start (GTK_BOX (vbox), hbox3, FALSE, FALSE, 6); gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 6); gtk_box_pack_start (GTK_BOX (behaviour_vbox), hbox, FALSE, FALSE, 6); /* Titlebar Action */ widget = title_label_new (N_("Titlebar Action")); gtk_box_pack_start (GTK_BOX (behaviour_vbox), widget, FALSE, FALSE, 6); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); widget = gtk_label_new_with_mnemonic (_("_Double-click titlebar to perform this action:")); gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 6); double_click_titlebar_optionmenu = gtk_combo_box_text_new (); gtk_label_set_mnemonic_widget (GTK_LABEL (widget), double_click_titlebar_optionmenu); gtk_box_pack_start (GTK_BOX (hbox), double_click_titlebar_optionmenu, FALSE, FALSE, 6); gtk_box_pack_start (GTK_BOX (behaviour_vbox), hbox, FALSE, FALSE, 6); /* Movement Key */ widget = title_label_new (N_("Movement Key")); gtk_box_pack_start (GTK_BOX (behaviour_vbox), widget, FALSE, FALSE, 6); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); widget = gtk_label_new_with_mnemonic (_("To move a window, press-and-hold this key then grab the window:")); #if GTK_CHECK_VERSION (3, 16, 0) gtk_label_set_xalign (GTK_LABEL (widget), 0.0); gtk_label_set_yalign (GTK_LABEL (widget), 0.0); #else gtk_misc_set_alignment (GTK_MISC (widget), 0.0, 0.0); #endif gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE, 6); alt_click_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); gtk_label_set_mnemonic_widget (GTK_LABEL (widget), alt_click_vbox); gtk_box_pack_start (GTK_BOX (vbox), alt_click_vbox, FALSE, FALSE, 6); gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 6); gtk_box_pack_start (GTK_BOX (behaviour_vbox), hbox, FALSE, FALSE, 6); reload_mouse_modifiers (); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (titlebar_layout_optionmenu), _("Right")); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (titlebar_layout_optionmenu), _("Left")); str = g_settings_get_string (marco_settings, MARCO_BUTTON_LAYOUT_KEY); gtk_combo_box_set_active (GTK_COMBO_BOX (titlebar_layout_optionmenu), g_strcmp0 (str, MARCO_BUTTON_LAYOUT_RIGHT) == 0 ? 0 : 1); g_free (str); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (double_click_titlebar_optionmenu), _("Roll up")); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (double_click_titlebar_optionmenu), _("Maximize")); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (double_click_titlebar_optionmenu), _("Maximize Horizontally")); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (double_click_titlebar_optionmenu), _("Maximize Vertically")); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (double_click_titlebar_optionmenu), _("Minimize")); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (double_click_titlebar_optionmenu), _("None")); gtk_combo_box_set_active (GTK_COMBO_BOX (double_click_titlebar_optionmenu), g_settings_get_enum (marco_settings, MARCO_DOUBLE_CLICK_TITLEBAR_KEY)); set_alt_click_value (); gtk_range_set_value (GTK_RANGE (autoraise_delay_slider), g_settings_get_int (marco_settings, MARCO_AUTORAISE_DELAY_KEY) / 1000.0); gtk_combo_box_set_active (GTK_COMBO_BOX (double_click_titlebar_optionmenu), g_settings_get_enum (marco_settings, MARCO_DOUBLE_CLICK_TITLEBAR_KEY)); g_signal_connect (G_OBJECT (dialog_win), "response", G_CALLBACK (response_cb), NULL); g_signal_connect (G_OBJECT (dialog_win), "destroy", G_CALLBACK (gtk_main_quit), NULL); g_signal_connect (marco_settings, "changed", G_CALLBACK (marco_settings_changed_callback), NULL); g_settings_bind (marco_settings, MARCO_COMPOSITING_MANAGER_KEY, compositing_checkbutton, "active", G_SETTINGS_BIND_DEFAULT); g_settings_bind (marco_settings, MARCO_COMPOSITING_FAST_ALT_TAB_KEY, compositing_fast_alt_tab_checkbutton, "active", G_SETTINGS_BIND_DEFAULT); g_settings_bind (marco_settings, MARCO_SIDE_BY_SIDE_TILING_KEY, side_by_side_tiling_checkbutton, "active", G_SETTINGS_BIND_DEFAULT); g_settings_bind (marco_settings, MARCO_CENTER_NEW_WINDOWS_KEY, center_new_windows_checkbutton, "active", G_SETTINGS_BIND_DEFAULT); g_signal_connect (marco_settings, "changed::" MARCO_FOCUS_KEY, G_CALLBACK (mouse_focus_changed_callback), NULL); /* Initialize the checkbox state appropriately */ mouse_focus_changed_callback(marco_settings, MARCO_FOCUS_KEY, NULL); g_signal_connect (focus_mode_checkbutton, "toggled", G_CALLBACK (mouse_focus_toggled_callback), NULL); g_signal_connect (focus_mode_mouse_checkbutton, "toggled", G_CALLBACK (mouse_focus_toggled_callback), NULL); g_settings_bind (marco_settings, MARCO_AUTORAISE_KEY, autoraise_checkbutton, "active", G_SETTINGS_BIND_DEFAULT); g_signal_connect (autoraise_delay_slider, "value_changed", G_CALLBACK (autoraise_delay_value_changed_callback), NULL); g_signal_connect (double_click_titlebar_optionmenu, "changed", G_CALLBACK (double_click_titlebar_changed_callback), NULL); g_signal_connect (titlebar_layout_optionmenu, "changed", G_CALLBACK (titlebar_layout_changed_callback), NULL); g_signal_connect (G_OBJECT (screen), "window_manager_changed", G_CALLBACK (wm_changed_callback), NULL); i = 0; while (i < n_mouse_modifiers) { g_signal_connect (G_OBJECT (mouse_modifiers[i].radio), "toggled", G_CALLBACK (alt_click_radio_toggled_callback), &mouse_modifiers[i]); ++i; } /* update sensitivity */ update_sensitivity (); capplet_set_icon (dialog_win, "preferences-system-windows"); content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog_win)); gtk_box_pack_start (GTK_BOX (content_area), nb, TRUE, TRUE, 0); gtk_widget_show_all (dialog_win); gtk_main (); g_object_unref (marco_settings); return 0; }
static void background_area (void) { GtkWidget *window, *widget, *label, *main_vbox; GtkWidget *iconview, *frame, *vbox, *hbox; window = gtk_window_new (GTK_WINDOW_TOPLEVEL); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4); main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 4); gtk_widget_show (hbox); gtk_widget_show (main_vbox); gtk_container_add (GTK_CONTAINER (window), main_vbox); gtk_window_set_title (GTK_WINDOW (window), "Background Area"); label = gtk_label_new ("In this example, row spacing gets devided into the background area, " "column spacing is added between each background area, item_padding is " "prepended space distributed to the background area."); gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); gtk_label_set_width_chars (GTK_LABEL (label), 40); gtk_widget_show (label); gtk_box_pack_start (GTK_BOX (main_vbox), label, FALSE, FALSE); iconview = focus_iconview (TRUE, NULL, NULL); frame = gtk_frame_new (NULL); gtk_widget_show (frame); gtk_widget_set_valign (frame, GTK_ALIGN_CENTER); gtk_widget_set_halign (frame, GTK_ALIGN_FILL); gtk_container_add (GTK_CONTAINER (frame), iconview); gtk_box_pack_end (GTK_BOX (hbox), frame, TRUE, TRUE); /* Now add some controls */ vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 4); gtk_widget_show (vbox); gtk_box_pack_end (GTK_BOX (hbox), vbox, FALSE, FALSE); gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, FALSE); widget = gtk_combo_box_text_new (); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Horizontal"); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Vertical"); gtk_combo_box_set_active (GTK_COMBO_BOX (widget), 0); gtk_widget_show (widget); gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE); g_signal_connect (G_OBJECT (widget), "changed", G_CALLBACK (orientation_changed), iconview); widget = gtk_spin_button_new_with_range (0, 10, 1); label = gtk_label_new ("Cell spacing"); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4); gtk_widget_show (hbox); gtk_widget_show (label); gtk_widget_show (widget); gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, TRUE); gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE); g_signal_connect (G_OBJECT (widget), "value-changed", G_CALLBACK (cell_spacing_changed), iconview); widget = gtk_spin_button_new_with_range (0, 10, 1); gtk_spin_button_set_value (GTK_SPIN_BUTTON (widget), gtk_icon_view_get_row_spacing (GTK_ICON_VIEW (iconview))); label = gtk_label_new ("Row spacing"); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4); gtk_widget_show (hbox); gtk_widget_show (label); gtk_widget_show (widget); gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, TRUE); gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE); g_signal_connect (G_OBJECT (widget), "value-changed", G_CALLBACK (row_spacing_changed), iconview); widget = gtk_spin_button_new_with_range (0, 30, 1); label = gtk_label_new ("Item padding"); gtk_spin_button_set_value (GTK_SPIN_BUTTON (widget), gtk_icon_view_get_item_padding (GTK_ICON_VIEW (iconview))); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4); gtk_widget_show (hbox); gtk_widget_show (label); gtk_widget_show (widget); gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, TRUE); gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE); g_signal_connect (G_OBJECT (widget), "value-changed", G_CALLBACK (item_padding_changed), iconview); gtk_widget_show (window); }
static void remmina_ftp_client_init(RemminaFTPClient *client) { RemminaFTPClientPriv *priv; GtkWidget *vpaned; GtkWidget *scrolledwindow; GtkWidget *widget; GtkCellRenderer *renderer; GtkTreeViewColumn *column; GtkWidget *vbox; priv = g_new0(RemminaFTPClientPriv, 1); client->priv = priv; /* Main container */ gtk_box_set_homogeneous(GTK_BOX(client), FALSE); gtk_box_set_spacing(GTK_BOX(client), 4); /* Toolbar */ remmina_ftp_client_create_toolbar(client); /* The Paned to separate File List and Task List */ vpaned = gtk_vpaned_new(); gtk_widget_show(vpaned); gtk_box_pack_start(GTK_BOX(client), vpaned, TRUE, TRUE, 0); priv->vpaned = vpaned; /* Remote */ vbox = gtk_vbox_new(FALSE, 0); gtk_widget_show(vbox); gtk_paned_pack1(GTK_PANED(vpaned), vbox, TRUE, FALSE); /* Remote Directory */ widget = gtk_combo_box_text_new_with_entry(); gtk_widget_show(widget); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(widget), "/"); gtk_box_pack_start(GTK_BOX(vbox), widget, FALSE, TRUE, 0); priv->directory_combo = widget; /* Remote File List */ scrolledwindow = gtk_scrolled_window_new(NULL, NULL); gtk_widget_show(scrolledwindow); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS); gtk_box_pack_start(GTK_BOX(vbox), scrolledwindow, TRUE, TRUE, 0); widget = gtk_tree_view_new(); gtk_widget_show(widget); gtk_container_add(GTK_CONTAINER(scrolledwindow), widget); gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(widget)), GTK_SELECTION_MULTIPLE); priv->file_list_view = widget; /* Remote File List - Columns */ column = gtk_tree_view_column_new(); gtk_tree_view_column_set_title(column, _("File Name")); gtk_tree_view_column_set_expand(column, TRUE); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_sort_column_id(column, REMMINA_FTP_FILE_COLUMN_NAME_SORT); renderer = gtk_cell_renderer_pixbuf_new(); gtk_tree_view_column_pack_start(column, renderer, FALSE); gtk_tree_view_column_set_cell_data_func(column, renderer, remmina_ftp_client_cell_data_filetype_pixbuf, NULL, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(column, renderer, FALSE); gtk_tree_view_column_add_attribute(column, renderer, "text", REMMINA_FTP_FILE_COLUMN_NAME); gtk_tree_view_append_column(GTK_TREE_VIEW(priv->file_list_view), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes(_("Size"), renderer, NULL); gtk_tree_view_column_set_alignment(column, 1.0); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_cell_data_func(column, renderer, remmina_ftp_client_cell_data_size, NULL, NULL); gtk_tree_view_column_set_sort_column_id(column, REMMINA_FTP_FILE_COLUMN_SIZE); gtk_tree_view_append_column(GTK_TREE_VIEW(priv->file_list_view), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes(_("User"), renderer, "text", REMMINA_FTP_FILE_COLUMN_USER, NULL); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_sort_column_id(column, REMMINA_FTP_FILE_COLUMN_USER); gtk_tree_view_append_column(GTK_TREE_VIEW(priv->file_list_view), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes(_("Group"), renderer, "text", REMMINA_FTP_FILE_COLUMN_GROUP, NULL); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_sort_column_id(column, REMMINA_FTP_FILE_COLUMN_GROUP); gtk_tree_view_append_column(GTK_TREE_VIEW(priv->file_list_view), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes(_("Permission"), renderer, "text", REMMINA_FTP_FILE_COLUMN_PERMISSION, NULL); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_cell_data_func(column, renderer, remmina_ftp_client_cell_data_permission, NULL, NULL); gtk_tree_view_column_set_sort_column_id(column, REMMINA_FTP_FILE_COLUMN_PERMISSION); gtk_tree_view_append_column(GTK_TREE_VIEW(priv->file_list_view), column); /* Remote File List - Model */ priv->file_list_model = GTK_TREE_MODEL( gtk_list_store_new(REMMINA_FTP_FILE_N_COLUMNS, G_TYPE_INT, G_TYPE_STRING, G_TYPE_FLOAT, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT, G_TYPE_STRING)); priv->file_list_filter = gtk_tree_model_filter_new(priv->file_list_model, NULL); gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(priv->file_list_filter), (GtkTreeModelFilterVisibleFunc) remmina_ftp_client_filter_visible_func, client, NULL); priv->file_list_sort = gtk_tree_model_sort_new_with_model(priv->file_list_filter); gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(priv->file_list_sort), REMMINA_FTP_FILE_COLUMN_NAME_SORT, GTK_SORT_ASCENDING); gtk_tree_view_set_model(GTK_TREE_VIEW(priv->file_list_view), priv->file_list_sort); /* Task List */ scrolledwindow = gtk_scrolled_window_new(NULL, NULL); gtk_widget_show(scrolledwindow); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS); gtk_paned_pack2(GTK_PANED(vpaned), scrolledwindow, FALSE, TRUE); widget = gtk_tree_view_new(); gtk_widget_show(widget); gtk_container_add(GTK_CONTAINER(scrolledwindow), widget); g_object_set(widget, "has-tooltip", TRUE, NULL); priv->task_list_view = widget; /* Task List - Columns */ column = gtk_tree_view_column_new(); gtk_tree_view_column_set_title(column, _("File Name")); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_expand(column, TRUE); gtk_tree_view_column_set_sort_column_id(column, REMMINA_FTP_TASK_COLUMN_NAME); renderer = gtk_cell_renderer_pixbuf_new(); gtk_tree_view_column_pack_start(column, renderer, FALSE); gtk_tree_view_column_set_cell_data_func(column, renderer, remmina_ftp_client_cell_data_progress_pixbuf, NULL, NULL); renderer = gtk_cell_renderer_pixbuf_new(); gtk_tree_view_column_pack_start(column, renderer, FALSE); gtk_tree_view_column_set_cell_data_func(column, renderer, remmina_ftp_client_cell_data_filetype_pixbuf, NULL, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(column, renderer, FALSE); gtk_tree_view_column_add_attribute(column, renderer, "text", REMMINA_FTP_FILE_COLUMN_NAME); gtk_tree_view_append_column(GTK_TREE_VIEW(priv->task_list_view), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes(_("Remote"), renderer, "text", REMMINA_FTP_TASK_COLUMN_REMOTEDIR, NULL); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_sort_column_id(column, REMMINA_FTP_TASK_COLUMN_REMOTEDIR); gtk_tree_view_append_column(GTK_TREE_VIEW(priv->task_list_view), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes(_("Local"), renderer, "text", REMMINA_FTP_TASK_COLUMN_LOCALDIR, NULL); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_sort_column_id(column, REMMINA_FTP_TASK_COLUMN_LOCALDIR); gtk_tree_view_append_column(GTK_TREE_VIEW(priv->task_list_view), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes(_("Size"), renderer, NULL); gtk_tree_view_column_set_alignment(column, 1.0); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_cell_data_func(column, renderer, remmina_ftp_client_cell_data_size_progress, NULL, NULL); gtk_tree_view_column_set_sort_column_id(column, REMMINA_FTP_TASK_COLUMN_SIZE); gtk_tree_view_append_column(GTK_TREE_VIEW(priv->task_list_view), column); renderer = gtk_cell_renderer_progress_new(); column = gtk_tree_view_column_new_with_attributes(_("Progress"), renderer, NULL); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_cell_data_func(column, renderer, remmina_ftp_client_cell_data_progress, NULL, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(priv->task_list_view), column); renderer = remmina_cell_renderer_pixbuf_new(); column = gtk_tree_view_column_new_with_attributes(NULL, renderer, NULL); g_object_set(G_OBJECT(renderer), "stock-id", GTK_STOCK_CANCEL, NULL); gtk_tree_view_column_set_resizable(column, FALSE); gtk_tree_view_append_column(GTK_TREE_VIEW(priv->task_list_view), column); g_signal_connect(G_OBJECT(renderer), "activate", G_CALLBACK(remmina_ftp_client_task_list_cell_on_activate), client); /* Task List - Model */ priv->task_list_model = GTK_TREE_MODEL( gtk_list_store_new(REMMINA_FTP_TASK_N_COLUMNS, G_TYPE_INT, G_TYPE_STRING, G_TYPE_FLOAT, G_TYPE_INT, G_TYPE_INT, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT, G_TYPE_FLOAT, G_TYPE_STRING)); gtk_tree_view_set_model(GTK_TREE_VIEW(priv->task_list_view), priv->task_list_model); /* Setup the internal signals */ g_signal_connect(G_OBJECT(client), "destroy", G_CALLBACK(remmina_ftp_client_destroy), NULL); g_signal_connect(G_OBJECT(gtk_bin_get_child(GTK_BIN(priv->directory_combo))), "activate", G_CALLBACK(remmina_ftp_client_dir_on_activate), client); g_signal_connect(G_OBJECT(priv->directory_combo), "changed", G_CALLBACK(remmina_ftp_client_dir_on_changed), client); g_signal_connect(G_OBJECT(priv->file_list_view), "button-press-event", G_CALLBACK(remmina_ftp_client_file_list_on_button_press), client); g_signal_connect(G_OBJECT(gtk_tree_view_get_selection(GTK_TREE_VIEW(priv->file_list_view))), "changed", G_CALLBACK(remmina_ftp_client_file_selection_on_changed), client); g_signal_connect(G_OBJECT(priv->task_list_view), "query-tooltip", G_CALLBACK(remmina_ftp_client_task_list_on_query_tooltip), client); }
static void file_configure(void) { if (!configure_win) { configure_win = gtk_dialog_new_with_buttons (_("FileWriter Configuration"), NULL, 0, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); g_signal_connect (configure_win, "response", (GCallback) configure_response_cb, NULL); g_signal_connect (configure_win, "destroy", (GCallback) gtk_widget_destroyed, & configure_win); configure_vbox = gtk_dialog_get_content_area ((GtkDialog *) configure_win); fileext_hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5); gtk_box_pack_start(GTK_BOX(configure_vbox), fileext_hbox, FALSE, FALSE, 0); fileext_label = gtk_label_new(_("Output file format:")); gtk_box_pack_start(GTK_BOX(fileext_hbox), fileext_label, FALSE, FALSE, 0); fileext_combo = gtk_combo_box_text_new (); gtk_combo_box_text_append_text ((GtkComboBoxText *) fileext_combo, "WAV"); #ifdef FILEWRITER_MP3 gtk_combo_box_text_append_text ((GtkComboBoxText *) fileext_combo, "MP3"); #endif #ifdef FILEWRITER_VORBIS gtk_combo_box_text_append_text ((GtkComboBoxText *) fileext_combo, "Vorbis"); #endif #ifdef FILEWRITER_FLAC gtk_combo_box_text_append_text ((GtkComboBoxText *) fileext_combo, "FLAC"); #endif gtk_box_pack_start(GTK_BOX(fileext_hbox), fileext_combo, FALSE, FALSE, 0); gtk_combo_box_set_active(GTK_COMBO_BOX(fileext_combo), fileext); g_signal_connect(G_OBJECT(fileext_combo), "changed", G_CALLBACK(fileext_cb), NULL); plugin_button = gtk_button_new_with_label(_("Configure")); gtk_widget_set_sensitive(plugin_button, plugin->configure != NULL); g_signal_connect(G_OBJECT(plugin_button), "clicked", G_CALLBACK(plugin_configure_cb), NULL); gtk_box_pack_end(GTK_BOX(fileext_hbox), plugin_button, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(configure_vbox), gtk_separator_new(GTK_ORIENTATION_HORIZONTAL), FALSE, FALSE, 0); saveplace_hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5); gtk_container_add(GTK_CONTAINER(configure_vbox), saveplace_hbox); saveplace = gtk_radio_button_new_with_label(NULL, _("Save into original directory")); g_signal_connect(G_OBJECT(saveplace), "toggled", G_CALLBACK(saveplace_original_cb), NULL); gtk_box_pack_start(GTK_BOX(saveplace_hbox), saveplace, FALSE, FALSE, 0); saveplace = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(saveplace), _("Save into custom directory")); if (!save_original) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(saveplace), TRUE); g_signal_connect(G_OBJECT(saveplace), "toggled", G_CALLBACK(saveplace_custom_cb), NULL); gtk_box_pack_start(GTK_BOX(saveplace_hbox), saveplace, FALSE, FALSE, 0); path_hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5); gtk_box_pack_start(GTK_BOX(configure_vbox), path_hbox, FALSE, FALSE, 0); path_label = gtk_label_new(_("Output file folder:")); gtk_box_pack_start(GTK_BOX(path_hbox), path_label, FALSE, FALSE, 0); path_dirbrowser = gtk_file_chooser_button_new (_("Pick a folder"), GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER); gtk_file_chooser_set_uri ((GtkFileChooser *) path_dirbrowser, file_path); gtk_box_pack_start(GTK_BOX(path_hbox), path_dirbrowser, TRUE, TRUE, 0); if (save_original) gtk_widget_set_sensitive(path_hbox, FALSE); gtk_box_pack_start(GTK_BOX(configure_vbox), gtk_separator_new(GTK_ORIENTATION_HORIZONTAL), FALSE, FALSE, 0); filenamefrom_hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5); gtk_container_add(GTK_CONTAINER(configure_vbox), filenamefrom_hbox); filenamefrom_label = gtk_label_new(_("Get filename from:")); gtk_box_pack_start(GTK_BOX(filenamefrom_hbox), filenamefrom_label, FALSE, FALSE, 0); filenamefrom_toggle = gtk_radio_button_new_with_label(NULL, _("original file tags")); g_signal_connect(G_OBJECT(filenamefrom_toggle), "toggled", G_CALLBACK(filenamefromtags_cb), NULL); gtk_box_pack_start(GTK_BOX(filenamefrom_hbox), filenamefrom_toggle, FALSE, FALSE, 0); filenamefrom_toggle = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(filenamefrom_toggle), _("original filename")); g_signal_connect(G_OBJECT(filenamefrom_toggle), "toggled", G_CALLBACK(filenamefromfilename_cb), NULL); gtk_box_pack_start(GTK_BOX(filenamefrom_hbox), filenamefrom_toggle, FALSE, FALSE, 0); if (!filenamefromtags) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(filenamefrom_toggle), TRUE); use_suffix_toggle = gtk_check_button_new_with_label(_("Don't strip file name extension")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(use_suffix_toggle), use_suffix); gtk_box_pack_start(GTK_BOX(configure_vbox), use_suffix_toggle, FALSE, FALSE, 0); if (filenamefromtags) gtk_widget_set_sensitive(use_suffix_toggle, FALSE); gtk_box_pack_start(GTK_BOX(configure_vbox), gtk_separator_new(GTK_ORIENTATION_HORIZONTAL), FALSE, FALSE, 0); prependnumber_toggle = gtk_check_button_new_with_label(_("Prepend track number to filename")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(prependnumber_toggle), prependnumber); gtk_box_pack_start(GTK_BOX(configure_vbox), prependnumber_toggle, FALSE, FALSE, 0); gtk_widget_show_all(configure_win); } }
/* Shows the preferences dialog on the given tab */ void show_preferences(gint tab) { if(gtk_grab_get_current()) { /* A window is already open, so we present it to the user */ GtkWidget *toplevel = gtk_widget_get_toplevel(gtk_grab_get_current()); gtk_window_present((GtkWindow*)toplevel); return; } /* Declare some variables */ GtkWidget *frame, *label, *alignment, *hbox, *vbox; GtkWidget *adjustment, *adjustment_small, *adjustment_statics; GtkTreeViewColumn *tree_column; /* Create the dialog */ GtkWidget* dialog = gtk_dialog_new_with_buttons(_("Preferences"), NULL, (GTK_DIALOG_MODAL + GTK_DIALOG_NO_SEPARATOR), GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, NULL); gtk_window_set_icon((GtkWindow*)dialog, gtk_widget_render_icon(dialog, GTK_STOCK_PREFERENCES, GTK_ICON_SIZE_MENU, NULL)); gtk_window_set_resizable((GtkWindow*)dialog, FALSE); /* Create notebook */ GtkWidget* notebook = gtk_notebook_new(); #if GTK_CHECK_VERSION (2,14,0) gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area (GTK_DIALOG(dialog))), notebook, TRUE, TRUE, 2); #else gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), notebook, TRUE, TRUE, 2); #endif /* Build the settings page */ GtkWidget* page_settings = gtk_alignment_new(0.50, 0.50, 1.0, 1.0); gtk_alignment_set_padding((GtkAlignment*)page_settings, 12, 6, 12, 6); gtk_notebook_append_page((GtkNotebook*)notebook, page_settings, gtk_label_new(_("Settings"))); GtkWidget* vbox_settings = gtk_vbox_new(FALSE, 12); gtk_container_add((GtkContainer*)page_settings, vbox_settings); /* Build the clipboards frame */ frame = gtk_frame_new(NULL); gtk_frame_set_shadow_type((GtkFrame*)frame, GTK_SHADOW_NONE); label = gtk_label_new(NULL); gtk_label_set_markup((GtkLabel*)label, _("<b>Clipboards</b>")); gtk_frame_set_label_widget((GtkFrame*)frame, label); alignment = gtk_alignment_new(0.50, 0.50, 1.0, 1.0); gtk_alignment_set_padding((GtkAlignment*)alignment, 12, 0, 12, 0); gtk_container_add((GtkContainer*)frame, alignment); vbox = gtk_vbox_new(FALSE, 2); gtk_container_add((GtkContainer*)alignment, vbox); copy_check = gtk_check_button_new_with_mnemonic(_("Use _Copy (Ctrl-C)")); g_signal_connect((GObject*)copy_check, "toggled", (GCallback)check_toggled, NULL); gtk_box_pack_start((GtkBox*)vbox, copy_check, FALSE, FALSE, 0); primary_check = gtk_check_button_new_with_mnemonic(_("Use _Primary (Selection)")); g_signal_connect((GObject*)primary_check, "toggled", (GCallback)check_toggled, NULL); gtk_box_pack_start((GtkBox*)vbox, primary_check, FALSE, FALSE, 0); synchronize_check = gtk_check_button_new_with_mnemonic(_("S_ynchronize clipboards")); gtk_box_pack_start((GtkBox*)vbox, synchronize_check, FALSE, FALSE, 0); paste_check = gtk_check_button_new_with_mnemonic(_("_Automatically paste selected item")); g_signal_connect((GObject*)paste_check, "toggled", (GCallback)check_toggled, NULL); gtk_box_pack_start((GtkBox*)vbox, paste_check, FALSE, FALSE, 0); gtk_box_pack_start((GtkBox*)vbox_settings, frame, FALSE, FALSE, 0); /* Build the miscellaneous frame */ frame = gtk_frame_new(NULL); gtk_frame_set_shadow_type((GtkFrame*)frame, GTK_SHADOW_NONE); label = gtk_label_new(NULL); gtk_label_set_markup((GtkLabel*)label, _("<b>Miscellaneous</b>")); gtk_frame_set_label_widget((GtkFrame*)frame, label); alignment = gtk_alignment_new(0.50, 0.50, 1.0, 1.0); gtk_alignment_set_padding((GtkAlignment*)alignment, 12, 0, 12, 0); gtk_container_add((GtkContainer*)frame, alignment); vbox = gtk_vbox_new(FALSE, 2); gtk_container_add((GtkContainer*)alignment, vbox); show_indexes_check = gtk_check_button_new_with_mnemonic(_("Show _indexes in history menu")); gtk_box_pack_start((GtkBox*)vbox, show_indexes_check, FALSE, FALSE, 0); save_uris_check = gtk_check_button_new_with_mnemonic(_("S_ave URIs")); gtk_box_pack_start((GtkBox*)vbox, save_uris_check, FALSE, FALSE, 0); hyperlinks_check = gtk_check_button_new_with_mnemonic(_("Capture _hyperlinks only")); gtk_box_pack_start((GtkBox*)vbox, hyperlinks_check, FALSE, FALSE, 0); confirm_check = gtk_check_button_new_with_mnemonic(_("C_onfirm before clearing history")); gtk_box_pack_start((GtkBox*)vbox, confirm_check, FALSE, FALSE, 0); use_rmb_menu_check = gtk_check_button_new_with_mnemonic(_("_Use right-click menu")); gtk_box_pack_start((GtkBox*)vbox, use_rmb_menu_check, FALSE, FALSE, 0); hbox = gtk_hbox_new(FALSE, 4); gtk_box_pack_start((GtkBox*)vbox, hbox, FALSE, FALSE, 0); gtk_box_pack_start((GtkBox*)vbox_settings, frame, FALSE, FALSE, 0); /* Build the history page */ GtkWidget* page_history = gtk_alignment_new(0.50, 0.50, 1.0, 1.0); gtk_alignment_set_padding((GtkAlignment*)page_history, 12, 6, 12, 6); gtk_notebook_append_page((GtkNotebook*)notebook, page_history, gtk_label_new(_("History"))); GtkWidget* vbox_history = gtk_vbox_new(FALSE, 12); gtk_container_add((GtkContainer*)page_history, vbox_history); /* Build the history frame */ frame = gtk_frame_new(NULL); gtk_frame_set_shadow_type((GtkFrame*)frame, GTK_SHADOW_NONE); label = gtk_label_new(NULL); gtk_label_set_markup((GtkLabel*)label, _("<b>History</b>")); gtk_frame_set_label_widget((GtkFrame*)frame, label); alignment = gtk_alignment_new(0.50, 0.50, 1.0, 1.0); gtk_alignment_set_padding((GtkAlignment*)alignment, 12, 0, 12, 0); gtk_container_add((GtkContainer*)frame, alignment); vbox = gtk_vbox_new(FALSE, 2); gtk_container_add((GtkContainer*)alignment, vbox); save_check = gtk_check_button_new_with_mnemonic(_("Save _history")); gtk_widget_set_tooltip_text(save_check, _("Save and restore history between sessions")); gtk_box_pack_start((GtkBox*)vbox, save_check, FALSE, FALSE, 0); hbox = gtk_hbox_new(FALSE, 4); gtk_box_pack_start((GtkBox*)vbox, hbox, FALSE, FALSE, 0); label = gtk_label_new(_("Items in history:")); gtk_misc_set_alignment((GtkMisc*)label, 0.0, 0.50); gtk_box_pack_start((GtkBox*)hbox, label, FALSE, FALSE, 0); adjustment = gtk_adjustment_new(25, 5, 1000, 1, 10, 0); history_spin = gtk_spin_button_new((GtkAdjustment*)adjustment, 0.0, 0); gtk_spin_button_set_update_policy((GtkSpinButton*)history_spin, GTK_UPDATE_IF_VALID); gtk_box_pack_start((GtkBox*)hbox, history_spin, FALSE, FALSE, 0); hbox = gtk_hbox_new(FALSE, 4); gtk_box_pack_start((GtkBox*)vbox, hbox, FALSE, FALSE, 0); label = gtk_label_new(_("Items in menu:")); gtk_misc_set_alignment((GtkMisc*)label, 0.0, 0.50); gtk_box_pack_start((GtkBox*)hbox, label, FALSE, FALSE, 0); adjustment_small = gtk_adjustment_new(25, 5, 100, 1, 10, 0); items_menu = gtk_spin_button_new((GtkAdjustment*)adjustment_small, 0.0, 0); gtk_spin_button_set_update_policy((GtkSpinButton*)items_menu, GTK_UPDATE_IF_VALID); gtk_box_pack_start((GtkBox*)hbox, items_menu, FALSE, FALSE, 0); statics_show_check = gtk_check_button_new_with_mnemonic(_("Show _static items in menu")); g_signal_connect((GObject*)statics_show_check, "toggled", (GCallback)check_toggled, NULL); gtk_box_pack_start((GtkBox*)vbox, statics_show_check, FALSE, FALSE, 0); hbox = gtk_hbox_new(FALSE, 4); gtk_box_pack_start((GtkBox*)vbox, hbox, FALSE, FALSE, 0); label = gtk_label_new(_("Static items in menu:")); gtk_misc_set_alignment((GtkMisc*)label, 0.0, 0.50); gtk_box_pack_start((GtkBox*)hbox, label, FALSE, FALSE, 0); adjustment_statics = gtk_adjustment_new(10, 1, 100, 1, 10, 0); statics_items_spin = gtk_spin_button_new((GtkAdjustment*)adjustment_statics, 0.0, 0); gtk_spin_button_set_update_policy((GtkSpinButton*)statics_items_spin, GTK_UPDATE_IF_VALID); gtk_box_pack_start((GtkBox*)hbox, statics_items_spin, FALSE, FALSE, 0); gtk_box_pack_start((GtkBox*)vbox_history, frame, FALSE, FALSE, 0); /* Build the items frame */ frame = gtk_frame_new(NULL); gtk_frame_set_shadow_type((GtkFrame*)frame, GTK_SHADOW_NONE); label = gtk_label_new(NULL); gtk_label_set_markup((GtkLabel*)label, _("<b>Items</b>")); gtk_frame_set_label_widget((GtkFrame*)frame, label); alignment = gtk_alignment_new(0.50, 0.50, 1.0, 1.0); gtk_alignment_set_padding((GtkAlignment*)alignment, 12, 0, 12, 0); gtk_container_add((GtkContainer*)frame, alignment); vbox = gtk_vbox_new(FALSE, 2); gtk_container_add((GtkContainer*)alignment, vbox); linemode_check = gtk_check_button_new_with_mnemonic(_("Show in a single _line")); gtk_box_pack_start((GtkBox*)vbox, linemode_check, FALSE, FALSE, 0); reverse_check = gtk_check_button_new_with_mnemonic(_("Show in _reverse order")); gtk_box_pack_start((GtkBox*)vbox, reverse_check, FALSE, FALSE, 0); hbox = gtk_hbox_new(FALSE, 4); gtk_box_pack_start((GtkBox*)vbox, hbox, FALSE, FALSE, 0); label = gtk_label_new(_("Character length of items:")); gtk_misc_set_alignment((GtkMisc*)label, 0.0, 0.50); gtk_box_pack_start((GtkBox*)hbox, label, FALSE, FALSE, 0); adjustment = gtk_adjustment_new(50, 25, 75, 1, 5, 0); charlength_spin = gtk_spin_button_new((GtkAdjustment*)adjustment, 0.0, 0); gtk_spin_button_set_update_policy((GtkSpinButton*)charlength_spin, GTK_UPDATE_IF_VALID); gtk_box_pack_start((GtkBox*)hbox, charlength_spin, FALSE, FALSE, 0); hbox = gtk_hbox_new(FALSE, 4); gtk_box_pack_start((GtkBox*)vbox, hbox, FALSE, FALSE, 0); label = gtk_label_new(_("Omit items in the:")); gtk_misc_set_alignment((GtkMisc*)label, 0.0, 0.50); gtk_box_pack_start((GtkBox*)hbox, label, FALSE, FALSE, 0); ellipsize_combo = gtk_combo_box_text_new(); gtk_combo_box_text_append_text((GtkComboBox*)ellipsize_combo, _("Beginning")); gtk_combo_box_text_append_text((GtkComboBox*)ellipsize_combo, _("Middle")); gtk_combo_box_text_append_text((GtkComboBox*)ellipsize_combo, _("End")); gtk_box_pack_start((GtkBox*)hbox, ellipsize_combo, FALSE, FALSE, 0); gtk_box_pack_start((GtkBox*)vbox_history, frame, FALSE, FALSE, 0); /* Build the omitting frame frame = gtk_frame_new(NULL); gtk_frame_set_shadow_type((GtkFrame*)frame, GTK_SHADOW_NONE); label = gtk_label_new(NULL); gtk_label_set_markup((GtkLabel*)label, _("<b>Omitting</b>")); gtk_frame_set_label_widget((GtkFrame*)frame, label); alignment = gtk_alignment_new(0.50, 0.50, 1.0, 1.0); gtk_alignment_set_padding((GtkAlignment*)alignment, 12, 0, 12, 0); gtk_container_add((GtkContainer*)frame, alignment); vbox = gtk_vbox_new(FALSE, 2); gtk_container_add((GtkContainer*)alignment, vbox); hbox = gtk_hbox_new(FALSE, 4); gtk_box_pack_start((GtkBox*)vbox, hbox, FALSE, FALSE, 0); label = gtk_label_new(_("Omit items in the:")); gtk_misc_set_alignment((GtkMisc*)label, 0.0, 0.50); gtk_box_pack_start((GtkBox*)hbox, label, FALSE, FALSE, 0); ellipsize_combo = gtk_combo_box_new_text(); gtk_combo_box_text_append_text((GtkComboBox*)ellipsize_combo, _("Beginning")); gtk_combo_box_text_append_text((GtkComboBox*)ellipsize_combo, _("Middle")); gtk_combo_box_text_append_text((GtkComboBox*)ellipsize_combo, _("End")); gtk_box_pack_start((GtkBox*)hbox, ellipsize_combo, FALSE, FALSE, 0); gtk_box_pack_start((GtkBox*)vbox_history, frame, FALSE, FALSE, 0); */ /* Build the actions page */ GtkWidget* page_actions = gtk_alignment_new(0.50, 0.50, 1.0, 1.0); gtk_alignment_set_padding((GtkAlignment*)page_actions, 6, 6, 6, 6); gtk_notebook_append_page((GtkNotebook*)notebook, page_actions, gtk_label_new(_("Actions"))); GtkWidget* vbox_actions = gtk_vbox_new(FALSE, 6); gtk_container_add((GtkContainer*)page_actions, vbox_actions); /* Build the actions label */ label = gtk_label_new(_("Control-click ClipIt\'s tray icon to use actions")); gtk_label_set_line_wrap((GtkLabel*)label, TRUE); gtk_misc_set_alignment((GtkMisc*)label, 0.0, 0.50); gtk_box_pack_start((GtkBox*)vbox_actions, label, FALSE, FALSE, 0); /* Build the actions treeview */ GtkWidget* scrolled_window = gtk_scrolled_window_new( (GtkAdjustment*)gtk_adjustment_new(0, 0, 0, 0, 0, 0), (GtkAdjustment*)gtk_adjustment_new(0, 0, 0, 0, 0, 0)); gtk_scrolled_window_set_policy((GtkScrolledWindow*)scrolled_window, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type((GtkScrolledWindow*)scrolled_window, GTK_SHADOW_ETCHED_OUT); GtkWidget* treeview = gtk_tree_view_new(); gtk_tree_view_set_reorderable((GtkTreeView*)treeview, TRUE); gtk_tree_view_set_rules_hint((GtkTreeView*)treeview, TRUE); actions_list = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_STRING, -1); gtk_tree_view_set_model((GtkTreeView*)treeview, (GtkTreeModel*)actions_list); GtkCellRenderer* name_renderer = gtk_cell_renderer_text_new(); g_object_set(name_renderer, "editable", TRUE, NULL); g_signal_connect((GObject*)name_renderer, "edited", (GCallback)edit_action, (gpointer)0); tree_column = gtk_tree_view_column_new_with_attributes(_("Action"), name_renderer, "text", 0, NULL); gtk_tree_view_column_set_resizable(tree_column, TRUE); gtk_tree_view_append_column((GtkTreeView*)treeview, tree_column); GtkCellRenderer* command_renderer = gtk_cell_renderer_text_new(); g_object_set(command_renderer, "editable", TRUE, NULL); g_object_set(command_renderer, "ellipsize-set", TRUE, "ellipsize", PANGO_ELLIPSIZE_END, NULL); g_signal_connect((GObject*)command_renderer, "edited", (GCallback)edit_action, (gpointer)1); tree_column = gtk_tree_view_column_new_with_attributes(_("Command"), command_renderer, "text", 1, NULL); gtk_tree_view_column_set_expand(tree_column, TRUE); gtk_tree_view_append_column((GtkTreeView*)treeview, tree_column); gtk_container_add((GtkContainer*)scrolled_window, treeview); gtk_box_pack_start((GtkBox*)vbox_actions, scrolled_window, TRUE, TRUE, 0); /* Edit selection and connect treeview related signals */ actions_selection = gtk_tree_view_get_selection((GtkTreeView*)treeview); gtk_tree_selection_set_mode(actions_selection, GTK_SELECTION_BROWSE); g_signal_connect((GObject*)treeview, "key-press-event", (GCallback)delete_key_pressed, NULL); /* Build the buttons */ GtkWidget* hbbox = gtk_hbutton_box_new(); gtk_box_set_spacing((GtkBox*)hbbox, 6); gtk_button_box_set_layout((GtkButtonBox*)hbbox, GTK_BUTTONBOX_START); GtkWidget* add_button = gtk_button_new_with_label(_("Add...")); gtk_button_set_image((GtkButton*)add_button, gtk_image_new_from_stock(GTK_STOCK_ADD, GTK_ICON_SIZE_MENU)); g_signal_connect((GObject*)add_button, "clicked", (GCallback)add_action, NULL); gtk_box_pack_start((GtkBox*)hbbox, add_button, FALSE, TRUE, 0); GtkWidget* remove_button = gtk_button_new_with_label(_("Remove")); gtk_button_set_image((GtkButton*)remove_button, gtk_image_new_from_stock(GTK_STOCK_REMOVE, GTK_ICON_SIZE_MENU)); g_signal_connect((GObject*)remove_button, "clicked", (GCallback)remove_action, NULL); gtk_box_pack_start((GtkBox*)hbbox, remove_button, FALSE, TRUE, 0); GtkWidget* up_button = gtk_button_new(); gtk_button_set_image((GtkButton*)up_button, gtk_image_new_from_stock(GTK_STOCK_GO_UP, GTK_ICON_SIZE_MENU)); g_signal_connect((GObject*)up_button, "clicked", (GCallback)move_action_up, NULL); gtk_box_pack_start((GtkBox*)hbbox, up_button, FALSE, TRUE, 0); GtkWidget* down_button = gtk_button_new(); gtk_button_set_image((GtkButton*)down_button, gtk_image_new_from_stock(GTK_STOCK_GO_DOWN, GTK_ICON_SIZE_MENU)); g_signal_connect((GObject*)down_button, "clicked", (GCallback)move_action_down, NULL); gtk_box_pack_start((GtkBox*)hbbox, down_button, FALSE, TRUE, 0); gtk_box_pack_start((GtkBox*)vbox_actions, hbbox, FALSE, FALSE, 0); /* Build the exclude page */ GtkWidget* page_exclude = gtk_alignment_new(0.50, 0.50, 1.0, 1.0); gtk_alignment_set_padding((GtkAlignment*)page_exclude, 6, 6, 6, 6); gtk_notebook_append_page((GtkNotebook*)notebook, page_exclude, gtk_label_new(_("Exclude"))); GtkWidget* vbox_exclude = gtk_vbox_new(FALSE, 6); gtk_container_add((GtkContainer*)page_exclude, vbox_exclude); /* Build the exclude label */ label = gtk_label_new(_("Regex list of items that should not be inserted into the history (passwords/sites that you don't need in history, etc).")); gtk_label_set_line_wrap((GtkLabel*)label, TRUE); gtk_misc_set_alignment((GtkMisc*)label, 0.0, 0.50); gtk_box_pack_start((GtkBox*)vbox_exclude, label, FALSE, FALSE, 0); /* Build the exclude treeview */ GtkWidget* scrolled_window_exclude = gtk_scrolled_window_new( (GtkAdjustment*)gtk_adjustment_new(0, 0, 0, 0, 0, 0), (GtkAdjustment*)gtk_adjustment_new(0, 0, 0, 0, 0, 0)); gtk_scrolled_window_set_policy((GtkScrolledWindow*)scrolled_window_exclude, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type((GtkScrolledWindow*)scrolled_window_exclude, GTK_SHADOW_ETCHED_OUT); GtkWidget* treeview_exclude = gtk_tree_view_new(); gtk_tree_view_set_reorderable((GtkTreeView*)treeview_exclude, TRUE); gtk_tree_view_set_rules_hint((GtkTreeView*)treeview_exclude, TRUE); exclude_list = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_STRING, -1); gtk_tree_view_set_model((GtkTreeView*)treeview_exclude, (GtkTreeModel*)exclude_list); GtkCellRenderer* name_renderer_exclude = gtk_cell_renderer_text_new(); g_object_set(name_renderer_exclude, "editable", TRUE, NULL); g_signal_connect((GObject*)name_renderer_exclude, "edited", (GCallback)edit_exclude, (gpointer)0); tree_column = gtk_tree_view_column_new_with_attributes(_("Regex"), name_renderer_exclude, "text", 0, NULL); gtk_tree_view_column_set_resizable(tree_column, TRUE); gtk_tree_view_append_column((GtkTreeView*)treeview_exclude, tree_column); gtk_container_add((GtkContainer*)scrolled_window_exclude, treeview_exclude); gtk_box_pack_start((GtkBox*)vbox_exclude, scrolled_window_exclude, TRUE, TRUE, 0); /* Edit selection and connect treeview related signals */ exclude_selection = gtk_tree_view_get_selection((GtkTreeView*)treeview_exclude); gtk_tree_selection_set_mode(exclude_selection, GTK_SELECTION_BROWSE); g_signal_connect((GObject*)treeview_exclude, "key-press-event", (GCallback)delete_key_pressed, NULL); /* Build the buttons */ GtkWidget* hbbox_exclude = gtk_hbutton_box_new(); gtk_box_set_spacing((GtkBox*)hbbox_exclude, 6); gtk_button_box_set_layout((GtkButtonBox*)hbbox_exclude, GTK_BUTTONBOX_START); GtkWidget* add_button_exclude = gtk_button_new_with_label(_("Add...")); gtk_button_set_image((GtkButton*)add_button_exclude, gtk_image_new_from_stock(GTK_STOCK_ADD, GTK_ICON_SIZE_MENU)); g_signal_connect((GObject*)add_button_exclude, "clicked", (GCallback)add_exclude, NULL); gtk_box_pack_start((GtkBox*)hbbox_exclude, add_button_exclude, FALSE, TRUE, 0); GtkWidget* remove_button_exclude = gtk_button_new_with_label(_("Remove")); gtk_button_set_image((GtkButton*)remove_button_exclude, gtk_image_new_from_stock(GTK_STOCK_REMOVE, GTK_ICON_SIZE_MENU)); g_signal_connect((GObject*)remove_button_exclude, "clicked", (GCallback)remove_exclude, NULL); gtk_box_pack_start((GtkBox*)hbbox_exclude, remove_button_exclude, FALSE, TRUE, 0); gtk_box_pack_start((GtkBox*)vbox_exclude, hbbox_exclude, FALSE, FALSE, 0); /* Build the hotkeys page */ GtkWidget* page_extras = gtk_alignment_new(0.50, 0.50, 1.0, 1.0); gtk_alignment_set_padding((GtkAlignment*)page_extras, 12, 6, 12, 6); gtk_notebook_append_page((GtkNotebook*)notebook, page_extras, gtk_label_new(_("Hotkeys"))); GtkWidget* vbox_extras = gtk_vbox_new(FALSE, 12); gtk_container_add((GtkContainer*)page_extras, vbox_extras); /* Build the hotkeys frame */ frame = gtk_frame_new(NULL); gtk_frame_set_shadow_type((GtkFrame*)frame, GTK_SHADOW_NONE); label = gtk_label_new(NULL); gtk_label_set_markup((GtkLabel*)label, _("<b>Hotkeys</b>")); gtk_frame_set_label_widget((GtkFrame*)frame, label); alignment = gtk_alignment_new(0.50, 0.50, 1.0, 1.0); gtk_alignment_set_padding((GtkAlignment*)alignment, 12, 0, 12, 0); gtk_container_add((GtkContainer*)frame, alignment); vbox = gtk_vbox_new(FALSE, 2); gtk_container_add((GtkContainer*)alignment, vbox); /* History key combination */ hbox = gtk_hbox_new(TRUE, 4); gtk_box_pack_start((GtkBox*)vbox, hbox, FALSE, FALSE, 0); label = gtk_label_new(_("History hotkey:")); gtk_misc_set_alignment((GtkMisc*)label, 0.0, 0.50); gtk_box_pack_start((GtkBox*)hbox, label, TRUE, TRUE, 0); history_key_entry = gtk_entry_new(); gtk_entry_set_width_chars((GtkEntry*)history_key_entry, 10); gtk_box_pack_end((GtkBox*)hbox, history_key_entry, TRUE, TRUE, 0); /* Actions key combination */ hbox = gtk_hbox_new(TRUE, 4); gtk_box_pack_start((GtkBox*)vbox, hbox, FALSE, FALSE, 0); label = gtk_label_new(_("Actions hotkey:")); gtk_misc_set_alignment((GtkMisc*)label, 0.0, 0.50); gtk_box_pack_start((GtkBox*)hbox, label, TRUE, TRUE, 0); actions_key_entry = gtk_entry_new(); gtk_entry_set_width_chars((GtkEntry*)actions_key_entry, 10); gtk_box_pack_end((GtkBox*)hbox, actions_key_entry, TRUE, TRUE, 0); /* Menu key combination */ hbox = gtk_hbox_new(TRUE, 4); gtk_box_pack_start((GtkBox*)vbox, hbox, FALSE, FALSE, 0); label = gtk_label_new(_("Menu hotkey:")); gtk_misc_set_alignment((GtkMisc*)label, 0.0, 0.50); gtk_box_pack_start((GtkBox*)hbox, label, TRUE, TRUE, 0); menu_key_entry = gtk_entry_new(); gtk_entry_set_width_chars((GtkEntry*)menu_key_entry, 10); gtk_box_pack_end((GtkBox*)hbox, menu_key_entry, TRUE, TRUE, 0); /* Search key combination */ hbox = gtk_hbox_new(TRUE, 4); gtk_box_pack_start((GtkBox*)vbox, hbox, FALSE, FALSE, 0); label = gtk_label_new(_("Manage hotkey:")); gtk_misc_set_alignment((GtkMisc*)label, 0.0, 0.50); gtk_box_pack_start((GtkBox*)hbox, label, TRUE, TRUE, 0); search_key_entry = gtk_entry_new(); gtk_entry_set_width_chars((GtkEntry*)search_key_entry, 10); gtk_box_pack_end((GtkBox*)hbox, search_key_entry, TRUE, TRUE, 0); /* Offline mode key combination */ hbox = gtk_hbox_new(TRUE, 4); gtk_box_pack_start((GtkBox*)vbox, hbox, FALSE, FALSE, 0); label = gtk_label_new(_("Offline mode hotkey:")); gtk_misc_set_alignment((GtkMisc*)label, 0.0, 0.50); gtk_box_pack_start((GtkBox*)hbox, label, TRUE, TRUE, 0); offline_key_entry = gtk_entry_new(); gtk_entry_set_width_chars((GtkEntry*)offline_key_entry, 10); gtk_box_pack_end((GtkBox*)hbox, offline_key_entry, TRUE, TRUE, 0); gtk_box_pack_start((GtkBox*)vbox_extras, frame, FALSE, FALSE, 0); /* Make widgets reflect current preferences */ gtk_toggle_button_set_active((GtkToggleButton*)copy_check, prefs.use_copy); gtk_toggle_button_set_active((GtkToggleButton*)primary_check, prefs.use_primary); gtk_toggle_button_set_active((GtkToggleButton*)synchronize_check, prefs.synchronize); gtk_toggle_button_set_active((GtkToggleButton*)paste_check, prefs.automatic_paste); gtk_toggle_button_set_active((GtkToggleButton*)show_indexes_check, prefs.show_indexes); gtk_toggle_button_set_active((GtkToggleButton*)save_uris_check, prefs.save_uris); gtk_toggle_button_set_active((GtkToggleButton*)use_rmb_menu_check, prefs.use_rmb_menu); gtk_toggle_button_set_active((GtkToggleButton*)save_check, prefs.save_history); gtk_spin_button_set_value((GtkSpinButton*)history_spin, (gdouble)prefs.history_limit); gtk_spin_button_set_value((GtkSpinButton*)items_menu, (gdouble)prefs.items_menu); gtk_toggle_button_set_active((GtkToggleButton*)statics_show_check, prefs.statics_show); gtk_spin_button_set_value((GtkSpinButton*)statics_items_spin, (gdouble)prefs.statics_items); gtk_toggle_button_set_active((GtkToggleButton*)hyperlinks_check, prefs.hyperlinks_only); gtk_toggle_button_set_active((GtkToggleButton*)confirm_check, prefs.confirm_clear); gtk_toggle_button_set_active((GtkToggleButton*)linemode_check, prefs.single_line); gtk_toggle_button_set_active((GtkToggleButton*)reverse_check, prefs.reverse_history); gtk_spin_button_set_value((GtkSpinButton*)charlength_spin, (gdouble)prefs.item_length); gtk_combo_box_set_active((GtkComboBox*)ellipsize_combo, prefs.ellipsize - 1); gtk_entry_set_text((GtkEntry*)history_key_entry, prefs.history_key); gtk_entry_set_text((GtkEntry*)actions_key_entry, prefs.actions_key); gtk_entry_set_text((GtkEntry*)menu_key_entry, prefs.menu_key); gtk_entry_set_text((GtkEntry*)search_key_entry, prefs.search_key); gtk_entry_set_text((GtkEntry*)offline_key_entry, prefs.offline_key); /* Read actions */ read_actions(); read_excludes(); /* Run the dialog */ gtk_widget_show_all(dialog); #ifdef HAVE_APPINDICATOR gtk_widget_hide(use_rmb_menu_check); #endif gtk_notebook_set_current_page((GtkNotebook*)notebook, tab); if (gtk_dialog_run((GtkDialog*)dialog) == GTK_RESPONSE_ACCEPT) { /* If the user disabled history saving, we ask him if he wants to delete the history file */ if(prefs.save_history && !gtk_toggle_button_get_active((GtkToggleButton*)save_check)) check_saved_hist_file(); /* Apply and save preferences */ apply_preferences(); save_preferences(); save_actions(); save_excludes(); } gtk_widget_destroy(dialog); }
static void create_dropdowns_for_multival_attr(GList *match_attr_list, GList *contact_attr_list, GList **use_attr_list, gint *row, GtkTable *table, gchar *label_str) { GtkWidget *label, *hbox, *dropdown; GList *miter, *citer; GHashTable *match_attrs; /* attr in the 'match' contact from address book */ match_attrs = g_hash_table_new_full (camel_strcase_hash, camel_strcase_equal, g_free, NULL); for (miter = match_attr_list; miter; miter = g_list_next (miter)) { EVCardAttribute *attr = miter->data; gchar *value; value = e_vcard_attribute_get_value (attr); if (value && *value) { g_hash_table_insert (match_attrs, value, attr); *use_attr_list = g_list_prepend (*use_attr_list, attr); } else { g_free (value); } } *use_attr_list = g_list_reverse (*use_attr_list); for (citer = contact_attr_list; citer; citer = g_list_next (citer)) { EVCardAttribute *attr = citer->data; gchar *value; value = e_vcard_attribute_get_value (attr); if (value && *value) { if (!g_hash_table_lookup (match_attrs, value)) { dropdown_data *data; /* the attr is not set in both contacts */ *use_attr_list = g_list_append (*use_attr_list, attr); /* remove to avoid collisions with match UI_SLOTs */ e_vcard_attribute_remove_param (attr, EVOLUTION_UI_SLOT_PARAM); (*row)++; label = gtk_label_new (label_str); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); gtk_box_pack_start (GTK_BOX (hbox), (GtkWidget *) label, FALSE, FALSE, 0); gtk_table_attach_defaults (table, (GtkWidget *) hbox, 0, 1, *row, *row + 1); dropdown = gtk_combo_box_text_new (); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (dropdown), value); data = g_new0 (dropdown_data, 1); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (dropdown), ""); gtk_combo_box_set_active (GTK_COMBO_BOX (dropdown), 0); data->email_attr_list_item = g_list_last (*use_attr_list); data->email_attr = attr; g_signal_connect ( dropdown, "changed", G_CALLBACK (attr_dropdown_changed), data); g_object_set_data_full (G_OBJECT (dropdown), "eab-contact-merging::dropdown-data", data, g_free); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); gtk_box_pack_start (GTK_BOX (hbox), (GtkWidget *) dropdown, FALSE, FALSE, 0); gtk_table_attach_defaults (table, (GtkWidget *) hbox, 1, 2, *row, *row + 1); gtk_widget_show ((GtkWidget *) dropdown); } } g_free (value); } g_hash_table_destroy (match_attrs); }
void glatex_insert_environment_dialog(G_GNUC_UNUSED GtkMenuItem *menuitem, G_GNUC_UNUSED gpointer gdata) { GtkWidget *dialog = NULL; GtkWidget *vbox = NULL; GtkWidget *label_env = NULL; GtkWidget *textbox_env = NULL; GtkWidget *table = NULL; GtkWidget *tmp_entry = NULL; GtkTreeModel *model = NULL; gint i, max; dialog = gtk_dialog_new_with_buttons(_("Insert Environment"), GTK_WINDOW(geany->main_widgets->window), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, NULL); vbox = ui_dialog_vbox_new(GTK_DIALOG(dialog)); gtk_widget_set_name(dialog, "GeanyDialog"); gtk_box_set_spacing(GTK_BOX(vbox), 10); table = gtk_table_new(1, 2, FALSE); gtk_table_set_col_spacings(GTK_TABLE(table), 6); gtk_table_set_row_spacings(GTK_TABLE(table), 6); label_env = gtk_label_new(_("Environment:")); textbox_env = gtk_combo_box_text_new_with_entry(); max = glatex_count_menu_entries(glatex_environment_array, -1); for (i = 0; i < max; i++) { gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(textbox_env), glatex_environment_array[i].label); } model = gtk_combo_box_get_model(GTK_COMBO_BOX(textbox_env)); gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(model), 0, GTK_SORT_ASCENDING); gtk_misc_set_alignment(GTK_MISC(label_env), 0, 0.5); gtk_table_attach_defaults(GTK_TABLE(table), label_env, 0, 1, 0, 1); gtk_table_attach_defaults(GTK_TABLE(table), textbox_env, 1, 2, 0, 1); gtk_container_add(GTK_CONTAINER(vbox), table); tmp_entry = gtk_bin_get_child(GTK_BIN(textbox_env)); g_signal_connect(G_OBJECT(tmp_entry), "activate", G_CALLBACK(glatex_enter_key_pressed_in_entry), dialog); gtk_widget_show_all(vbox); if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) { gchar *env_string = NULL; env_string = g_strdup(gtk_combo_box_text_get_active_text( GTK_COMBO_BOX_TEXT(textbox_env))); if (env_string != NULL) { glatex_insert_environment(env_string, -1); g_free(env_string); } } gtk_widget_destroy(dialog); }
int main(int argc, char **argv) { GtkWidget *menubar,*submenu, *application, *about, *license, *department_list, *semester_list, *base, *list, *label_group, *list_group, *go, *align; Department dep; Semester sem; GtkWidget *active[2]; gtk_init (&argc, &argv); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (window), "GPA Calculator for Anna University"); gtk_window_set_resizable(GTK_WINDOW(window),FALSE); gtk_window_set_position(GTK_WINDOW(window),GTK_WIN_POS_CENTER); g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL); gtk_widget_show_all(window); menubar = gtk_menu_bar_new(); application = gtk_menu_item_new_with_label("Application"); submenu = gtk_menu_new(); gtk_menu_item_set_submenu(GTK_MENU_ITEM(application),(submenu)); about = gtk_menu_item_new_with_label("About"); g_signal_connect(about, "activate", G_CALLBACK(about_dialog),NULL); license = gtk_menu_item_new_with_label("License"); g_signal_connect(license, "activate", G_CALLBACK(license_dialog),NULL); gtk_menu_attach( GTK_MENU(gtk_menu_item_get_submenu(GTK_MENU_ITEM(application))),about,0,1,0,1); gtk_menu_attach( GTK_MENU(gtk_menu_item_get_submenu(GTK_MENU_ITEM(application))),license,0,1,1,2); gtk_container_add(GTK_CONTAINER(menubar),application); department_list = gtk_combo_box_text_new(); for(dep = CSE; dep<=EI; dep++) gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(department_list), departments[dep]); //make sure its const char* :) gtk_combo_box_set_active(GTK_COMBO_BOX(department_list),0); base = gtk_vbox_new(FALSE,10); semester_list = gtk_hbox_new(FALSE,10); list = gtk_combo_box_text_new(); for (sem = one; sem <=eight; sem++) gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(list), g_strdup_printf("%d",sem+1) ); gtk_combo_box_set_active(GTK_COMBO_BOX(list),0); label_group = gtk_vbox_new(FALSE,0); list_group = gtk_vbox_new(FALSE,0); gtk_box_pack_start(GTK_BOX(label_group), gtk_label_new("Department : "), TRUE, TRUE, 0 ); gtk_box_pack_start(GTK_BOX(label_group), gtk_label_new("Semester : "), TRUE, TRUE, 0 ); gtk_box_pack_start(GTK_BOX(list_group),department_list, TRUE, TRUE, 0 ); gtk_box_pack_start(GTK_BOX(list_group),list, TRUE, TRUE, 0 ); active[0] = department_list; active[1] = list; go = gtk_button_new_with_label("Go"); g_signal_connect(go,"clicked", G_CALLBACK(show_subjects),active ); align = gtk_alignment_new(1,1,0,0); gtk_alignment_set_padding(GTK_ALIGNMENT(align),0,10,0,10); gtk_container_add(GTK_CONTAINER(align), go); gtk_box_pack_start(GTK_BOX(semester_list), gtk_vseparator_new(), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(semester_list), label_group, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(semester_list), gtk_vseparator_new(), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(semester_list), list_group, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(semester_list), gtk_vseparator_new(), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(base), menubar, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(base), gtk_image_new_from_file("logo.png"), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(base), gtk_hseparator_new(), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(base), semester_list, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(base), gtk_hseparator_new(), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(base), align, FALSE, FALSE, 0); gtk_widget_show_all(base); gtk_container_add(GTK_CONTAINER(window), base); gtk_main(); return 0; }
/** Create layout selector. */ static void create_layout_selector(GKeyFile * cfg, GtkTable * table) { GtkWidget *label; gchar *buffer; gchar *thumbfile; guint i, sel = PREDEF_NUM - 1; /* get the current settings */ if (cfg != NULL) { buffer = mod_cfg_get_str(cfg, MOD_CFG_GLOBAL_SECTION, MOD_CFG_GRID, SAT_CFG_STR_MODULE_GRID); } else { buffer = sat_cfg_get_str(SAT_CFG_STR_MODULE_GRID); } /* create header */ label = gtk_label_new(_("Select layout:")); gtk_misc_set_alignment(GTK_MISC(label), 1.0, 0.5); gtk_table_attach(GTK_TABLE(table), label, 0, 1, 0, 1, GTK_SHRINK | GTK_FILL, GTK_EXPAND | GTK_FILL, 5, 0); /* layout selector */ selector = gtk_combo_box_text_new(); gtk_table_attach(GTK_TABLE(table), selector, 1, 3, 0, 1, GTK_FILL, GTK_SHRINK, 0, 0); for (i = 0; i < PREDEF_NUM; i++) { /* append default layout string to combo box */ gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(selector), _(predef_layout[i][1])); /* check if this layout corresponds to the settings */ if (!g_ascii_strcasecmp(buffer, predef_layout[i][0])) { sel = i; } } /* select settings */ gtk_combo_box_set_active(GTK_COMBO_BOX(selector), sel); /* connect signal handler */ g_signal_connect(selector, "changed", G_CALLBACK(layout_selected_cb), NULL); /* layout preview thumbnail */ thumbfile = thumb_file_from_sel(sel); thumb = gtk_image_new_from_file(thumbfile); g_free(thumbfile); gtk_table_attach(GTK_TABLE(table), thumb, 1, 3, 1, 2, GTK_EXPAND, GTK_EXPAND, 0, 5); /* layout string */ label = gtk_label_new(_("Layout code:")); gtk_misc_set_alignment(GTK_MISC(label), 1.0, 0.5); gtk_table_attach(GTK_TABLE(table), label, 0, 1, 2, 3, GTK_SHRINK | GTK_FILL, GTK_EXPAND | GTK_FILL, 5, 0); gridstr = gtk_entry_new(); gtk_entry_set_text(GTK_ENTRY(gridstr), buffer); g_free(buffer); gtk_widget_set_tooltip_text(gridstr, _("This entry holds the layout code for the " "module.\n" "Consult the user manual for how to create " "custom layouts using layout codes.")); /* disable if it is a predefined layout */ if (sel < PREDEF_NUM - 1) { gtk_widget_set_sensitive(gridstr, FALSE); } /* connect changed signal handler */ gridstr_sigid = g_signal_connect(gridstr, "changed", G_CALLBACK(layout_code_changed), NULL); gtk_table_attach_defaults(GTK_TABLE(table), gridstr, 1, 4, 2, 3); }
GtkWidget * pgd_selections_properties_selector_create (PgdSelectionsDemo *demo) { GtkWidget *hbox, *vbox; GtkWidget *label; GtkWidget *page_hbox, *page_selector; GtkWidget *scale_hbox, *scale_selector; GtkWidget *rotate_hbox, *rotate_selector; GtkWidget *color_hbox; GtkWidget *button; gint n_pages; gchar *str; n_pages = poppler_document_get_n_pages (demo->doc); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12); gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0); gtk_widget_show (hbox); page_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); label = gtk_label_new ("Page:"); gtk_box_pack_start (GTK_BOX (page_hbox), label, TRUE, TRUE, 0); gtk_widget_show (label); page_selector = gtk_spin_button_new_with_range (1, n_pages, 1); g_signal_connect (G_OBJECT (page_selector), "value-changed", G_CALLBACK (pgd_selections_page_selector_value_changed), (gpointer)demo); gtk_box_pack_start (GTK_BOX (page_hbox), page_selector, TRUE, TRUE, 0); gtk_widget_show (page_selector); str = g_strdup_printf ("of %d", n_pages); label = gtk_label_new (str); gtk_box_pack_start (GTK_BOX (page_hbox), label, TRUE, TRUE, 0); gtk_widget_show (label); g_free (str); gtk_box_pack_start (GTK_BOX (hbox), page_hbox, FALSE, TRUE, 0); gtk_widget_show (page_hbox); scale_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); label = gtk_label_new ("Scale:"); gtk_box_pack_start (GTK_BOX (scale_hbox), label, TRUE, TRUE, 0); gtk_widget_show (label); scale_selector = gtk_spin_button_new_with_range (0, 10.0, 0.1); gtk_spin_button_set_value (GTK_SPIN_BUTTON (scale_selector), 1.0); g_signal_connect (G_OBJECT (scale_selector), "value-changed", G_CALLBACK (pgd_selections_scale_selector_value_changed), (gpointer)demo); gtk_box_pack_start (GTK_BOX (scale_hbox), scale_selector, TRUE, TRUE, 0); gtk_widget_show (scale_selector); gtk_box_pack_start (GTK_BOX (hbox), scale_hbox, FALSE, TRUE, 0); gtk_widget_show (scale_hbox); rotate_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); label = gtk_label_new ("Rotate:"); gtk_box_pack_start (GTK_BOX (rotate_hbox), label, TRUE, TRUE, 0); gtk_widget_show (label); rotate_selector = gtk_combo_box_text_new (); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (rotate_selector), "0"); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (rotate_selector), "90"); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (rotate_selector), "180"); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (rotate_selector), "270"); gtk_combo_box_set_active (GTK_COMBO_BOX (rotate_selector), 0); #if 0 g_signal_connect (G_OBJECT (rotate_selector), "changed", G_CALLBACK (pgd_selections_rotate_selector_changed), (gpointer)demo); #endif gtk_box_pack_start (GTK_BOX (rotate_hbox), rotate_selector, TRUE, TRUE, 0); gtk_widget_show (rotate_selector); gtk_box_pack_start (GTK_BOX (hbox), rotate_hbox, FALSE, TRUE, 0); gtk_widget_show (rotate_hbox); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12); gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0); gtk_widget_show (hbox); color_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); label = gtk_label_new ("Foreground Color:"); gtk_box_pack_start (GTK_BOX (color_hbox), label, TRUE, TRUE, 0); gtk_widget_show (label); demo->fg_color_button = gtk_color_button_new (); g_signal_connect (demo->fg_color_button, "notify::color", G_CALLBACK (pgd_selections_fg_color_changed), (gpointer)demo); gtk_box_pack_start (GTK_BOX (color_hbox), demo->fg_color_button, TRUE, TRUE, 0); gtk_widget_show (demo->fg_color_button); gtk_box_pack_start (GTK_BOX (hbox), color_hbox, FALSE, TRUE, 0); gtk_widget_show (color_hbox); color_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); label = gtk_label_new ("Background Color:"); gtk_box_pack_start (GTK_BOX (color_hbox), label, TRUE, TRUE, 0); gtk_widget_show (label); demo->bg_color_button = gtk_color_button_new (); g_signal_connect (demo->bg_color_button, "notify::color", G_CALLBACK (pgd_selections_bg_color_changed), (gpointer)demo); gtk_box_pack_start (GTK_BOX (color_hbox), demo->bg_color_button, TRUE, TRUE, 0); gtk_widget_show (demo->bg_color_button); gtk_box_pack_start (GTK_BOX (hbox), color_hbox, FALSE, TRUE, 0); gtk_widget_show (color_hbox); demo->copy_button = gtk_button_new_with_label ("Copy"); g_signal_connect (G_OBJECT (demo->copy_button), "clicked", G_CALLBACK (pgd_selections_copy), (gpointer)demo); gtk_box_pack_end (GTK_BOX (hbox), demo->copy_button, FALSE, TRUE, 0); gtk_widget_set_sensitive(demo->copy_button, FALSE); gtk_widget_show (demo->copy_button); button = gtk_button_new_with_label ("Render"); g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (pgd_selections_render), (gpointer)demo); gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, TRUE, 0); gtk_widget_show (button); return vbox; }
int main(int argc,char **argv) { GtkWidget *win; GtkWidget *vbox; GtkWidget *hbox; GtkWidget *notebook; GtkWidget *page; GtkWidget *button; GtkWidget *api[4]; GtkWidget *box; GtkWidget *label; PREData data; char *name[]={"百度词典:","必应词典:","金山词霸:","有道词典:"}; char *dic[]={"百度词典","必应词典","金山词霸","有道词典"}; int i; /*设置默认UTF-8编码*/ setlocale(LC_ALL,""); #ifdef _WIN32 putenv("LANG=zh_CN.UTF-8"); #else setenv("LANG","zh_CN.UTF-8"); #endif /*先读取出配置*/ duoyi_read_config(&data.data); /*默认状态为未更改*/ data.changed=FALSE; gtk_init(&argc,&argv); win=gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(win),"配置"); gtk_window_set_position(GTK_WINDOW(win),GTK_WIN_POS_CENTER); gtk_window_set_icon_from_file(GTK_WINDOW(win), "img/64x64/preferences.png",NULL); gtk_window_set_resizable(GTK_WINDOW(win),FALSE); g_signal_connect(G_OBJECT(win),"delete-event", G_CALLBACK(pre_quit),&data); vbox=gtk_box_new(GTK_ORIENTATION_VERTICAL,0); notebook=gtk_notebook_new(); gtk_container_add(GTK_CONTAINER(win),vbox); gtk_box_pack_start(GTK_BOX(vbox),notebook,FALSE,FALSE,5); /*添加常规页*/ page=gtk_box_new(GTK_ORIENTATION_VERTICAL,0); label=gtk_label_new("常规"); gtk_notebook_append_page(GTK_NOTEBOOK(notebook),page,label); /*添加选择字体按钮*/ label=gtk_label_new("选择字体:"); hbox=gtk_box_new(GTK_ORIENTATION_HORIZONTAL,0); gtk_box_pack_start(GTK_BOX(page),hbox,FALSE,FALSE,20); gtk_box_pack_start(GTK_BOX(hbox),label,FALSE,FALSE,20); if(data.data.font) button=gtk_font_button_new_with_font(data.data.font); else button=gtk_font_button_new(); /*按钮使用字体显示文字*/ gtk_font_button_set_use_font(GTK_FONT_BUTTON(button),TRUE); gtk_font_button_set_title(GTK_FONT_BUTTON(button),"字体选择"); gtk_box_pack_start(GTK_BOX(hbox),button,TRUE,TRUE,100); g_signal_connect(G_OBJECT(button),"font-set", G_CALLBACK(pre_set_font),&data); /*添加默认词典选择*/ hbox=gtk_box_new(GTK_ORIENTATION_HORIZONTAL,0); gtk_box_pack_start(GTK_BOX(page),hbox,FALSE,FALSE,20); label=gtk_label_new("默认词典:"); gtk_box_pack_start(GTK_BOX(hbox),label,FALSE,FALSE,20); box=gtk_combo_box_text_new(); for(i=0;i != 4;++i) gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(box),dic[i]); gtk_combo_box_set_active(GTK_COMBO_BOX(box),data.data.dic); g_signal_connect(G_OBJECT(box),"changed", G_CALLBACK(pre_set_default_dic),&data); //gtk_combo_box_set_active(GTK_COMBO_BOX(box),data.data.dic); gtk_box_pack_start(GTK_BOX(hbox),box,TRUE,TRUE,100); /*添加API页*/ page=gtk_box_new(GTK_ORIENTATION_VERTICAL,0); label=gtk_label_new("API"); gtk_notebook_append_page(GTK_NOTEBOOK(notebook),page,label); for(i=0;i != 4;++i) { /*名称*/ label=gtk_label_new(name[i]); /*api输入框*/ api[i]=gtk_entry_new(); /*api*/ data.api[i]=api[i]; /*如果当前API已设置,则显示出来*/ if(data.data.api[i]) gtk_entry_set_text(GTK_ENTRY(api[i]),data.data.api[i]); hbox=gtk_box_new(GTK_ORIENTATION_HORIZONTAL,0); gtk_box_pack_start(GTK_BOX(page),hbox,TRUE,TRUE,10); gtk_box_pack_start(GTK_BOX(hbox),label,TRUE,TRUE,10); gtk_box_pack_start(GTK_BOX(hbox),api[i],TRUE,TRUE,10); /*如有改动更改操作状态*/ g_signal_connect(G_OBJECT(api[i]),"changed", G_CALLBACK(pre_save_flag),&data); } hbox=gtk_box_new(GTK_ORIENTATION_HORIZONTAL,0); gtk_box_pack_end(GTK_BOX(vbox),hbox,FALSE,FALSE,5); gtk_box_pack_end(GTK_BOX(vbox), gtk_separator_new(GTK_ORIENTATION_HORIZONTAL), FALSE,FALSE,5); label=gtk_label_new("所有更改均在重启后生效!"); gtk_box_pack_end(GTK_BOX(vbox),label,FALSE,FALSE,5); /*取消按钮*/ button=gtk_button_new_with_label("取消"); gtk_box_pack_start(GTK_BOX(hbox),button,FALSE,FALSE,20); g_signal_connect(G_OBJECT(button),"clicked", G_CALLBACK(pre_quit),&data); /*保存按钮*/ button=gtk_button_new_with_label("保存"); gtk_box_pack_end(GTK_BOX(hbox),button,FALSE,FALSE,20); g_signal_connect(G_OBJECT(button),"clicked", G_CALLBACK(pre_quit_with_save),&data); gtk_widget_show_all(win); gtk_main(); return 0; }