static SyncDialog *sync_dialog_new(GtkWidget *parent) { SyncDialog *sd; GtkWidget *dialog; GtkWidget *dialog1_vbox; GtkWidget *scrolledwindow2; GtkWidget *treeview2; GtkWidget *dialog1_action_area; GtkWidget *button8; GtkWidget *button7; GtkWidget *button6; GtkWidget *label; GtkWidget *hbox; GtkTreeViewColumn *column; GtkTreeModel *model; GtkListStore *store; GtkCellRenderer *cr_text, *cr_toggle; sd = g_new0(SyncDialog, 1); sd->sna = sync_dialog_netarea_new(); dialog = gtk_dialog_new(); gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(parent)); gtk_window_set_title(GTK_WINDOW(dialog), "Network Updater"); gtk_window_set_resizable(GTK_WINDOW(dialog), FALSE); gtk_window_set_icon(GTK_WINDOW(dialog), icon_cache_get_pixbuf("syncmanager.png")); gtk_window_set_default_size(GTK_WINDOW(dialog), 420, 260); gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER_ON_PARENT); gtk_window_set_type_hint(GTK_WINDOW(dialog), GDK_WINDOW_TYPE_HINT_DIALOG); gtk_container_set_border_width(GTK_CONTAINER(dialog), 5); dialog1_vbox = GTK_DIALOG(dialog)->vbox; gtk_box_set_spacing(GTK_BOX(dialog1_vbox), 5); gtk_container_set_border_width(GTK_CONTAINER(dialog1_vbox), 4); gtk_widget_show(dialog1_vbox); hbox = gtk_hbox_new(FALSE, 5); gtk_box_pack_start(GTK_BOX(dialog1_vbox), hbox, FALSE, FALSE, 0); label = gtk_label_new(LABEL_SYNC_DEFAULT); gtk_label_set_line_wrap(GTK_LABEL(label), TRUE); gtk_label_set_use_markup(GTK_LABEL(label), TRUE); gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); gtk_box_pack_start(GTK_BOX(hbox), icon_cache_get_image("syncmanager.png"), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, TRUE, 0); gtk_widget_show_all(hbox); gtk_box_pack_start(GTK_BOX(dialog1_vbox), sd->sna->vbox, TRUE, TRUE, 0); scrolledwindow2 = gtk_scrolled_window_new(NULL, NULL); gtk_widget_show(scrolledwindow2); gtk_box_pack_start(GTK_BOX(dialog1_vbox), scrolledwindow2, TRUE, TRUE, 0); gtk_widget_set_size_request(scrolledwindow2, -1, 200); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow2), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW (scrolledwindow2), GTK_SHADOW_IN); store = gtk_list_store_new(3, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_POINTER); model = GTK_TREE_MODEL(store); treeview2 = gtk_tree_view_new_with_model(model); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeview2), FALSE); gtk_widget_show(treeview2); gtk_container_add(GTK_CONTAINER(scrolledwindow2), treeview2); column = gtk_tree_view_column_new(); gtk_tree_view_append_column(GTK_TREE_VIEW(treeview2), column); cr_toggle = gtk_cell_renderer_toggle_new(); gtk_tree_view_column_pack_start(column, cr_toggle, FALSE); g_signal_connect(cr_toggle, "toggled", G_CALLBACK(sel_toggle), model); gtk_tree_view_column_add_attribute(column, cr_toggle, "active", 0); cr_text = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(column, cr_text, TRUE); gtk_tree_view_column_add_attribute(column, cr_text, "markup", 1); populate_store(store); dialog1_action_area = GTK_DIALOG(dialog)->action_area; gtk_widget_show(dialog1_action_area); gtk_button_box_set_layout(GTK_BUTTON_BOX(dialog1_action_area), GTK_BUTTONBOX_END); button8 = gtk_button_new_from_stock(GTK_STOCK_CANCEL); gtk_widget_show(button8); gtk_dialog_add_action_widget(GTK_DIALOG(dialog), button8, GTK_RESPONSE_CANCEL); GTK_WIDGET_SET_FLAGS(button8, GTK_CAN_DEFAULT); button7 = gtk_button_new_with_mnemonic("_Synchronize"); gtk_widget_show(button7); gtk_dialog_add_action_widget(GTK_DIALOG(dialog), button7, GTK_RESPONSE_ACCEPT); GTK_WIDGET_SET_FLAGS(button7, GTK_CAN_DEFAULT); button6 = gtk_button_new_from_stock(GTK_STOCK_CLOSE); g_signal_connect(G_OBJECT(button6), "clicked", (GCallback) close_clicked, NULL); gtk_dialog_add_action_widget(GTK_DIALOG(dialog), button6, GTK_RESPONSE_ACCEPT); GTK_WIDGET_SET_FLAGS(button6, GTK_CAN_DEFAULT); sd->dialog = dialog; sd->button_sync = button7; sd->button_cancel = button8; sd->button_close = button6; sd->scroll_box = scrolledwindow2; sd->label = label; return sd; }
static void import_widget_set_up_account_list (EmpathyImportWidget *self) { EmpathyImportWidgetPriv *priv = GET_PRIV (self); GtkListStore *store; GtkTreeView *view; GtkTreeViewColumn *column; GtkCellRenderer *cell; priv->accounts = empathy_import_accounts_load (priv->app_id); store = gtk_list_store_new (COL_COUNT, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER); gtk_tree_view_set_model (GTK_TREE_VIEW (priv->treeview), GTK_TREE_MODEL (store)); g_object_unref (store); view = GTK_TREE_VIEW (priv->treeview); gtk_tree_view_set_headers_visible (view, TRUE); /* Import column */ cell = gtk_cell_renderer_toggle_new (); gtk_tree_view_insert_column_with_attributes (view, -1, /* Translators: this is the header of a treeview column */ _("Import"), cell, "active", COL_IMPORT, NULL); g_signal_connect (cell, "toggled", G_CALLBACK (import_widget_cell_toggled_cb), self); /* Protocol column */ column = gtk_tree_view_column_new (); gtk_tree_view_column_set_title (column, _("Protocol")); gtk_tree_view_column_set_expand (column, TRUE); gtk_tree_view_append_column (view, column); cell = gtk_cell_renderer_text_new (); g_object_set (cell, "editable", FALSE, NULL); gtk_tree_view_column_pack_start (column, cell, TRUE); gtk_tree_view_column_add_attribute (column, cell, "text", COL_PROTOCOL); /* Account column */ column = gtk_tree_view_column_new (); gtk_tree_view_column_set_title (column, _("Account")); gtk_tree_view_column_set_expand (column, TRUE); gtk_tree_view_append_column (view, column); cell = gtk_cell_renderer_text_new (); g_object_set (cell, "editable", FALSE, NULL); gtk_tree_view_column_pack_start (column, cell, TRUE); gtk_tree_view_column_add_attribute (column, cell, "text", COL_NAME); if (priv->app_id == EMPATHY_IMPORT_APPLICATION_ALL) { /* Source column */ column = gtk_tree_view_column_new (); gtk_tree_view_column_set_title (column, _("Source")); gtk_tree_view_column_set_expand (column, TRUE); gtk_tree_view_append_column (view, column); cell = gtk_cell_renderer_text_new (); g_object_set (cell, "editable", FALSE, NULL); gtk_tree_view_column_pack_start (column, cell, TRUE); gtk_tree_view_column_add_attribute (column, cell, "text", COL_SOURCE); } import_widget_add_accounts_to_model (self); }
void gtkui_help(void) { GtkWidget *dialog, *scrolled, *treeview, *hbox, *textview; GtkCellRenderer *renderer; GtkTreeViewColumn *column; GtkTreeIter iter; help_pair *section; DEBUG_MSG("gtkui_help"); dialog = gtk_dialog_new_with_buttons(EC_PROGRAM" Help", GTK_WINDOW (window), GTK_DIALOG_MODAL, GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, NULL); gtk_window_set_default_size(GTK_WINDOW (dialog), 780, 580); gtk_dialog_set_has_separator(GTK_DIALOG (dialog), TRUE); gtk_container_set_border_width(GTK_CONTAINER (dialog), 5); hbox = gtk_hbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), hbox, TRUE, TRUE, 0); scrolled = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW (scrolled), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW (scrolled), GTK_SHADOW_IN); gtk_box_pack_start(GTK_BOX(hbox), scrolled, FALSE, FALSE, 0); gtk_widget_show(scrolled); treeview = gtk_tree_view_new(); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW (treeview), FALSE); gtk_container_add(GTK_CONTAINER (scrolled), treeview); gtk_widget_show(treeview); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview)); gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE); g_signal_connect(selection, "changed", G_CALLBACK (gtkui_help_selected), liststore); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Contents", renderer, "text", 0, NULL); gtk_tree_view_column_set_sort_column_id (column, 0); gtk_tree_view_append_column (GTK_TREE_VIEW(treeview), column); liststore = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_POINTER); for(section = help_list; section->title; section++) { gtk_list_store_append (liststore, &iter); gtk_list_store_set (liststore, &iter, 0, section->title, 1, section->file, -1); } gtk_tree_view_set_model(GTK_TREE_VIEW (treeview), GTK_TREE_MODEL (liststore)); /* text area */ scrolled = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW (scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW (scrolled), GTK_SHADOW_IN); gtk_box_pack_start(GTK_BOX(hbox), scrolled, TRUE, TRUE, 0); gtk_widget_show(scrolled); textview = gtk_text_view_new(); gtk_text_view_set_editable(GTK_TEXT_VIEW (textview), FALSE); gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW (textview), FALSE); gtk_container_add(GTK_CONTAINER (scrolled), textview); gtk_widget_show(textview); textbuf = gtk_text_view_get_buffer(GTK_TEXT_VIEW (textview)); gtk_widget_show_all(hbox); gtk_dialog_run(GTK_DIALOG (dialog)); gtk_widget_destroy (dialog); }
/* * Create a new owner tree view for one type of owners. * This view will be based on a model that is common to all views of * the same set of books, but will have its own private filter on that * model. */ GtkTreeView * gnc_tree_view_owner_new (GncOwnerType owner_type) { GncTreeView *view; GtkTreeModel *model, *f_model, *s_model; const gchar *sample_type, *sample_currency; GncTreeViewOwnerPrivate *priv; GtkTreeViewColumn *tax_info_column; GtkCellRenderer *renderer; ENTER(" "); /* Create our view */ view = g_object_new (GNC_TYPE_TREE_VIEW_OWNER, "name", "owner_tree", NULL); priv = GNC_TREE_VIEW_OWNER_GET_PRIVATE(GNC_TREE_VIEW_OWNER (view)); /* Create/get a pointer to the existing model for this set of books. */ model = gnc_tree_model_owner_new (owner_type); /* Set up the view private filter layer on the common model. */ f_model = gtk_tree_model_filter_new (model, NULL); /* A GncTreeModelOwner is based on a GncTreeModel, which is a * GObject that provides a GtkTreeModel interface. */ g_object_unref(G_OBJECT(model)); /* Set up the view private sort layer on the common model. */ s_model = gtk_tree_model_sort_new_with_model(f_model); g_object_unref(G_OBJECT(f_model)); gnc_tree_view_set_model (view, s_model); g_object_unref(G_OBJECT(s_model)); /* Set default visibilities */ gtk_tree_view_set_headers_visible (GTK_TREE_VIEW(view), FALSE); sample_type = gncOwnerTypeToQofIdType (GNC_OWNER_CUSTOMER); sample_currency = gnc_commodity_get_fullname(gnc_default_currency()); priv->name_column = gnc_tree_view_add_text_column(view, _("Owner Name"), GNC_OWNER_TREE_NAME_COL, NULL, "GnuCash Inc.", GNC_TREE_MODEL_OWNER_COL_NAME, GNC_TREE_VIEW_COLUMN_VISIBLE_ALWAYS, sort_by_string); gnc_tree_view_add_text_column(view, _("Type"), GNC_OWNER_TREE_TYPE_COL, NULL, sample_type, GNC_TREE_MODEL_OWNER_COL_TYPE, GNC_TREE_VIEW_COLUMN_VISIBLE_ALWAYS, sort_by_string); priv->id_column = gnc_tree_view_add_text_column(view, _("Owner ID"), GNC_OWNER_TREE_ID_COL, NULL, "1-123-1234", GNC_TREE_MODEL_OWNER_COL_ID, GNC_TREE_VIEW_COLUMN_VISIBLE_ALWAYS, sort_by_string); gnc_tree_view_add_text_column(view, _("Currency"), GNC_OWNER_TREE_CURRENCY_COL, NULL, sample_currency, GNC_TREE_MODEL_OWNER_COL_CURRENCY, GNC_TREE_VIEW_COLUMN_VISIBLE_ALWAYS, sort_by_string); gnc_tree_view_add_text_column(view, _("Address Name"), GNC_OWNER_TREE_ADDRESS_NAME_COL, NULL, "GnuCash Inc.", GNC_TREE_MODEL_OWNER_COL_ADDRESS_NAME, GNC_TREE_VIEW_COLUMN_VISIBLE_ALWAYS, sort_by_string); gnc_tree_view_add_text_column(view, _("Address 1"), GNC_OWNER_TREE_ADDRESS_1_COL, NULL, "Free Software Foundation", GNC_TREE_MODEL_OWNER_COL_ADDRESS_1, GNC_TREE_VIEW_COLUMN_VISIBLE_ALWAYS, sort_by_string); gnc_tree_view_add_text_column(view, _("Address 2"), GNC_OWNER_TREE_ADDRESS_2_COL, NULL, "51 Franklin Street, Fifth Floor", GNC_TREE_MODEL_OWNER_COL_ADDRESS_2, GNC_TREE_VIEW_COLUMN_VISIBLE_ALWAYS, sort_by_string); gnc_tree_view_add_text_column(view, _("Address 3"), GNC_OWNER_TREE_ADDRESS_3_COL, NULL, "Boston, MA 02110-1301", GNC_TREE_MODEL_OWNER_COL_ADDRESS_3, GNC_TREE_VIEW_COLUMN_VISIBLE_ALWAYS, sort_by_string); gnc_tree_view_add_text_column(view, _("Address 4"), GNC_OWNER_TREE_ADDRESS_4_COL, NULL, "USA", GNC_TREE_MODEL_OWNER_COL_ADDRESS_4, GNC_TREE_VIEW_COLUMN_VISIBLE_ALWAYS, sort_by_string); gnc_tree_view_add_text_column(view, _("Phone"), GNC_OWNER_TREE_PHONE_COL, NULL, "+1-617-542-5942", GNC_TREE_MODEL_OWNER_COL_PHONE, GNC_TREE_VIEW_COLUMN_VISIBLE_ALWAYS, sort_by_string); gnc_tree_view_add_text_column(view, _("Fax"), GNC_OWNER_TREE_FAX_COL, NULL, "+1-617-542-2652", GNC_TREE_MODEL_OWNER_COL_FAX, GNC_TREE_VIEW_COLUMN_VISIBLE_ALWAYS, sort_by_string); gnc_tree_view_add_text_column(view, _("E-mail"), GNC_OWNER_TREE_EMAIL_COL, NULL, "*****@*****.**", GNC_TREE_MODEL_OWNER_COL_EMAIL, GNC_TREE_VIEW_COLUMN_VISIBLE_ALWAYS, sort_by_string); gnc_tree_view_add_numeric_column(view, _("Balance"), GNC_OWNER_TREE_BALANCE_COL, SAMPLE_OWNER_VALUE, GNC_TREE_MODEL_OWNER_COL_BALANCE, GNC_TREE_MODEL_OWNER_COL_COLOR_BALANCE, GNC_TREE_VIEW_COLUMN_VISIBLE_ALWAYS, sort_by_balance_value); priv->balance_report_column = gnc_tree_view_add_numeric_column(view, _("Balance"), GNC_OWNER_TREE_BALANCE_REPORT_COL, SAMPLE_OWNER_VALUE, GNC_TREE_MODEL_OWNER_COL_BALANCE_REPORT, GNC_TREE_MODEL_OWNER_COL_COLOR_BALANCE, GNC_TREE_VIEW_COLUMN_VISIBLE_ALWAYS, sort_by_balance_value); priv->notes_column = gnc_tree_view_add_text_column(view, _("Notes"), GNC_OWNER_TREE_NOTES_COL, NULL, "Sample owner notes.", GNC_TREE_MODEL_OWNER_COL_NOTES, GNC_TREE_VIEW_COLUMN_VISIBLE_ALWAYS, sort_by_string); gnc_tree_view_add_toggle_column (view, _("Active"), /* Translators: This string has a context prefix; the translation must only contain the part after the | character. */ Q_("Column letter for 'Active'|A"), GNC_OWNER_TREE_ACTIVE_COL, GNC_TREE_MODEL_OWNER_COL_ACTIVE, GNC_TREE_VIEW_COLUMN_VISIBLE_ALWAYS, sort_by_boolean, gnc_tree_view_owner_active_toggled); /* Update column titles to use the currency name. */ gtvo_update_column_names(view); /* By default only the first column is visible. */ gnc_tree_view_configure_columns(view); gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER (f_model), gnc_tree_view_owner_filter_helper, view, NULL); /* Default the sorting to owner name */ gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(s_model), GNC_TREE_MODEL_OWNER_COL_NAME, GTK_SORT_ASCENDING); gtk_widget_show(GTK_WIDGET(view)); LEAVE("%p", view); return GTK_TREE_VIEW(view); }
GtkWidget* create_dialog1 (void) { GtkWidget *dialog1; GtkWidget *dialog_vbox1; GtkWidget *scrolledwindow1; GtkWidget *treeview1; GtkWidget *dialog_action_area1; GtkWidget *cancelbutton1; GtkWidget *okbutton1; dialog1 = gtk_dialog_new (); gtk_window_set_title (GTK_WINDOW (dialog1), QT_TR_NOOP("Recent files")); dialog_vbox1 = GTK_DIALOG (dialog1)->vbox; gtk_widget_show (dialog_vbox1); scrolledwindow1 = gtk_scrolled_window_new (NULL, NULL); gtk_widget_show (scrolledwindow1); gtk_box_pack_start (GTK_BOX (dialog_vbox1), scrolledwindow1, TRUE, TRUE, 0); //__________ PATCH BEGIN HERE_________________________ store = gtk_list_store_new (1, G_TYPE_STRING); treeview1 = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store)); GtkTreeViewColumn *column; GtkCellRenderer *renderer; renderer = gtk_cell_renderer_text_new (); /* Create a column, associating the "text" attribute of the * cell_renderer to the first column of the model */ column = gtk_tree_view_column_new_with_attributes ("File", renderer, "text", 0, NULL); /* Add the column to the view. */ gtk_tree_view_append_column (GTK_TREE_VIEW (treeview1), column); //_______________PATCH END HERE____________________ // treeview1 = gtk_tree_view_new (); gtk_widget_show (treeview1); gtk_container_add (GTK_CONTAINER (scrolledwindow1), treeview1); gtk_container_set_border_width (GTK_CONTAINER (treeview1), 1); gtk_widget_set_size_request (treeview1, 400, 150); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview1), TRUE); gtk_tree_view_set_enable_search (GTK_TREE_VIEW (treeview1), FALSE); dialog_action_area1 = GTK_DIALOG (dialog1)->action_area; gtk_widget_show (dialog_action_area1); gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area1), GTK_BUTTONBOX_END); cancelbutton1 = gtk_button_new_from_stock ("gtk-cancel"); gtk_widget_show (cancelbutton1); gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), cancelbutton1, GTK_RESPONSE_CANCEL); GTK_WIDGET_SET_FLAGS (cancelbutton1, GTK_CAN_DEFAULT); okbutton1 = gtk_button_new_from_stock ("gtk-ok"); gtk_widget_show (okbutton1); gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), okbutton1, GTK_RESPONSE_OK); GTK_WIDGET_SET_FLAGS (okbutton1, GTK_CAN_DEFAULT); /* Store pointers to all widgets, for use by lookup_widget(). */ GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog1, "dialog1"); GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_vbox1, "dialog_vbox1"); GLADE_HOOKUP_OBJECT (dialog1, scrolledwindow1, "scrolledwindow1"); GLADE_HOOKUP_OBJECT (dialog1, treeview1, "treeview1"); GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_action_area1, "dialog_action_area1"); GLADE_HOOKUP_OBJECT (dialog1, cancelbutton1, "cancelbutton1"); GLADE_HOOKUP_OBJECT (dialog1, okbutton1, "okbutton1"); return dialog1; }
/* * create target page */ void tpage_init() { page = gtk_hbox_new(FALSE, 0); GtkWidget *lbox = gtk_vbox_new(FALSE, SPACING); GtkWidget *mbox = gtk_vbox_new(FALSE, SPACING); GtkWidget *rbox = gtk_vbox_new(FALSE, SPACING); GtkWidget* separator = gtk_vseparator_new(); /* right box with Load/Save buttons */ gtk_container_set_border_width(GTK_CONTAINER(rbox), SPACING); loadbtn = gtk_button_new_from_stock(GTK_STOCK_OPEN); g_signal_connect(G_OBJECT(loadbtn), "clicked", G_CALLBACK (on_load_config), (gpointer)TRUE); savebtn = gtk_button_new_from_stock(GTK_STOCK_SAVE); g_signal_connect(G_OBJECT(savebtn), "clicked", G_CALLBACK (on_save_config), NULL); clearbtn = gtk_button_new_from_stock(GTK_STOCK_CLEAR); g_signal_connect(G_OBJECT(clearbtn), "clicked", G_CALLBACK (on_clear), NULL); gtk_box_pack_start(GTK_BOX(rbox), loadbtn, FALSE, TRUE, 0); gtk_box_pack_start(GTK_BOX(rbox), savebtn, FALSE, TRUE, 0); gtk_box_pack_start(GTK_BOX(rbox), clearbtn, FALSE, TRUE, 0); GtkWidget *hombox = gtk_hbox_new(TRUE, 0); /* left box */ gtk_container_set_border_width(GTK_CONTAINER(lbox), SPACING); /* Target frame */ GtkWidget *frame = gtk_frame_new(_("Target")); GtkWidget *vbox = gtk_vbox_new(FALSE, 0); /* filename hbox */ GtkWidget *hbox = gtk_hbox_new(FALSE, SPACING); gtk_container_set_border_width(GTK_CONTAINER(hbox), SPACING); targetname = gtk_entry_new (); button_browse = gtk_button_new_with_label(_("Browse")); g_signal_connect(G_OBJECT(button_browse), "clicked", G_CALLBACK (on_target_browse_clicked), NULL); gtk_box_pack_start(GTK_BOX(hbox), targetname, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(hbox), button_browse, FALSE, TRUE, 0); /* pack in the vertical box */ gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0); /* debugger type hbox */ hbox = gtk_hbox_new(FALSE, SPACING); gtk_container_set_border_width(GTK_CONTAINER(hbox), SPACING); GtkWidget *label = gtk_label_new(_("Debugger:")); cmb_debugger = gtk_combo_box_new_text(); GList *modules = debug_get_modules(); GList *iter = modules; while (iter) { gtk_combo_box_append_text(GTK_COMBO_BOX(cmb_debugger), (gchar*)iter->data); iter = iter->next; } g_list_free(modules); gtk_combo_box_set_active(GTK_COMBO_BOX(cmb_debugger), 0); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox), cmb_debugger, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0); gtk_container_add(GTK_CONTAINER(frame), vbox); gtk_box_pack_start(GTK_BOX(lbox), frame, FALSE, FALSE, 0); /* Arguments frame */ frame = gtk_frame_new(_("Arguments")); hbox = gtk_vbox_new(FALSE, SPACING); gtk_container_set_border_width(GTK_CONTAINER(hbox), SPACING); textview = gtk_text_view_new (); gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(textview), GTK_WRAP_CHAR); gtk_box_pack_start(GTK_BOX(hbox), textview, TRUE, TRUE, 0); gtk_container_add(GTK_CONTAINER(frame), hbox); gtk_box_pack_start(GTK_BOX(lbox), frame, TRUE, TRUE, 0); /* Environment */ gtk_container_set_border_width(GTK_CONTAINER(mbox), SPACING); frame = gtk_frame_new(_("Environment variables")); hbox = gtk_hbox_new(FALSE, SPACING); gtk_container_set_border_width(GTK_CONTAINER(hbox), SPACING); store = gtk_list_store_new ( N_COLUMNS, G_TYPE_STRING, G_TYPE_STRING); model = GTK_TREE_MODEL(store); envtree = gtk_tree_view_new_with_model (model); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(envtree), TRUE); gtk_tree_view_set_grid_lines (GTK_TREE_VIEW(envtree), GTK_TREE_VIEW_GRID_LINES_VERTICAL); g_object_set(envtree, "rules-hint", TRUE, NULL); g_signal_connect(G_OBJECT(envtree), "key-press-event", G_CALLBACK (on_envtree_keypressed), NULL); gchar *header; int char_width = get_char_width(envtree); header = _("Name"); renderer_name = gtk_cell_renderer_text_new (); g_object_set (renderer_name, "editable", TRUE, NULL); g_signal_connect (G_OBJECT (renderer_name), "edited", G_CALLBACK (on_name_changed), NULL); column_name = create_column(header, renderer_name, FALSE, get_header_string_width(header, MW_NAME, char_width), "text", NAME); gtk_tree_view_append_column (GTK_TREE_VIEW (envtree), column_name); header = _("Value"); renderer_value = gtk_cell_renderer_text_new (); column_value = create_column(header, renderer_value, TRUE, get_header_string_width(header, MW_VALUE, char_width), "text", VALUE); g_signal_connect (G_OBJECT (renderer_value), "edited", G_CALLBACK (on_value_changed), NULL); g_signal_connect (G_OBJECT (renderer_value), "editing-started", G_CALLBACK (on_value_editing_started), NULL); g_signal_connect (G_OBJECT (renderer_value), "editing-canceled", G_CALLBACK (on_value_editing_cancelled), NULL); gtk_tree_view_column_set_cell_data_func(column_value, renderer_value, on_render_value, NULL, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (envtree), column_value); /* add empty row */ add_empty_row(); /* set multiple selection */ GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(envtree)); gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE); gtk_box_pack_start(GTK_BOX(hbox), envtree, TRUE, TRUE, 0); gtk_container_add(GTK_CONTAINER(frame), hbox); gtk_box_pack_start(GTK_BOX(mbox), frame, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(hombox), lbox, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(hombox), mbox, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(page), hombox, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(page), separator, FALSE, TRUE, 0); gtk_box_pack_start(GTK_BOX(page), rbox, FALSE, TRUE, 0); /* update Load/Save config button */ tpage_on_document_activate(document_get_current()); }
/** * favorite_selector_new * * Returns: a new #GtkWidget */ GtkWidget * favorite_selector_new (BrowserConnection *bcnc) { FavoriteSelector *tsel; GdaTreeManager *manager; g_return_val_if_fail (BROWSER_IS_CONNECTION (bcnc), NULL); tsel = FAVORITE_SELECTOR (g_object_new (FAVORITE_SELECTOR_TYPE, NULL)); tsel->priv->bcnc = g_object_ref (bcnc); g_signal_connect (browser_connection_get_favorites (tsel->priv->bcnc), "favorites-changed", G_CALLBACK (favorites_changed_cb), tsel); /* create tree managers */ tsel->priv->tree = gda_tree_new (); manager = mgr_favorites_new (bcnc, GDA_TOOLS_FAVORITES_TABLES | GDA_TOOLS_FAVORITES_DIAGRAMS, ORDER_KEY_SCHEMA); gda_tree_add_manager (tsel->priv->tree, manager); g_object_unref (manager); /* update the tree's contents */ if (tsel->priv->idle_update_favorites == 0) tsel->priv->idle_update_favorites = g_idle_add ((GSourceFunc) idle_update_favorites, tsel); /* header */ GtkWidget *label; gchar *str; str = g_strdup_printf ("<b>%s</b>", _("Favorites")); label = gdaui_bar_new (str); g_free (str); gdaui_bar_set_icon_from_pixbuf (GDAUI_BAR (label), browser_get_pixbuf_icon (BROWSER_ICON_BOOKMARK)); gtk_box_pack_start (GTK_BOX (tsel), label, FALSE, FALSE, 0); gtk_widget_show (label); /* tree model */ GtkTreeModel *model; GtkWidget *treeview; GtkCellRenderer *renderer; GtkTreeViewColumn *column; model = gdaui_tree_store_new (tsel->priv->tree, 5, G_TYPE_STRING, "markup", G_TYPE_OBJECT, "icon", G_TYPE_STRING, MGR_FAVORITES_CONTENTS_ATT_NAME, G_TYPE_UINT, MGR_FAVORITES_TYPE_ATT_NAME, G_TYPE_INT, MGR_FAVORITES_ID_ATT_NAME); treeview = browser_make_tree_view (model); tsel->priv->treeview = treeview; g_object_unref (model); /* icon */ column = gtk_tree_view_column_new (); renderer = gtk_cell_renderer_pixbuf_new (); gtk_tree_view_column_pack_start (column, renderer, FALSE); gtk_tree_view_column_add_attribute (column, renderer, "pixbuf", COLUMN_ICON); /* text */ renderer = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, renderer, TRUE); gtk_tree_view_column_add_attribute (column, renderer, "markup", COLUMN_MARKUP); gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column); /* scrolled window packing */ GtkWidget *sw; sw = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_ETCHED_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_container_add (GTK_CONTAINER (sw), treeview); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview), FALSE); gtk_box_pack_start (GTK_BOX (tsel), sw, TRUE, TRUE, 0); gtk_widget_show_all (sw); g_signal_connect (G_OBJECT (treeview), "row-activated", G_CALLBACK (selection_changed_cb), tsel); g_signal_connect (G_OBJECT (treeview), "key-press-event", G_CALLBACK (key_press_event_cb), tsel); /* DnD */ gtk_tree_view_enable_model_drag_dest (GTK_TREE_VIEW (treeview), dbo_table, G_N_ELEMENTS (dbo_table), GDK_ACTION_COPY); gtk_tree_view_enable_model_drag_source (GTK_TREE_VIEW (treeview), GDK_BUTTON1_MASK, dbo_table, G_N_ELEMENTS (dbo_table), GDK_ACTION_COPY | GDK_ACTION_MOVE); g_signal_connect (model, "drag-drop", G_CALLBACK (tree_store_drag_drop_cb), tsel); g_signal_connect (model, "drag-can-drag", G_CALLBACK (tree_store_drag_can_drag_cb), tsel); g_signal_connect (model, "drag-get", G_CALLBACK (tree_store_drag_get_cb), tsel); return (GtkWidget*) tsel; }
/** * Statistic Viewer's constructor * * This constructor is used to create StatisticViewerData data structure. * @return The Statistic viewer data created. */ StatisticViewerData * gui_statistic(LttvPluginTab *ptab) { GtkCellRenderer *renderer; GtkTreeViewColumn *column; StatisticViewerData* statistic_viewer_data = g_new(StatisticViewerData,1); statistic_viewer_data->live_trace_count = 0; Tab *tab = ptab->tab; statistic_viewer_data->tab = tab; statistic_viewer_data->ptab = ptab; // statistic_viewer_data->stats = // lttvwindow_get_traceset_stats(statistic_viewer_data->tab); // statistic_viewer_data->calculate_stats = // statistic_insert_traceset_stats((void *)statistic_viewer_data->stats); lttvwindow_register_traceset_notify(statistic_viewer_data->tab, statistic_traceset_changed, statistic_viewer_data); statistic_viewer_data->statistic_hash = g_hash_table_new_full(g_str_hash, g_str_equal, statistic_destroy_hash_key, NULL); statistic_viewer_data->hpaned_v = gtk_hpaned_new(); statistic_viewer_data->store_m = gtk_tree_store_new (N_COLUMNS, G_TYPE_STRING); statistic_viewer_data->tree_v = gtk_tree_view_new_with_model ( GTK_TREE_MODEL (statistic_viewer_data->store_m)); g_object_unref (G_OBJECT (statistic_viewer_data->store_m)); // Setup the selection handler statistic_viewer_data->select_c = gtk_tree_view_get_selection (GTK_TREE_VIEW (statistic_viewer_data->tree_v)); gtk_tree_selection_set_mode (statistic_viewer_data->select_c, GTK_SELECTION_SINGLE); g_signal_connect (G_OBJECT (statistic_viewer_data->select_c), "changed", G_CALLBACK (tree_selection_changed_cb), statistic_viewer_data); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Statistic Name", renderer, "text", NAME_COLUMN, NULL); gtk_tree_view_column_set_alignment (column, 0.0); // gtk_tree_view_column_set_fixed_width (column, 45); gtk_tree_view_append_column (GTK_TREE_VIEW (statistic_viewer_data->tree_v), column); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW (statistic_viewer_data->tree_v), FALSE); statistic_viewer_data->scroll_win_tree = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(statistic_viewer_data->scroll_win_tree), GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC); gtk_container_add (GTK_CONTAINER (statistic_viewer_data->scroll_win_tree), statistic_viewer_data->tree_v); gtk_paned_pack1(GTK_PANED(statistic_viewer_data->hpaned_v),statistic_viewer_data->scroll_win_tree, TRUE, FALSE); gtk_paned_set_position(GTK_PANED(statistic_viewer_data->hpaned_v), 160); statistic_viewer_data->scroll_win_text = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(statistic_viewer_data->scroll_win_text), GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC); statistic_viewer_data->text_v = gtk_text_view_new (); gtk_text_view_set_editable(GTK_TEXT_VIEW(statistic_viewer_data->text_v),FALSE); gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(statistic_viewer_data->text_v),FALSE); gtk_container_add (GTK_CONTAINER (statistic_viewer_data->scroll_win_text), statistic_viewer_data->text_v); gtk_paned_pack2(GTK_PANED(statistic_viewer_data->hpaned_v), statistic_viewer_data->scroll_win_text, TRUE, FALSE); gtk_container_set_border_width( GTK_CONTAINER(statistic_viewer_data->hpaned_v), 1); gtk_widget_show(statistic_viewer_data->scroll_win_tree); gtk_widget_show(statistic_viewer_data->scroll_win_text); gtk_widget_show(statistic_viewer_data->tree_v); gtk_widget_show(statistic_viewer_data->text_v); gtk_widget_show(statistic_viewer_data->hpaned_v); g_object_set_data_full( G_OBJECT(guistatistic_get_widget(statistic_viewer_data)), "statistic_viewer_data", statistic_viewer_data, (GDestroyNotify)gui_statistic_destructor); /* Add the object's information to the module's array */ g_statistic_viewer_data_list = g_slist_append( g_statistic_viewer_data_list, statistic_viewer_data); request_background_data(statistic_viewer_data); return statistic_viewer_data; }
SeahorseKeyManagerStore* seahorse_key_manager_store_new (GcrCollection *collection, GtkTreeView *view, SeahorsePredicate *pred, GSettings *settings) { SeahorseKeyManagerStore *self; GtkTreeViewColumn *col; SeahorseCollection *filtered; GtkCellRenderer *renderer; gchar *sort_by; guint last; filtered = seahorse_collection_new_for_predicate (collection, pred, NULL); pred->custom = on_filter_visible; self = g_object_new (SEAHORSE_TYPE_KEY_MANAGER_STORE, "collection", filtered, "settings", settings, "mode", GCR_COLLECTION_MODEL_LIST, NULL); pred->custom_target = self; g_object_unref (filtered); last = gcr_collection_model_set_columns (GCR_COLLECTION_MODEL (self), columns); g_return_val_if_fail (last == N_COLS, NULL); /* The sorted model is the top level model */ gtk_tree_view_set_model (view, GTK_TREE_MODEL (self)); /* add the icon column */ renderer = gtk_cell_renderer_pixbuf_new (); g_object_set (renderer, "stock-size", GTK_ICON_SIZE_DND, NULL); g_object_set (renderer, "ypad", 6, NULL); g_object_set (renderer, "yalign", 0.0, NULL); col = gtk_tree_view_column_new_with_attributes ("", renderer, "gicon", COL_ICON, NULL); gtk_tree_view_column_set_resizable (col, FALSE); gtk_tree_view_append_column (view, col); /* Name column */ col = gtk_tree_view_column_new (); renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "ypad", 6, "yalign", 0.0, "ellipsize", PANGO_ELLIPSIZE_END, NULL); gtk_tree_view_column_pack_start (col, renderer, TRUE); gtk_tree_view_column_set_attributes (col, renderer, "markup", COL_MARKUP, NULL); renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "ypad", 6, "xpad", 3, "yalign", 0.0, "xalign", 1.0, "scale", PANGO_SCALE_SMALL, "alignment", PANGO_ALIGN_RIGHT, NULL); gtk_tree_view_column_pack_start (col, renderer, FALSE); gtk_tree_view_column_set_attributes (col, renderer, "markup", COL_DESCRIPTION, NULL); gtk_tree_view_column_set_resizable (col, TRUE); gtk_tree_view_column_set_expand (col, TRUE); gtk_tree_view_append_column (view, col); gtk_tree_view_column_set_sort_column_id (col, COL_LABEL); /* Use predicate to figure out which columns to add */ if (SEAHORSE_IS_COLLECTION (collection)) pred = seahorse_collection_get_predicate (SEAHORSE_COLLECTION (collection)); else pred = NULL; /* Also watch for sort-changed on the store */ g_signal_connect (self, "sort-column-changed", G_CALLBACK (on_sort_column_changed), self); /* Update sort order in case the sorted column was added */ if ((sort_by = g_settings_get_string (settings, "sort-by")) != NULL) { set_sort_to (self, sort_by); g_free (sort_by); } gtk_tree_view_set_enable_search (view, FALSE); gtk_tree_view_set_show_expanders (view, FALSE); gtk_tree_view_set_rules_hint (view, TRUE); gtk_tree_view_set_headers_visible (view, FALSE); gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (self), COL_LABEL, GTK_SORT_ASCENDING); /* Tree drag */ egg_tree_multi_drag_add_drag_support (view); g_signal_connect (G_OBJECT (view), "drag_data_get", G_CALLBACK (drag_data_get), self); g_signal_connect (G_OBJECT (view), "drag_begin", G_CALLBACK (drag_begin), self); g_signal_connect (G_OBJECT (view), "drag_end", G_CALLBACK (drag_end), self); gtk_drag_source_set (GTK_WIDGET (view), GDK_BUTTON1_MASK, store_targets, G_N_ELEMENTS (store_targets), GDK_ACTION_COPY); return self; }
void SetupHashWindow() { /* Setup window */ gui.windows.hash = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(gui.windows.hash), "Hashes"); gtk_window_set_default_size(GTK_WINDOW(gui.windows.hash), 580, 340); gtk_window_set_deletable(GTK_WINDOW(gui.windows.hash), false); gui.fixed.hash = gtk_fixed_new(); gtk_container_add(GTK_CONTAINER(gui.windows.hash), gui.fixed.hash); /* Load hashes */ gui.entries.hash = gtk_entry_new(); gtk_widget_set_size_request(gui.entries.hash, 380, 32); gtk_fixed_put(GTK_FIXED(gui.fixed.hash), gui.entries.hash, 8, 8); gui.cbox.hash = gtk_combo_box_new_text(); gtk_combo_box_append_text(GTK_COMBO_BOX(gui.cbox.hash), "Hashlist"); gtk_combo_box_append_text(GTK_COMBO_BOX(gui.cbox.hash), "Hash"); gtk_combo_box_append_text(GTK_COMBO_BOX(gui.cbox.hash), "pwdump"); gtk_combo_box_append_text(GTK_COMBO_BOX(gui.cbox.hash), "Cain"); gtk_widget_set_size_request(gui.cbox.hash, 90, 32); gtk_combo_box_set_active(GTK_COMBO_BOX(gui.cbox.hash), 0); gtk_fixed_put(GTK_FIXED(gui.fixed.hash), gui.cbox.hash, 390, 8); gui.buttons.hash_load = gtk_button_new_with_label("Load"); gtk_widget_set_size_request(gui.buttons.hash_load, 80, 32); gtk_fixed_put(GTK_FIXED(gui.fixed.hash), gui.buttons.hash_load, 485, 8); /* TreeView */ gui.hash.scroll = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(gui.hash.scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS); gui.hash.tree = gtk_tree_view_new(); gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(gui.hash.tree), true); gtk_tree_view_set_rubber_banding(GTK_TREE_VIEW(gui.hash.tree), true); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(gui.hash.tree), true); gtk_tree_view_set_headers_clickable(GTK_TREE_VIEW(gui.hash.tree), true); gui.hash.store = gtk_list_store_new(3, G_TYPE_STRING, G_TYPE_INT, G_TYPE_STRING); gtk_tree_view_set_model(GTK_TREE_VIEW(gui.hash.tree), GTK_TREE_MODEL(gui.hash.store)); gui.hash.render = gtk_cell_renderer_text_new(); GtkTreeViewColumn *col = gtk_tree_view_column_new_with_attributes("Algorithm", gui.hash.render, "text", 0, NULL); gtk_tree_view_column_set_sort_column_id(col, 0); gtk_tree_view_append_column(GTK_TREE_VIEW(gui.hash.tree), col); col = gtk_tree_view_column_new_with_attributes("Length", gui.hash.render, "text", 1, NULL); gtk_tree_view_column_set_sort_column_id(col, 1); gtk_tree_view_append_column(GTK_TREE_VIEW(gui.hash.tree), col); col = gtk_tree_view_column_new_with_attributes("Hash", gui.hash.render, "text", 2, NULL); gtk_tree_view_column_set_sort_column_id(col, 2); gtk_tree_view_append_column(GTK_TREE_VIEW(gui.hash.tree), col); GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(gui.hash.tree)); gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE); gtk_container_add(GTK_CONTAINER(gui.hash.scroll), gui.hash.tree); gtk_widget_set_size_request(gui.hash.tree, 560, 240); gtk_fixed_put(GTK_FIXED(gui.fixed.hash), gui.hash.scroll, 8, 48); /* Buttons */ gui.buttons.hash_delete = gtk_button_new_with_label("Remove"); gtk_widget_set_size_request(gui.buttons.hash_delete, 80, 32); gtk_fixed_put(GTK_FIXED(gui.fixed.hash), gui.buttons.hash_delete, 8, 300); gui.buttons.hash_clear = gtk_button_new_with_label("Clear"); gtk_widget_set_size_request(gui.buttons.hash_clear, 80, 32); gtk_fixed_put(GTK_FIXED(gui.fixed.hash), gui.buttons.hash_clear, 100, 300); gui.buttons.hash_ok = gtk_button_new_with_label("OK"); gtk_widget_set_size_request(gui.buttons.hash_ok, 80, 32); gtk_fixed_put(GTK_FIXED(gui.fixed.hash), gui.buttons.hash_ok, 480, 300); g_signal_connect(gui.buttons.hash_load, "clicked", G_CALLBACK(LoadHashes), NULL); g_signal_connect(gui.buttons.hash_ok, "clicked", G_CALLBACK(HideHashWindow), NULL); g_signal_connect(gui.buttons.hash_delete, "clicked", G_CALLBACK(DeleteHashes), NULL); g_signal_connect(gui.buttons.hash_clear, "clicked", G_CALLBACK(ClearHashes), NULL); return; }
GtkWidget *Create_Log_Area (void) { GtkWidget *Frame; GtkWidget *ScrollWindowLogList; GtkCellRenderer *renderer; GtkTreeViewColumn *column; GtkWidget *PopupMenu; Frame = gtk_frame_new(_("Log")); gtk_container_set_border_width(GTK_CONTAINER(Frame), 2); /* * The ScrollWindow and the List */ ScrollWindowLogList = gtk_scrolled_window_new(NULL,NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(ScrollWindowLogList), GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC); gtk_container_add(GTK_CONTAINER(Frame),ScrollWindowLogList); /* The file list */ logListModel = gtk_list_store_new(LOG_COLUMN_COUNT, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, GDK_TYPE_COLOR, GDK_TYPE_COLOR); LogList = gtk_tree_view_new_with_model(GTK_TREE_MODEL(logListModel)); g_object_unref (logListModel); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(LogList), FALSE); gtk_container_add(GTK_CONTAINER(ScrollWindowLogList), LogList); gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(LogList), FALSE); gtk_widget_set_size_request(LogList, 0, 0); gtk_tree_view_set_reorderable(GTK_TREE_VIEW(LogList), FALSE); gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(LogList)),GTK_SELECTION_MULTIPLE); column = gtk_tree_view_column_new(); gtk_tree_view_append_column(GTK_TREE_VIEW(LogList), column); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE); renderer = gtk_cell_renderer_pixbuf_new(); gtk_tree_view_column_pack_start(column, renderer, FALSE); gtk_tree_view_column_set_attributes(column, renderer, "stock-id", LOG_PIXBUF, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(column, renderer, FALSE); gtk_tree_view_column_set_attributes(column, renderer, "text", LOG_TIME_TEXT, "background-gdk", LOG_ROW_BACKGROUND, "foreground-gdk", LOG_ROW_FOREGROUND, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(column, renderer, FALSE); gtk_tree_view_column_set_attributes(column, renderer, "text", LOG_TEXT, "background-gdk", LOG_ROW_BACKGROUND, "foreground-gdk", LOG_ROW_FOREGROUND, NULL); // Create Popup Menu on browser album list PopupMenu = gtk_ui_manager_get_widget(UIManager, "/LogPopup"); gtk_menu_attach_to_widget (GTK_MENU (PopupMenu), LogList, NULL); g_signal_connect (G_OBJECT (LogList), "button-press-event", G_CALLBACK (Log_Popup_Menu_Handler), PopupMenu); // Load pending messages in the Log list Log_Print_Tmp_List(); if (SHOW_LOG_VIEW) //gtk_widget_show_all(ScrollWindowLogList); gtk_widget_show_all(Frame); //return ScrollWindowLogList; return Frame; }
GtkWidget * userlist_create (GtkWidget *box) { GtkWidget *sw, *treeview; static const GtkTargetEntry dnd_dest_targets[] = { {"text/uri-list", 0, 1}, {"XCHAT_CHANVIEW", GTK_TARGET_SAME_APP, 75 } }; static const GtkTargetEntry dnd_src_target[] = { {"XCHAT_USERLIST", GTK_TARGET_SAME_APP, 75 } }; sw = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_ETCHED_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), prefs.pchat_gui_ulist_show_hosts ? GTK_POLICY_AUTOMATIC : GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_box_pack_start (GTK_BOX (box), sw, TRUE, TRUE, 0); gtk_widget_show (sw); treeview = gtk_tree_view_new (); gtk_widget_set_name (treeview, "xchat-userlist"); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview), FALSE); gtk_tree_selection_set_mode (gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview)), GTK_SELECTION_MULTIPLE); /* set up drops */ gtk_drag_dest_set (treeview, GTK_DEST_DEFAULT_ALL, dnd_dest_targets, 2, GDK_ACTION_MOVE | GDK_ACTION_COPY | GDK_ACTION_LINK); gtk_drag_source_set (treeview, GDK_BUTTON1_MASK, dnd_src_target, 1, GDK_ACTION_MOVE); /* file DND (for DCC) */ g_signal_connect (G_OBJECT (treeview), "drag_motion", G_CALLBACK (userlist_dnd_motion), treeview); g_signal_connect (G_OBJECT (treeview), "drag_leave", G_CALLBACK (userlist_dnd_leave), 0); g_signal_connect (G_OBJECT (treeview), "drag_data_received", G_CALLBACK (userlist_dnd_drop), treeview); g_signal_connect (G_OBJECT (treeview), "button_press_event", G_CALLBACK (userlist_click_cb), 0); g_signal_connect (G_OBJECT (treeview), "key_press_event", G_CALLBACK (userlist_key_cb), 0); /* tree/chanview DND */ #ifndef _WIN32 /* leaks GDI pool memory, don't enable */ g_signal_connect (G_OBJECT (treeview), "drag_begin", G_CALLBACK (mg_drag_begin_cb), NULL); g_signal_connect (G_OBJECT (treeview), "drag_drop", G_CALLBACK (mg_drag_drop_cb), NULL); g_signal_connect (G_OBJECT (treeview), "drag_motion", G_CALLBACK (mg_drag_motion_cb), NULL); g_signal_connect (G_OBJECT (treeview), "drag_end", G_CALLBACK (mg_drag_end_cb), NULL); #endif userlist_add_columns (GTK_TREE_VIEW (treeview)); gtk_container_add (GTK_CONTAINER (sw), treeview); gtk_widget_show (treeview); return treeview; }
static void gb_book_links_construct (GbBookLinks *self) { GbBookLinksPrivate *priv; GtkWidget *swindow; GtkTreeViewColumn *column; GtkCellRenderer *renderer; GtkTreeSelection *selection; priv = self->priv; swindow = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (swindow), GTK_SHADOW_IN); /* Create tree view */ priv->tree_view = gtk_tree_view_new (); gtk_tree_view_set_activate_on_single_click (GTK_TREE_VIEW (priv->tree_view), TRUE); g_signal_connect_swapped (priv->tree_view, "row-activated", G_CALLBACK (schedule_emit_link_activated), self); gtk_tree_view_set_show_expanders (GTK_TREE_VIEW (priv->tree_view), FALSE); gtk_tree_view_set_level_indentation (GTK_TREE_VIEW (priv->tree_view), 20); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->tree_view)); gtk_tree_selection_set_mode (selection, GTK_SELECTION_BROWSE); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (priv->tree_view), FALSE); gtk_container_add (GTK_CONTAINER (swindow), priv->tree_view); gtk_box_pack_start (GTK_BOX (self), swindow, TRUE, TRUE, 0); gtk_widget_show_all (GTK_WIDGET (self)); column = gtk_tree_view_column_new (); gtk_tree_view_column_set_expand (GTK_TREE_VIEW_COLUMN (column), TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW (priv->tree_view), column); renderer = (GtkCellRenderer *) g_object_new (GTK_TYPE_CELL_RENDERER_TEXT, "ellipsize", PANGO_ELLIPSIZE_END, "weight", PANGO_WEIGHT_BOLD, "xpad", 10, NULL); gtk_tree_view_column_pack_start (GTK_TREE_VIEW_COLUMN (column), renderer, TRUE); gtk_tree_view_column_set_attributes (GTK_TREE_VIEW_COLUMN (column), renderer, "markup", BOOK_LINKS_COLUMN_MARKUP, NULL); renderer = gd_styled_text_renderer_new (); gd_styled_text_renderer_add_class (GD_STYLED_TEXT_RENDERER (renderer), "dim-label"); g_object_set (renderer, "max-width-chars", 12, "scale", PANGO_SCALE_SMALL, "xalign", 1.0, "xpad", 10, NULL); gtk_tree_view_column_pack_end (GTK_TREE_VIEW_COLUMN (column), renderer, FALSE); /* gtk_tree_view_column_set_attributes (GTK_TREE_VIEW_COLUMN (column), renderer, "text", BOOK_LINKS_COLUMN_LABEL, NULL); */ priv->model = (GtkTreeModel *)gtk_list_store_new (BOOK_LINKS_COLUMN_N, G_TYPE_STRING, G_TYPE_STRING); }
static PanelAddtoDialog * panel_addto_dialog_new (PanelWidget *panel_widget) { PanelAddtoDialog *dialog; GtkWidget *dialog_vbox; #if !GTK_CHECK_VERSION (3, 0, 0) GtkWidget *vbox; #endif GtkWidget *inner_vbox; GtkWidget *find_hbox; GtkWidget *sw; GtkCellRenderer *renderer; GtkTreeSelection *selection; GtkTreeViewColumn *column; dialog = g_new0 (PanelAddtoDialog, 1); g_object_set_qdata_full (G_OBJECT (panel_widget->toplevel), panel_addto_dialog_quark, dialog, (GDestroyNotify) panel_addto_dialog_free); dialog->panel_widget = panel_widget; g_signal_connect (dialog->panel_widget->toplevel->settings, "changed::" PANEL_TOPLEVEL_NAME_KEY, G_CALLBACK (panel_addto_name_notify), dialog); dialog->addto_dialog = gtk_dialog_new (); gtk_dialog_add_button (GTK_DIALOG (dialog->addto_dialog), GTK_STOCK_HELP, GTK_RESPONSE_HELP); dialog->back_button = gtk_dialog_add_button (GTK_DIALOG (dialog->addto_dialog), GTK_STOCK_GO_BACK, PANEL_ADDTO_RESPONSE_BACK); dialog->add_button = gtk_dialog_add_button (GTK_DIALOG (dialog->addto_dialog), GTK_STOCK_ADD, PANEL_ADDTO_RESPONSE_ADD); gtk_dialog_add_button (GTK_DIALOG (dialog->addto_dialog), GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE); gtk_widget_set_sensitive (GTK_WIDGET (dialog->add_button), FALSE); gtk_dialog_set_default_response (GTK_DIALOG (dialog->addto_dialog), PANEL_ADDTO_RESPONSE_ADD); gtk_container_set_border_width (GTK_CONTAINER (dialog->addto_dialog), 5); dialog_vbox = gtk_dialog_get_content_area (GTK_DIALOG (dialog->addto_dialog)); #if GTK_CHECK_VERSION (3, 0, 0) gtk_box_set_spacing (GTK_BOX (dialog_vbox), 12); gtk_container_set_border_width (GTK_CONTAINER (dialog_vbox), 5); #else gtk_box_set_spacing (GTK_BOX (dialog_vbox), 2); #endif g_signal_connect (G_OBJECT (dialog->addto_dialog), "response", G_CALLBACK (panel_addto_dialog_response), dialog); g_signal_connect (dialog->addto_dialog, "destroy", G_CALLBACK (panel_addto_dialog_destroy), dialog); #if !GTK_CHECK_VERSION (3, 0, 0) vbox = gtk_vbox_new (FALSE, 12); gtk_container_set_border_width (GTK_CONTAINER (vbox), 5); gtk_container_add (GTK_CONTAINER (dialog_vbox), vbox); #endif inner_vbox = gtk_vbox_new (FALSE, 6); #if GTK_CHECK_VERSION (3, 0, 0) gtk_box_pack_start (GTK_BOX (dialog_vbox), inner_vbox, TRUE, TRUE, 0); #else gtk_box_pack_start (GTK_BOX (vbox), inner_vbox, TRUE, TRUE, 0); #endif find_hbox = gtk_hbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (inner_vbox), find_hbox, FALSE, FALSE, 0); dialog->label = gtk_label_new_with_mnemonic (""); gtk_misc_set_alignment (GTK_MISC (dialog->label), 0.0, 0.5); gtk_label_set_use_markup (GTK_LABEL (dialog->label), TRUE); gtk_box_pack_start (GTK_BOX (find_hbox), dialog->label, FALSE, FALSE, 0); dialog->search_entry = gtk_entry_new (); g_signal_connect (G_OBJECT (dialog->search_entry), "changed", G_CALLBACK (panel_addto_search_entry_changed), dialog); g_signal_connect (G_OBJECT (dialog->search_entry), "activate", G_CALLBACK (panel_addto_search_entry_activated), dialog); gtk_box_pack_end (GTK_BOX (find_hbox), dialog->search_entry, TRUE, TRUE, 0); gtk_label_set_mnemonic_widget (GTK_LABEL (dialog->label), dialog->search_entry); sw = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_IN); gtk_box_pack_start (GTK_BOX (inner_vbox), sw, TRUE, TRUE, 0); dialog->tree_view = gtk_tree_view_new (); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (dialog->tree_view), FALSE); gtk_tree_view_expand_all (GTK_TREE_VIEW (dialog->tree_view)); renderer = g_object_new (GTK_TYPE_CELL_RENDERER_PIXBUF, "xpad", 4, "ypad", 4, NULL); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (dialog->tree_view), -1, NULL, renderer, "pixbuf", COLUMN_ICON, NULL); renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "ellipsize", PANGO_ELLIPSIZE_END, NULL); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (dialog->tree_view), -1, NULL, renderer, "markup", COLUMN_TEXT, NULL); //FIXME use the same search than the one for the search entry? gtk_tree_view_set_search_column (GTK_TREE_VIEW (dialog->tree_view), COLUMN_SEARCH); gtk_tree_view_set_row_separator_func (GTK_TREE_VIEW (dialog->tree_view), panel_addto_separator_func, GINT_TO_POINTER (COLUMN_TEXT), NULL); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (dialog->tree_view)); gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE); column = gtk_tree_view_get_column (GTK_TREE_VIEW (dialog->tree_view), COLUMN_TEXT); gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED); g_signal_connect (selection, "changed", G_CALLBACK (panel_addto_selection_changed), dialog); g_signal_connect (dialog->tree_view, "row-activated", G_CALLBACK (panel_addto_selection_activated), dialog); gtk_container_add (GTK_CONTAINER (sw), dialog->tree_view); #if GTK_CHECK_VERSION (3, 0, 0) gtk_widget_show_all (dialog_vbox); #else gtk_widget_show_all (vbox); #endif panel_toplevel_push_autohide_disabler (dialog->panel_widget->toplevel); panel_widget_register_open_dialog (panel_widget, dialog->addto_dialog); panel_addto_name_change (dialog, panel_toplevel_get_name (dialog->panel_widget->toplevel)); return dialog; }
static GtkWidget *create_window(void) { // Basic window stwidgets.startwin = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(stwidgets.startwin), apptitle); // NOTE: use global app title gtk_window_set_position(GTK_WINDOW(stwidgets.startwin), GTK_WIN_POS_CENTER); gtk_window_set_resizable(GTK_WINDOW(stwidgets.startwin), FALSE); gtk_window_set_type_hint(GTK_WINDOW(stwidgets.startwin), GDK_WINDOW_TYPE_HINT_DIALOG); // Horizontal layout of banner and controls stwidgets.hlayout = gtk_hbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(stwidgets.startwin), stwidgets.hlayout); // banner { GdkPixbuf *pixbuf = load_banner(); stwidgets.banner = gtk_image_new_from_pixbuf(pixbuf); g_object_unref((gpointer)pixbuf); } gtk_box_pack_start(GTK_BOX(stwidgets.hlayout), stwidgets.banner, FALSE, FALSE, 0); gtk_misc_set_alignment(GTK_MISC(stwidgets.banner), 0.5, 0); // Vertical layout of tab control and start+cancel buttons stwidgets.vlayout = gtk_vbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(stwidgets.hlayout), stwidgets.vlayout, TRUE, TRUE, 0); // Tab control stwidgets.tabs = gtk_notebook_new(); gtk_box_pack_start(GTK_BOX(stwidgets.vlayout), stwidgets.tabs, TRUE, TRUE, 0); gtk_container_set_border_width(GTK_CONTAINER(stwidgets.tabs), 4); // layout table of config page stwidgets.configtlayout = gtk_table_new(6, 3, FALSE); gtk_container_add(GTK_CONTAINER(stwidgets.tabs), stwidgets.configtlayout); // 3D video mode LabelText stwidgets.vmode3dlabel = gtk_label_new_with_mnemonic("_Video mode:"); gtk_misc_set_alignment(GTK_MISC(stwidgets.vmode3dlabel), 0.3, 0); gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.vmode3dlabel, 0,1, 0,1, GTK_FILL, 0, 4, 0); // 3D video mode combo { GtkListStore *list = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_INT); GtkCellRenderer *cell; stwidgets.vmode3dcombo = gtk_combo_box_new_with_model(GTK_TREE_MODEL(list)); g_object_unref(G_OBJECT(list)); cell = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(stwidgets.vmode3dcombo), cell, FALSE); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(stwidgets.vmode3dcombo), cell, "text", 0, NULL); } gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.vmode3dcombo, 1,2, 0,1, GTK_EXPAND | GTK_FILL, 0, 4, 0); // Fullscreen checkbox stwidgets.displayvlayout = gtk_vbox_new(TRUE, 0); gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.displayvlayout, 2,3, 0,1, GTK_FILL, 0, 4, 0); stwidgets.fullscreencheck = gtk_check_button_new_with_mnemonic("_Fullscreen"); gtk_box_pack_start(GTK_BOX(stwidgets.displayvlayout), stwidgets.fullscreencheck, FALSE, FALSE, 0); #ifdef POLYMER // Polymer checkbox stwidgets.polymercheck = gtk_check_button_new_with_mnemonic("_Polymer"); gtk_box_pack_start(GTK_BOX(stwidgets.displayvlayout), stwidgets.polymercheck, FALSE, FALSE, 0); #endif // Input devices LabelText stwidgets.inputdevlabel = gtk_label_new_with_mnemonic("_Input devices:"); gtk_misc_set_alignment(GTK_MISC(stwidgets.inputdevlabel), 0.3, 0); gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.inputdevlabel, 0,1, 1,2, GTK_FILL, 0, 4, 0); // Input devices combo { GtkListStore *list = gtk_list_store_new(1, G_TYPE_STRING); GtkCellRenderer *cell; stwidgets.inputdevcombo = gtk_combo_box_new_with_model(GTK_TREE_MODEL(list)); g_object_unref(G_OBJECT(list)); cell = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(stwidgets.inputdevcombo), cell, FALSE); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(stwidgets.inputdevcombo), cell, "text", 0, NULL); } gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.inputdevcombo, 1,2, 1,2, GTK_EXPAND | GTK_FILL, 0, 4, 0); // Custom mod LabelText stwidgets.custommodlabel = gtk_label_new_with_mnemonic("Custom _game:"); gtk_misc_set_alignment(GTK_MISC(stwidgets.custommodlabel), 0.3, 0); gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.custommodlabel, 0,1, 2,3, GTK_FILL, 0, 4, 7); // Custom mod combo { GtkListStore *list = gtk_list_store_new(1, G_TYPE_STRING); GtkCellRenderer *cell; stwidgets.custommodcombo = gtk_combo_box_new_with_model(GTK_TREE_MODEL(list)); g_object_unref(G_OBJECT(list)); cell = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(stwidgets.custommodcombo), cell, FALSE); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(stwidgets.custommodcombo), cell, "text", 0, NULL); } gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.custommodcombo, 1,2, 2,3, GTK_EXPAND | GTK_FILL, 0, 4, 7); // Empty horizontal layout stwidgets.emptyhlayout = gtk_hbox_new(TRUE, 0); gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.emptyhlayout, 0,3, 3,4, 0, GTK_EXPAND | GTK_FILL, 4, 0); // Autoload checkbox stwidgets.autoloadcheck = gtk_check_button_new_with_mnemonic("_Enable \"autoload\" folder"); gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.autoloadcheck, 0,3, 4,5, GTK_FILL, 0, 2, 2); // Always show config checkbox stwidgets.alwaysshowcheck = gtk_check_button_new_with_mnemonic("_Always show this window at startup"); gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.alwaysshowcheck, 0,3, 5,6, GTK_FILL, 0, 2, 2); // Configuration tab stwidgets.configtab = gtk_label_new("Configuration"); gtk_notebook_set_tab_label(GTK_NOTEBOOK(stwidgets.tabs), gtk_notebook_get_nth_page(GTK_NOTEBOOK(stwidgets.tabs), 0), stwidgets.configtab); // Game data layout stwidgets.gamevlayout = gtk_vbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(stwidgets.tabs), stwidgets.gamevlayout); gtk_container_set_border_width(GTK_CONTAINER(stwidgets.gamevlayout), 4); // Game data field LabelText stwidgets.gamelabel = gtk_label_new_with_mnemonic("_Game:"); gtk_box_pack_start(GTK_BOX(stwidgets.gamevlayout), stwidgets.gamelabel, FALSE, FALSE, 0); gtk_misc_set_alignment(GTK_MISC(stwidgets.gamelabel), 0, 0.5); // Game data scrollable area stwidgets.gamescroll = gtk_scrolled_window_new(NULL, NULL); gtk_box_pack_start(GTK_BOX(stwidgets.gamevlayout), stwidgets.gamescroll, TRUE, TRUE, 0); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(stwidgets.gamescroll), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(stwidgets.gamescroll), GTK_SHADOW_IN); // Game data list { GtkListStore *list = gtk_list_store_new(3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER); GtkCellRenderer *cell; GtkTreeViewColumn *col; gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(list), 0, name_sorter, NULL, NULL); gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(list), 0, GTK_SORT_ASCENDING); stwidgets.gamelist = gtk_tree_view_new_with_model(GTK_TREE_MODEL(list)); g_object_unref(G_OBJECT(list)); cell = gtk_cell_renderer_text_new(); col = gtk_tree_view_column_new_with_attributes("Game", cell, "text", 0, NULL); gtk_tree_view_column_set_expand(col, TRUE); gtk_tree_view_append_column(GTK_TREE_VIEW(stwidgets.gamelist), col); col = gtk_tree_view_column_new_with_attributes("GRP file", cell, "text", 1, NULL); gtk_tree_view_column_set_min_width(col, 64); gtk_tree_view_append_column(GTK_TREE_VIEW(stwidgets.gamelist), col); } gtk_container_add(GTK_CONTAINER(stwidgets.gamescroll), stwidgets.gamelist); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(stwidgets.gamelist), FALSE); gtk_tree_view_set_enable_search(GTK_TREE_VIEW(stwidgets.gamelist), FALSE); // Game tab stwidgets.gametab = gtk_label_new("Game"); gtk_notebook_set_tab_label(GTK_NOTEBOOK(stwidgets.tabs), gtk_notebook_get_nth_page(GTK_NOTEBOOK(stwidgets.tabs), 1), stwidgets.gametab); // Messages scrollable area stwidgets.messagesscroll = gtk_scrolled_window_new(NULL, NULL); gtk_container_add(GTK_CONTAINER(stwidgets.tabs), stwidgets.messagesscroll); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(stwidgets.messagesscroll), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS); // Messages text area stwidgets.messagestext = gtk_text_view_new(); gtk_container_add(GTK_CONTAINER(stwidgets.messagesscroll), stwidgets.messagestext); gtk_text_view_set_editable(GTK_TEXT_VIEW(stwidgets.messagestext), FALSE); gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(stwidgets.messagestext), GTK_WRAP_WORD); gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(stwidgets.messagestext), FALSE); gtk_text_view_set_left_margin(GTK_TEXT_VIEW(stwidgets.messagestext), 2); gtk_text_view_set_right_margin(GTK_TEXT_VIEW(stwidgets.messagestext), 2); // Messages tab stwidgets.messagestab = gtk_label_new("Messages"); gtk_notebook_set_tab_label(GTK_NOTEBOOK(stwidgets.tabs), gtk_notebook_get_nth_page(GTK_NOTEBOOK(stwidgets.tabs), 2), stwidgets.messagestab); // Dialogue box buttons layout stwidgets.buttons = gtk_hbutton_box_new(); gtk_box_pack_start(GTK_BOX(stwidgets.vlayout), stwidgets.buttons, FALSE, TRUE, 0); gtk_container_set_border_width(GTK_CONTAINER(stwidgets.buttons), 3); gtk_button_box_set_layout(GTK_BUTTON_BOX(stwidgets.buttons), GTK_BUTTONBOX_END); // Cancel button stwidgets.cancelbutton = gtk_button_new(); gtk_container_add(GTK_CONTAINER(stwidgets.buttons), stwidgets.cancelbutton); GTK_WIDGET_SET_FLAGS(stwidgets.cancelbutton, GTK_CAN_DEFAULT); stwidgets.cancelbuttonalign = gtk_alignment_new(0.5, 0.5, 0, 0); gtk_container_add(GTK_CONTAINER(stwidgets.cancelbutton), stwidgets.cancelbuttonalign); stwidgets.cancelbuttonlayout = gtk_hbox_new(FALSE, 2); gtk_container_add(GTK_CONTAINER(stwidgets.cancelbuttonalign), stwidgets.cancelbuttonlayout); stwidgets.cancelbuttonicon = gtk_image_new_from_stock("gtk-cancel", GTK_ICON_SIZE_BUTTON); gtk_box_pack_start(GTK_BOX(stwidgets.cancelbuttonlayout), stwidgets.cancelbuttonicon, FALSE, FALSE, 0); stwidgets.cancelbuttonlabel = gtk_label_new_with_mnemonic("_Cancel"); gtk_box_pack_start(GTK_BOX(stwidgets.cancelbuttonlayout), stwidgets.cancelbuttonlabel, FALSE, FALSE, 0); // Start button stwidgets.startbutton = gtk_button_new(); gtk_container_add(GTK_CONTAINER(stwidgets.buttons), stwidgets.startbutton); GTK_WIDGET_SET_FLAGS(stwidgets.startbutton, GTK_CAN_DEFAULT); gtk_window_set_default(GTK_WINDOW(stwidgets.startwin), stwidgets.startbutton); stwidgets.startbuttonalign = gtk_alignment_new(0.5, 0.5, 0, 0); gtk_container_add(GTK_CONTAINER(stwidgets.startbutton), stwidgets.startbuttonalign); stwidgets.startbuttonlayout = gtk_hbox_new(FALSE, 2); gtk_container_add(GTK_CONTAINER(stwidgets.startbuttonalign), stwidgets.startbuttonlayout); stwidgets.startbuttonicon = gtk_image_new_from_stock("gtk-execute", GTK_ICON_SIZE_BUTTON); gtk_box_pack_start(GTK_BOX(stwidgets.startbuttonlayout), stwidgets.startbuttonicon, FALSE, FALSE, 0); stwidgets.startbuttonlabel = gtk_label_new_with_mnemonic("_Start"); gtk_box_pack_start(GTK_BOX(stwidgets.startbuttonlayout), stwidgets.startbuttonlabel, FALSE, FALSE, 0); // Wire up the signals g_signal_connect((gpointer) stwidgets.startwin, "delete_event", G_CALLBACK(on_startwin_delete_event), NULL); g_signal_connect((gpointer) stwidgets.vmode3dcombo, "changed", G_CALLBACK(on_vmode3dcombo_changed), NULL); g_signal_connect((gpointer) stwidgets.fullscreencheck, "toggled", G_CALLBACK(on_fullscreencheck_toggled), NULL); #ifdef POLYMER g_signal_connect((gpointer) stwidgets.polymercheck, "toggled", G_CALLBACK(on_polymercheck_toggled), NULL); #endif g_signal_connect((gpointer) stwidgets.inputdevcombo, "changed", G_CALLBACK(on_inputdevcombo_changed), NULL); g_signal_connect((gpointer) stwidgets.custommodcombo, "changed", G_CALLBACK(on_custommodcombo_changed), NULL); g_signal_connect((gpointer) stwidgets.autoloadcheck, "toggled", G_CALLBACK(on_autoloadcheck_toggled), NULL); g_signal_connect((gpointer) stwidgets.alwaysshowcheck, "toggled", G_CALLBACK(on_alwaysshowcheck_toggled), NULL); g_signal_connect((gpointer) stwidgets.cancelbutton, "clicked", G_CALLBACK(on_cancelbutton_clicked), NULL); g_signal_connect((gpointer) stwidgets.startbutton, "clicked", G_CALLBACK(on_startbutton_clicked), NULL); { GtkTreeSelection *sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(stwidgets.gamelist)); gtk_tree_selection_set_mode(sel, GTK_SELECTION_SINGLE); g_signal_connect((gpointer) sel, "changed", G_CALLBACK(on_gamelist_selection_changed), NULL); } // Associate labels with their controls gtk_label_set_mnemonic_widget(GTK_LABEL(stwidgets.vmode3dlabel), stwidgets.vmode3dcombo); gtk_label_set_mnemonic_widget(GTK_LABEL(stwidgets.inputdevlabel), stwidgets.inputdevcombo); gtk_label_set_mnemonic_widget(GTK_LABEL(stwidgets.custommodlabel), stwidgets.custommodcombo); gtk_label_set_mnemonic_widget(GTK_LABEL(stwidgets.gamelabel), stwidgets.gamelist); return stwidgets.startwin; }
static GtkWidget * servlist_open_networks (void) { GtkWidget *servlist; GtkWidget *vbox1; GtkWidget *label2; GtkWidget *table1; GtkWidget *label3; GtkWidget *label4; GtkWidget *label5; GtkWidget *label6; GtkWidget *label7; GtkWidget *entry1; GtkWidget *entry2; GtkWidget *entry3; GtkWidget *entry4; GtkWidget *entry5; GtkWidget *vbox2; GtkWidget *label1; GtkWidget *table4; GtkWidget *scrolledwindow3; GtkWidget *treeview_networks; GtkWidget *checkbutton_skip; GtkWidget *vbuttonbox2; GtkWidget *button_add; GtkWidget *button_remove; GtkWidget *button_edit; GtkWidget *button_sort; GtkWidget *button_connect; GtkTreeModel *model; GtkListStore *store; GtkCellRenderer *renderer; servlist = mg_create_generic_tab(_("Network List"), _("conspire: Networks"), FALSE, TRUE, servlist_close_cb, NULL, 640, 480, &vbox1, NULL); label2 = bold_label (_("User Information")); gtk_box_pack_start (GTK_BOX (vbox1), label2, FALSE, FALSE, 0); table1 = gtk_table_new (5, 2, FALSE); gtk_widget_show (table1); gtk_box_pack_start (GTK_BOX (vbox1), table1, FALSE, FALSE, 0); gtk_container_set_border_width (GTK_CONTAINER (table1), 8); gtk_table_set_row_spacings (GTK_TABLE (table1), 2); gtk_table_set_col_spacings (GTK_TABLE (table1), 4); label3 = gtk_label_new_with_mnemonic (_("_Nick name:")); gtk_widget_show (label3); gtk_table_attach (GTK_TABLE (table1), label3, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label3), 0, 0.5); label4 = gtk_label_new (_("Second choice:")); gtk_widget_show (label4); gtk_table_attach (GTK_TABLE (table1), label4, 0, 1, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label4), 0, 0.5); label5 = gtk_label_new (_("Third choice:")); gtk_widget_show (label5); gtk_table_attach (GTK_TABLE (table1), label5, 0, 1, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label5), 0, 0.5); label6 = gtk_label_new_with_mnemonic (_("_User name:")); gtk_widget_show (label6); gtk_table_attach (GTK_TABLE (table1), label6, 0, 1, 3, 4, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label6), 0, 0.5); label7 = gtk_label_new_with_mnemonic (_("Rea_l name:")); gtk_widget_show (label7); gtk_table_attach (GTK_TABLE (table1), label7, 0, 1, 4, 5, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label7), 0, 0.5); entry_nick1 = entry1 = gtk_entry_new (); gtk_entry_set_text (GTK_ENTRY (entry1), prefs.nick1); gtk_widget_show (entry1); gtk_table_attach (GTK_TABLE (table1), entry1, 1, 2, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); entry_nick2 = entry2 = gtk_entry_new (); gtk_entry_set_text (GTK_ENTRY (entry2), prefs.nick2); gtk_widget_show (entry2); gtk_table_attach (GTK_TABLE (table1), entry2, 1, 2, 1, 2, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); entry_nick3 = entry3 = gtk_entry_new (); gtk_entry_set_text (GTK_ENTRY (entry3), prefs.nick3); gtk_widget_show (entry3); gtk_table_attach (GTK_TABLE (table1), entry3, 1, 2, 2, 3, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); entry_guser = entry4 = gtk_entry_new (); gtk_entry_set_text (GTK_ENTRY (entry4), prefs.username); gtk_widget_show (entry4); gtk_table_attach (GTK_TABLE (table1), entry4, 1, 2, 3, 4, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); entry_greal = entry5 = gtk_entry_new (); gtk_entry_set_text (GTK_ENTRY (entry5), prefs.realname); gtk_widget_show (entry5); gtk_table_attach (GTK_TABLE (table1), entry5, 1, 2, 4, 5, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); vbox2 = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox2); gtk_box_pack_start (GTK_BOX (vbox1), vbox2, TRUE, TRUE, 0); label1 = bold_label (_("Networks")); gtk_box_pack_start (GTK_BOX (vbox2), label1, FALSE, FALSE, 0); table4 = gtk_table_new (2, 2, FALSE); gtk_widget_show (table4); gtk_box_pack_start (GTK_BOX (vbox2), table4, TRUE, TRUE, 0); gtk_container_set_border_width (GTK_CONTAINER (table4), 8); gtk_table_set_row_spacings (GTK_TABLE (table4), 2); gtk_table_set_col_spacings (GTK_TABLE (table4), 3); scrolledwindow3 = gtk_scrolled_window_new (NULL, NULL); gtk_widget_show (scrolledwindow3); gtk_table_attach (GTK_TABLE (table4), scrolledwindow3, 0, 1, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow3), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow3), GTK_SHADOW_IN); store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_BOOLEAN); model = GTK_TREE_MODEL (store); networks_tree = treeview_networks = gtk_tree_view_new_with_model (model); g_object_unref (model); gtk_widget_show (treeview_networks); gtk_container_add (GTK_CONTAINER (scrolledwindow3), treeview_networks); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview_networks), FALSE); renderer = gtk_cell_renderer_text_new (); g_signal_connect (G_OBJECT (renderer), "edited", G_CALLBACK (servlist_celledit_cb), model); gtk_tree_view_insert_column_with_attributes ( GTK_TREE_VIEW (treeview_networks), -1, 0, renderer, "text", 0, "editable", 1, NULL); checkbutton_skip = gtk_check_button_new_with_mnemonic (_("Skip network list on startup")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (checkbutton_skip), prefs.skip_serverlist); g_signal_connect (G_OBJECT (checkbutton_skip), "toggled", G_CALLBACK (no_servlist), 0); gtk_widget_show (checkbutton_skip); gtk_table_attach (GTK_TABLE (table4), checkbutton_skip, 0, 2, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); vbuttonbox2 = gtk_vbutton_box_new (); gtk_box_set_spacing (GTK_BOX (vbuttonbox2), 3); gtk_button_box_set_layout (GTK_BUTTON_BOX (vbuttonbox2), GTK_BUTTONBOX_START); gtk_widget_show (vbuttonbox2); gtk_table_attach (GTK_TABLE (table4), vbuttonbox2, 1, 2, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); button_add = gtk_button_new_from_stock ("gtk-add"); g_signal_connect (G_OBJECT (button_add), "clicked", G_CALLBACK (servlist_addnet_cb), networks_tree); gtk_widget_show (button_add); gtk_container_add (GTK_CONTAINER (vbuttonbox2), button_add); GTK_WIDGET_SET_FLAGS (button_add, GTK_CAN_DEFAULT); button_remove = gtk_button_new_from_stock ("gtk-remove"); g_signal_connect (G_OBJECT (button_remove), "clicked", G_CALLBACK (servlist_deletenet_cb), 0); gtk_widget_show (button_remove); gtk_container_add (GTK_CONTAINER (vbuttonbox2), button_remove); GTK_WIDGET_SET_FLAGS (button_remove, GTK_CAN_DEFAULT); button_edit = gtk_button_new_with_mnemonic (_("_Edit...")); g_signal_connect (G_OBJECT (button_edit), "clicked", G_CALLBACK (servlist_edit_cb), 0); gtk_widget_show (button_edit); gtk_container_add (GTK_CONTAINER (vbuttonbox2), button_edit); GTK_WIDGET_SET_FLAGS (button_edit, GTK_CAN_DEFAULT); button_sort = gtk_button_new_with_mnemonic (_("_Sort")); add_tip (button_sort, _("Sorts the network list in alphabetical order. " "Use SHIFT-UP and SHIFT-DOWN keys to move a row.")); g_signal_connect (G_OBJECT (button_sort), "clicked", G_CALLBACK (servlist_sort), 0); gtk_widget_show (button_sort); gtk_container_add (GTK_CONTAINER (vbuttonbox2), button_sort); GTK_WIDGET_SET_FLAGS (button_sort, GTK_CAN_DEFAULT); button_connect = gtkutil_button (vbuttonbox2, GTK_STOCK_CONNECT, NULL, servlist_connect_cb, NULL, _("C_onnect")); GTK_WIDGET_SET_FLAGS (button_connect, GTK_CAN_DEFAULT); gtk_label_set_mnemonic_widget (GTK_LABEL (label3), entry1); gtk_label_set_mnemonic_widget (GTK_LABEL (label6), entry4); gtk_label_set_mnemonic_widget (GTK_LABEL (label7), entry5); gtk_widget_grab_focus (networks_tree); return servlist; }
static GtkDialog * create_store_view_dialog (ESource * source) { GtkWidget *dialog; GtkWidget *swin; GtkWidget *tree_view; GtkTreeSelection *selection; ScalixStoreModel *model; GtkTreeViewColumn *column; GtkCellRenderer *cell; char *text_uri; dialog = gtk_dialog_new_with_buttons (_("Select a location"), NULL, GTK_DIALOG_MODAL, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_container_set_border_width (GTK_CONTAINER (dialog), 6); /* Scrolled window */ swin = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swin), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_widget_show (swin); /* ScalixStoreModel aka TreeModel */ text_uri = e_source_get_uri (source); model = scalix_store_model_new (text_uri); /* Treeview */ tree_view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (model)); g_object_set_data (G_OBJECT (dialog), "treeview", tree_view); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (tree_view), FALSE); gtk_widget_show (tree_view); gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (swin), tree_view); gtk_widget_add_events (tree_view, GDK_BUTTON_PRESS); column = gtk_tree_view_column_new (); /* the icon */ cell = gtk_cell_renderer_pixbuf_new (); gtk_tree_view_column_pack_start (column, cell, FALSE); gtk_tree_view_column_set_attributes (column, cell, "pixbuf", SCM_COL_ICON, NULL); /* the text */ cell = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, cell, FALSE); gtk_tree_view_column_set_attributes (column, cell, "text", SCM_COL_NAME, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), column); /* Selection mode of the treeview */ selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)); gtk_tree_selection_set_mode (selection, GTK_SELECTION_BROWSE); g_signal_connect (G_OBJECT (selection), "changed", G_CALLBACK (selection_changed), source); g_signal_connect (G_OBJECT (model), "loaded", G_CALLBACK (model_loaded), tree_view); /* Put everthing together */ gtk_container_add (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox), swin); gtk_container_set_border_width (GTK_CONTAINER (swin), 6); gtk_box_set_spacing (GTK_BOX (GTK_DIALOG (dialog)->vbox), 6); gtk_window_set_default_size (GTK_WINDOW (dialog), 420, 340); return GTK_DIALOG (dialog); }
static GtkWidget * servlist_open_edit (GtkWidget *parent, ircnet *net) { GtkWidget *editwindow; GtkWidget *vbox5; GtkWidget *table3; GtkWidget *label17; GtkWidget *label16; GtkWidget *label21; GtkWidget *label22; GtkWidget *label34; GtkWidget *comboboxentry_charset; GtkWidget *hbox1; GtkWidget *scrolledwindow2; GtkWidget *treeview_servers; GtkWidget *vbuttonbox1; GtkWidget *buttonadd; GtkWidget *buttonremove; GtkWidget *buttonedit; GtkWidget *check; GtkTreeModel *model; GtkListStore *store; GtkCellRenderer *renderer; char buf[128]; char buf2[128 + 8]; char tbuf[256]; snprintf (tbuf, sizeof tbuf, _("conspire: Network Editor (%s)"), net->name); editwindow = mg_create_generic_tab(_("Network Editor"), tbuf, FALSE, TRUE, servlist_closegui, NULL, 550, 200, &vbox5, NULL); table3 = gtk_table_new (17, 3, FALSE); gtk_widget_show (table3); gtk_box_pack_start (GTK_BOX (vbox5), table3, TRUE, TRUE, 0); gtk_table_set_row_spacings (GTK_TABLE (table3), 2); gtk_table_set_col_spacings (GTK_TABLE (table3), 8); snprintf (buf, sizeof (buf), _("Servers for %s"), net->name); snprintf (buf2, sizeof (buf2), "<b>%s</b>", buf); label16 = gtk_label_new (buf2); gtk_widget_show (label16); gtk_table_attach (GTK_TABLE (table3), label16, 0, 3, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 3); gtk_label_set_use_markup (GTK_LABEL (label16), TRUE); gtk_misc_set_alignment (GTK_MISC (label16), 0, 0.5); check = servlist_create_check (0, !(net->flags & FLAG_CYCLE), table3, 2, 1, _("Connect to selected server only")); add_tip (check, _("Don't cycle through all the servers when the connection fails.")); label17 = bold_label (_("Your Details")); gtk_table_attach (GTK_TABLE (table3), label17, 0, 3, 3, 4, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 3); servlist_create_check (1, net->flags & FLAG_USE_GLOBAL, table3, 4, 1, _("Use global user information")); edit_entry_nick = servlist_create_entry (table3, _("_Nick name:"), 5, net->nick, &edit_label_nick, 0); edit_entry_nick2 = servlist_create_entry (table3, _("Second choice:"), 6, net->nick2, &edit_label_nick2, 0); edit_entry_user = servlist_create_entry (table3, _("_User name:"), 7, net->user, &edit_label_user, 0); edit_entry_real = servlist_create_entry (table3, _("Rea_l name:"), 8, net->real, &edit_label_real, 0); label21 = bold_label (_("Connecting")); gtk_table_attach (GTK_TABLE (table3), label21, 0, 3, 9, 10, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 3); servlist_create_check (3, net->flags & FLAG_AUTO_CONNECT, table3, 11, 1, _("Auto connect to this network at startup")); servlist_create_check (4, net->flags & FLAG_USE_PROXY, table3, 12, 1, _("Use a proxy server")); edit_entry_join = servlist_create_entry (table3, _("C_hannels to join:"), 15, net->autojoin, 0, _("Channels to join, separated by commas, but not spaces!")); edit_entry_nickserv = servlist_create_entry (table3, _("Nickserv password:"******"If your nickname requires a password, enter it here. Not all IRC networks support this.")); gtk_entry_set_visibility (GTK_ENTRY (edit_entry_nickserv), FALSE); edit_entry_pass = servlist_create_entry (table3, _("Server password:"******"Password for the server, if in doubt, leave blank.")); gtk_entry_set_visibility (GTK_ENTRY (edit_entry_pass), FALSE); edit_entry_sasl_user = servlist_create_entry (table3, _("SASL username:"******"If your network uses SASL, put your username here.")); edit_entry_sasl_pass = servlist_create_entry (table3, _("SASL password:"******"If your network uses SASL, put your password here.")); gtk_entry_set_visibility (GTK_ENTRY (edit_entry_sasl_pass), FALSE); label34 = gtk_label_new (_("Character set:")); gtk_widget_show (label34); gtk_table_attach (GTK_TABLE (table3), label34, 1, 2, 21, 22, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label34), 0, 0.5); comboboxentry_charset = servlist_create_charsetcombo (); ignore_changed = TRUE; gtk_entry_set_text (GTK_ENTRY (GTK_BIN (comboboxentry_charset)->child), net->encoding ? net->encoding : "System default"); ignore_changed = FALSE; gtk_widget_show (comboboxentry_charset); gtk_table_attach (GTK_TABLE (table3), comboboxentry_charset, 2, 3, 21, 22, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); label22 = bold_label (_("Perform")); gtk_table_attach (GTK_TABLE (table3), label22, 0, 3, 22, 23, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 3); edit_entry_cmd = servlist_create_textview (table3, _("Connect commands:"), 24, net->command, 0, _("Extra commands to execute after connecting. Alternatively, to run a large series of commands on connect, use LOAD -e <filename>, where <filename> is a text-file full of commands to execute.")); /*********** FINITO *************/ hbox1 = gtk_hbox_new (FALSE, 0); gtk_widget_show (hbox1); gtk_table_attach (GTK_TABLE (table3), hbox1, 1, 3, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); scrolledwindow2 = gtk_scrolled_window_new (NULL, NULL); gtk_widget_show (scrolledwindow2); gtk_box_pack_start (GTK_BOX (hbox1), scrolledwindow2, TRUE, TRUE, 0); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow2), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow2), GTK_SHADOW_IN); store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_BOOLEAN); model = GTK_TREE_MODEL (store); edit_tree = treeview_servers = gtk_tree_view_new_with_model (model); g_object_unref (model); gtk_widget_show (treeview_servers); gtk_container_add (GTK_CONTAINER (scrolledwindow2), treeview_servers); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview_servers), FALSE); renderer = gtk_cell_renderer_text_new (); g_signal_connect (G_OBJECT (renderer), "edited", G_CALLBACK (servlist_editserver_cb), model); gtk_tree_view_insert_column_with_attributes ( GTK_TREE_VIEW (treeview_servers), -1, 0, renderer, "text", 0, "editable", 1, NULL); vbuttonbox1 = gtk_vbutton_box_new (); gtk_box_set_spacing (GTK_BOX (vbuttonbox1), 3); gtk_button_box_set_layout (GTK_BUTTON_BOX (vbuttonbox1), GTK_BUTTONBOX_START); gtk_widget_show (vbuttonbox1); gtk_box_pack_start (GTK_BOX (hbox1), vbuttonbox1, FALSE, FALSE, 3); buttonadd = gtk_button_new_from_stock ("gtk-add"); g_signal_connect (G_OBJECT (buttonadd), "clicked", G_CALLBACK (servlist_addserver_cb), edit_tree); gtk_widget_show (buttonadd); gtk_container_add (GTK_CONTAINER (vbuttonbox1), buttonadd); GTK_WIDGET_SET_FLAGS (buttonadd, GTK_CAN_DEFAULT); buttonremove = gtk_button_new_from_stock ("gtk-remove"); g_signal_connect (G_OBJECT (buttonremove), "clicked", G_CALLBACK (servlist_deleteserver_cb), NULL); gtk_widget_show (buttonremove); gtk_container_add (GTK_CONTAINER (vbuttonbox1), buttonremove); GTK_WIDGET_SET_FLAGS (buttonremove, GTK_CAN_DEFAULT); buttonedit = gtk_button_new_with_mnemonic (_("_Edit")); g_signal_connect (G_OBJECT (buttonedit), "clicked", G_CALLBACK (servlist_editserverbutton_cb), NULL); gtk_widget_show (buttonedit); gtk_container_add (GTK_CONTAINER (vbuttonbox1), buttonedit); GTK_WIDGET_SET_FLAGS (buttonedit, GTK_CAN_DEFAULT); if (net->flags & FLAG_USE_GLOBAL) { gtk_widget_hide (edit_label_nick); gtk_widget_hide (edit_entry_nick); gtk_widget_hide (edit_label_nick2); gtk_widget_hide (edit_entry_nick2); gtk_widget_hide (edit_label_user); gtk_widget_hide (edit_entry_user); gtk_widget_hide (edit_label_real); gtk_widget_hide (edit_entry_real); } return editwindow; }
/***************************************************************************** * Run: Gtk+ thread ***************************************************************************** * this part of the interface is in a separate thread so that we can call * gtk_main() from within it without annoying the rest of the program. *****************************************************************************/ static void Run( intf_thread_t *p_intf ) { #ifndef NEED_GTK2_MAIN /* gtk_init needs to know the command line. We don't care, so we * give it an empty one */ char *p_args[] = { "", NULL }; char **pp_args = p_args; int i_args = 1; int i_dummy; #endif playlist_t *p_playlist; GtkCellRenderer *p_renderer = NULL; GtkTreeViewColumn *p_column = NULL; GtkListStore *p_filelist = NULL; GtkListStore *p_playlist_store = NULL; #ifndef NEED_GTK2_MAIN gtk_set_locale (); msg_Dbg( p_intf, "Starting pda GTK2+ interface" ); gtk_init( &i_args, &pp_args ); #else /* Initialize Gtk+ */ msg_Dbg( p_intf, "Starting pda GTK2+ interface thread" ); gdk_threads_enter(); #endif /* Create some useful widgets that will certainly be used */ /* FIXME: magic path */ add_pixmap_directory("share"); add_pixmap_directory("/usr/share/vlc"); /* Path for pixmaps under linupy 1.4 */ add_pixmap_directory("/usr/local/share/pixmaps/vlc"); /* Path for pixmaps under linupy 2.0 */ add_pixmap_directory("/usr/share/pixmaps/vlc"); p_intf->p_sys->p_window = create_pda(); if (p_intf->p_sys->p_window == NULL) { msg_Err( p_intf, "unable to create pda interface" ); } /* Store p_intf to keep an eye on it */ gtk_object_set_data( GTK_OBJECT(p_intf->p_sys->p_window), "p_intf", p_intf ); /* Set the title of the main window */ gtk_window_set_title( GTK_WINDOW(p_intf->p_sys->p_window), VOUT_TITLE " (PDA Linux interface)"); /* Get the notebook object */ p_intf->p_sys->p_notebook = GTK_NOTEBOOK( gtk_object_get_data( GTK_OBJECT( p_intf->p_sys->p_window ), "notebook" ) ); /* Get the slider object */ p_intf->p_sys->p_slider = (GtkHScale*) lookup_widget( p_intf->p_sys->p_window, "timeSlider" ); p_intf->p_sys->p_slider_label = (GtkLabel*) lookup_widget( p_intf->p_sys->p_window, "timeLabel" ); if (p_intf->p_sys->p_slider == NULL) msg_Err( p_intf, "Time slider widget not found." ); if (p_intf->p_sys->p_slider_label == NULL) msg_Err( p_intf, "Time label widget not found." ); /* Connect the date display to the slider */ p_intf->p_sys->p_adj = gtk_range_get_adjustment( GTK_RANGE(p_intf->p_sys->p_slider) ); if (p_intf->p_sys->p_adj == NULL) msg_Err( p_intf, "Adjustment range not found." ); g_signal_connect( GTK_OBJECT( p_intf->p_sys->p_adj ), "value_changed", G_CALLBACK( E_(GtkDisplayDate) ), p_intf ); p_intf->p_sys->f_adj_oldvalue = 0; p_intf->p_sys->i_adj_oldvalue = 0; /* BEGIN OF FILEVIEW GTK_TREE_VIEW */ p_intf->p_sys->p_tvfile = NULL; p_intf->p_sys->p_tvfile = (GtkTreeView *) lookup_widget( p_intf->p_sys->p_window, "tvFileList"); if (NULL == p_intf->p_sys->p_tvfile) msg_Err(p_intf, "Error obtaining pointer to File List"); /* Insert columns 0 */ p_renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes(p_intf->p_sys->p_tvfile, 0, (gchar *) N_("Filename"), p_renderer, NULL); p_column = gtk_tree_view_get_column(p_intf->p_sys->p_tvfile, 0 ); gtk_tree_view_column_add_attribute(p_column, p_renderer, "text", 0 ); gtk_tree_view_column_set_sort_column_id(p_column, 0); /* Insert columns 1 */ p_renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes(p_intf->p_sys->p_tvfile, 1, (gchar *) N_("Permissions"), p_renderer, NULL); p_column = gtk_tree_view_get_column(p_intf->p_sys->p_tvfile, 1 ); gtk_tree_view_column_add_attribute(p_column, p_renderer, "text", 1 ); gtk_tree_view_column_set_sort_column_id(p_column, 1); /* Insert columns 2 */ p_renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes(p_intf->p_sys->p_tvfile, 2, (gchar *) N_("Size"), p_renderer, NULL); p_column = gtk_tree_view_get_column(p_intf->p_sys->p_tvfile, 2 ); gtk_tree_view_column_add_attribute(p_column, p_renderer, "text", 2 ); gtk_tree_view_column_set_sort_column_id(p_column, 2); /* Insert columns 3 */ p_renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes(p_intf->p_sys->p_tvfile, 3, (gchar *) N_("Owner"), p_renderer, NULL); p_column = gtk_tree_view_get_column(p_intf->p_sys->p_tvfile, 3 ); gtk_tree_view_column_add_attribute(p_column, p_renderer, "text", 3 ); gtk_tree_view_column_set_sort_column_id(p_column, 3); /* Insert columns 4 */ p_renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes(p_intf->p_sys->p_tvfile, 4, (gchar *) N_("Group"), p_renderer, NULL); p_column = gtk_tree_view_get_column(p_intf->p_sys->p_tvfile, 4 ); gtk_tree_view_column_add_attribute(p_column, p_renderer, "text", 4 ); gtk_tree_view_column_set_sort_column_id(p_column, 4); /* Get new directory listing */ p_filelist = gtk_list_store_new (5, G_TYPE_STRING, /* Filename */ G_TYPE_STRING, /* permissions */ G_TYPE_UINT64, /* File size */ G_TYPE_STRING, /* Owner */ G_TYPE_STRING);/* Group */ ReadDirectory(p_intf, p_filelist, "."); gtk_tree_view_set_model(GTK_TREE_VIEW(p_intf->p_sys->p_tvfile), GTK_TREE_MODEL(p_filelist)); g_object_unref(p_filelist); /* Model will be released by GtkTreeView */ gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(p_intf->p_sys->p_tvfile)),GTK_SELECTION_MULTIPLE); /* Column properties */ gtk_tree_view_set_headers_visible(p_intf->p_sys->p_tvfile, TRUE); gtk_tree_view_columns_autosize(p_intf->p_sys->p_tvfile); gtk_tree_view_set_headers_clickable(GTK_TREE_VIEW(p_intf->p_sys->p_tvfile),TRUE); /* END OF FILEVIEW GTK_TREE_VIEW */ /* BEGIN OF PLAYLIST GTK_TREE_VIEW */ p_intf->p_sys->p_tvplaylist = NULL; p_intf->p_sys->p_tvplaylist = (GtkTreeView *) lookup_widget( p_intf->p_sys->p_window, "tvPlaylist"); if (NULL == p_intf->p_sys->p_tvplaylist) msg_Err(p_intf, "Error obtaining pointer to Play List"); /* Columns 1 */ p_renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes(p_intf->p_sys->p_tvplaylist, 0, (gchar *) N_("Filename"), p_renderer, NULL); p_column = gtk_tree_view_get_column(p_intf->p_sys->p_tvplaylist, 0 ); gtk_tree_view_column_add_attribute(p_column, p_renderer, "text", 0 ); gtk_tree_view_column_set_sort_column_id(p_column, 0); /* Column 2 */ p_renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes(p_intf->p_sys->p_tvplaylist, 1, (gchar *) N_("Time"), p_renderer, NULL); p_column = gtk_tree_view_get_column(p_intf->p_sys->p_tvplaylist, 1 ); gtk_tree_view_column_add_attribute(p_column, p_renderer, "text", 1 ); gtk_tree_view_column_set_sort_column_id(p_column, 1); #if 0 /* Column 3 - is a hidden column used for reliable deleting items from the underlying playlist */ p_renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes(p_intf->p_sys->p_tvplaylist, 2, (gchar *) N_("Index"), p_renderer, NULL); p_column = gtk_tree_view_get_column(p_intf->p_sys->p_tvplaylist, 2 ); gtk_tree_view_column_add_attribute(p_column, p_renderer, "text", 2 ); gtk_tree_view_column_set_sort_column_id(p_column, 2); #endif /* update the playlist */ p_playlist = vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST, FIND_ANYWHERE ); p_playlist_store = gtk_list_store_new (3, G_TYPE_STRING, /* Filename */ G_TYPE_STRING, /* Time */ G_TYPE_UINT); /* Hidden index */ PlaylistRebuildListStore(p_playlist_store, p_playlist); gtk_tree_view_set_model(GTK_TREE_VIEW(p_intf->p_sys->p_tvplaylist), GTK_TREE_MODEL(p_playlist_store)); g_object_unref(p_playlist_store); vlc_object_release(p_playlist); /* Free the playlist */ gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(p_intf->p_sys->p_tvplaylist)),GTK_SELECTION_MULTIPLE); /* Column properties */ gtk_tree_view_set_headers_visible(p_intf->p_sys->p_tvplaylist, TRUE); gtk_tree_view_columns_autosize(p_intf->p_sys->p_tvplaylist); gtk_tree_view_set_headers_clickable(p_intf->p_sys->p_tvplaylist, TRUE); /* END OF PLAYLIST GTK_TREE_VIEW */ /* Hide the Preference TAB for now. */ GtkWidget *p_preference_tab = NULL; p_preference_tab = gtk_notebook_get_nth_page(p_intf->p_sys->p_notebook,5); if (p_preference_tab != NULL) gtk_widget_hide(p_preference_tab); /* Show the control window */ gtk_widget_show( p_intf->p_sys->p_window ); #ifdef NEED_GTK2_MAIN msg_Dbg( p_intf, "Manage GTK keyboard events using threads" ); while( !p_intf->b_die ) { Manage( p_intf ); /* Sleep to avoid using all CPU - since some interfaces need to * access keyboard events, a 100ms delay is a good compromise */ gdk_threads_leave(); if (p_intf->p_libvlc->i_cpu & CPU_CAPABILITY_FPU) msleep( INTF_IDLE_SLEEP ); else msleep( 1000 ); gdk_threads_enter(); } #else msg_Dbg( p_intf, "Manage GTK keyboard events using timeouts" ); /* Sleep to avoid using all CPU - since some interfaces needs to access * keyboard events, a 1000ms delay is a good compromise */ if (p_intf->p_libvlc->i_cpu & CPU_CAPABILITY_FPU) i_dummy = gtk_timeout_add( INTF_IDLE_SLEEP / 1000, (GtkFunction)Manage, p_intf ); else i_dummy = gtk_timeout_add( 1000, (GtkFunction)Manage, p_intf ); /* Enter Gtk mode */ gtk_main(); /* Remove the timeout */ gtk_timeout_remove( i_dummy ); #endif gtk_object_destroy( GTK_OBJECT(p_intf->p_sys->p_window) ); #ifdef NEED_GTK2_MAIN gdk_threads_leave(); #endif }
int main(int argc, char *argv[]) { GtkWidget *main_window, *scroll; GtkWidget *treeview; GtkTreeViewColumn *column; GtkCellRenderer *name_renderer, *size_renderer; GtkTreeStore *store; GtkTreeIter categories[14]; GValue value = { 0, }; gint offset; uint32 res_counts[14]; uint32 res_sizes[14]; int i; Common::File in; uint32 index_pos; uint32 pos, len; gtk_init(&argc, &argv); if (argc != 2) { printf("Usage: %s filename\n", argv[0]); return EXIT_FAILURE; } in.open(argv[1], "rb"); if (!in.isOpen()) { printf("Couldn't open %s for reading\n", argv[1]); return EXIT_FAILURE; } /* Create the main window, scrollable in both directions */ main_window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(main_window), "CLUster Explorer"); gtk_window_set_default_size(GTK_WINDOW(main_window), 400, 400); g_signal_connect(G_OBJECT(main_window), "destroy", G_CALLBACK(main_window_destroy_cb), NULL); scroll = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scroll), GTK_SHADOW_ETCHED_IN); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); /* Create the tree view */ for (i = 0; i < ARRAYSIZE(res_counts); i++) { res_counts[i] = 0; res_sizes[i] = 0; } store = gtk_tree_store_new(N_COLUMNS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT, G_TYPE_INT, G_TYPE_INT); gtk_tree_sortable_set_default_sort_func(GTK_TREE_SORTABLE(store), compare_items, NULL, NULL); gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(store), GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, GTK_SORT_ASCENDING); index_pos = in.readUint32LE(); in.seek(index_pos, SEEK_SET); for (;;) { GtkTreeIter iter; byte type; gchar *utf8_name; gchar name[34]; gchar *size; try { pos = in.readUint32LE(); len = in.readUint32LE(); } catch (...) { break; } size = make_size(len); index_pos = in.pos(); in.seek(pos, SEEK_SET); type = in.readByte(); in.readByte(); /* compType */ in.readUint32LE(); /* compSize */ in.readUint32LE(); /* decompSize */ in.read_noThrow(name, sizeof(name)); /* * We need to convert from Latin-1 to UTF-8. Otherwise the text * "CAFÉ" won't be displayed properly. */ utf8_name = g_convert(name, -1, "UTF-8", "ISO-8859-1", NULL, NULL, NULL); if (!res_counts[type]) { gtk_tree_store_append(store, &categories[type], NULL); gtk_tree_store_set(store, &categories[type], NAME_COLUMN, getType(type), SIZE_COLUMN, "", TYPE_COLUMN, -1, POSITION_COLUMN, -1, LENGTH_COLUMN, -1, -1); } res_counts[type]++; res_sizes[type] += len; gtk_tree_store_append(store, &iter, &categories[type]); gtk_tree_store_set(store, &iter, NAME_COLUMN, utf8_name, SIZE_COLUMN, size, TYPE_COLUMN, type, POSITION_COLUMN, pos, LENGTH_COLUMN, len); in.seek(index_pos, SEEK_SET); } in.close(); for (i = 0; i < ARRAYSIZE(res_counts); i++) { if (res_counts[i]) { gchar size[80]; sprintf(size, "%s [%d]", make_size(res_sizes[i]), res_counts[i]); gtk_tree_store_set(store, &categories[i], SIZE_COLUMN, size, -1); } } treeview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store)); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeview), TRUE); g_signal_connect(G_OBJECT(treeview), "button-press-event", G_CALLBACK(tree_view_button_cb), argv[1]); /* The view now holds a reference. We can get rid of our own. */ g_object_unref(G_OBJECT(store)); name_renderer = gtk_cell_renderer_text_new(); size_renderer = gtk_cell_renderer_text_new(); g_value_init(&value, G_TYPE_FLOAT); g_value_set_float(&value, 1.0); g_object_set_property(G_OBJECT(size_renderer), "xalign", &value); gtk_tree_view_insert_column_with_attributes( GTK_TREE_VIEW(treeview), -1, "Name", name_renderer, "text", NAME_COLUMN, NULL); offset = gtk_tree_view_insert_column_with_attributes( GTK_TREE_VIEW(treeview), -1, "Size", size_renderer, "text", SIZE_COLUMN, NULL); column = gtk_tree_view_get_column(GTK_TREE_VIEW(treeview), offset - 1); gtk_tree_view_column_set_alignment(column, 1.0); gtk_container_add(GTK_CONTAINER(scroll), GTK_WIDGET(treeview)); gtk_container_add(GTK_CONTAINER(main_window), scroll); gtk_widget_show_all(GTK_WIDGET(main_window)); gtk_main(); return EXIT_SUCCESS; }
void xa_create_open_with_dialog(gchar *filename,gchar *filenames,int nr) { Open_with_data *data = NULL; GtkWidget *dialog_vbox1,*vbox1,*hbox1,*mime_icon,*open_text,*scrolledwindow1,*apps_treeview,*dialog_action_area1, *custom_command_expander,*hbox_expander,*browse,*cancelbutton1,*okbutton1; GtkCellRenderer *renderer; GtkTreeViewColumn *column; GtkTreeIter iter; GdkPixbuf *pixbuf; gchar *text = NULL; gchar *title; const gchar *icon_name = NULL; const gchar* const *desktop_dirs; gint x = 0; data = g_new0(Open_with_data,1); data->file_list = filenames; data->dialog1 = gtk_dialog_new (); if (nr == 1) title = _("Open With"); else title = _("Open the selected files with"); gtk_window_set_title (GTK_WINDOW (data->dialog1),title); gtk_window_set_position (GTK_WINDOW (data->dialog1), GTK_WIN_POS_CENTER_ON_PARENT); gtk_window_set_modal (GTK_WINDOW (data->dialog1), TRUE); gtk_window_set_type_hint (GTK_WINDOW (data->dialog1), GDK_WINDOW_TYPE_HINT_DIALOG); gtk_window_set_transient_for(GTK_WINDOW(data->dialog1),GTK_WINDOW(xa_main_window)); gtk_dialog_set_has_separator (GTK_DIALOG (data->dialog1),FALSE); gtk_container_set_border_width (GTK_CONTAINER (data->dialog1),5); gtk_widget_set_size_request(data->dialog1,380,380); dialog_vbox1 = GTK_DIALOG (data->dialog1)->vbox; vbox1 = gtk_vbox_new (FALSE, 5); gtk_box_pack_start (GTK_BOX (dialog_vbox1),vbox1,TRUE,TRUE,0); hbox1 = gtk_hbox_new (FALSE, 1); gtk_box_pack_start (GTK_BOX (vbox1),hbox1,FALSE,FALSE,0); if (nr == 1) { icon_name = xa_get_stock_mime_icon(filename); pixbuf = gtk_icon_theme_load_icon(icon_theme,icon_name,40,0,NULL); mime_icon = gtk_image_new_from_pixbuf(pixbuf); if (pixbuf) g_object_unref(pixbuf); gtk_box_pack_start (GTK_BOX (hbox1),mime_icon,FALSE,TRUE,0); gtk_misc_set_alignment (GTK_MISC (mime_icon),0,0); open_text = gtk_label_new(""); gtk_box_pack_start (GTK_BOX (hbox1),open_text,FALSE,FALSE,10); text = g_strdup_printf(_("Open <i>%s</i> with:"),filename); gtk_label_set_use_markup (GTK_LABEL (open_text),TRUE); gtk_label_set_markup (GTK_LABEL (open_text),text); g_free(text); } scrolledwindow1 = gtk_scrolled_window_new (NULL,NULL); gtk_box_pack_start (GTK_BOX (vbox1),scrolledwindow1,TRUE,TRUE,0); g_object_set (G_OBJECT (scrolledwindow1),"hscrollbar-policy",GTK_POLICY_AUTOMATIC,"shadow-type",GTK_SHADOW_IN,"vscrollbar-policy",GTK_POLICY_AUTOMATIC,NULL); data->apps_liststore = gtk_list_store_new (3,GDK_TYPE_PIXBUF,G_TYPE_STRING,G_TYPE_STRING); apps_treeview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(data->apps_liststore)); gtk_container_add (GTK_CONTAINER (scrolledwindow1),apps_treeview); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(apps_treeview),FALSE); GtkTreeSelection *sel = gtk_tree_view_get_selection( GTK_TREE_VIEW (apps_treeview)); g_signal_connect ((gpointer) sel,"changed",G_CALLBACK (xa_open_with_dialog_selection_changed),data); /* First column: icon + text */ column = gtk_tree_view_column_new(); renderer = gtk_cell_renderer_pixbuf_new(); gtk_tree_view_column_pack_start(column,renderer, FALSE); gtk_tree_view_column_set_attributes(column,renderer,"pixbuf",0,NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start(column,renderer, TRUE); gtk_tree_view_column_set_attributes( column,renderer,"text",1,NULL); gtk_tree_view_column_set_resizable (column, TRUE); gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(data->apps_liststore),1,GTK_SORT_ASCENDING); gtk_tree_view_append_column (GTK_TREE_VIEW (apps_treeview), column); gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_AUTOSIZE); /* Hidden column with the application executable name */ column = gtk_tree_view_column_new(); gtk_tree_view_column_set_visible(column,FALSE); gtk_tree_view_append_column (GTK_TREE_VIEW (apps_treeview), column); custom_command_expander = gtk_expander_new_with_mnemonic(_("Use a custom command:")); gtk_box_pack_start (GTK_BOX (vbox1),custom_command_expander,FALSE,FALSE,0); hbox_expander = gtk_hbox_new(FALSE,5); data->custom_command_entry = gtk_entry_new(); g_signal_connect (G_OBJECT (data->custom_command_entry),"activate",G_CALLBACK (xa_open_with_dialog_custom_entry_activated),data); browse = gtk_button_new_with_label(_("Browse")); g_signal_connect (G_OBJECT (browse),"clicked",G_CALLBACK (xa_open_with_dialog_browse_custom_command),data); gtk_box_pack_start (GTK_BOX (hbox_expander),data->custom_command_entry,TRUE,TRUE,0); gtk_box_pack_start (GTK_BOX (hbox_expander),browse,FALSE,TRUE,0); gtk_container_add(GTK_CONTAINER(custom_command_expander),hbox_expander); dialog_action_area1 = GTK_DIALOG (data->dialog1)->action_area; gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area1),GTK_BUTTONBOX_END); cancelbutton1 = gtk_button_new_from_stock ("gtk-cancel"); gtk_widget_show (cancelbutton1); gtk_dialog_add_action_widget (GTK_DIALOG (data->dialog1),cancelbutton1,GTK_RESPONSE_CANCEL); GTK_WIDGET_SET_FLAGS (cancelbutton1, GTK_CAN_DEFAULT); g_signal_connect_swapped (G_OBJECT (cancelbutton1),"clicked",G_CALLBACK (gtk_widget_destroy),G_OBJECT(data->dialog1)); okbutton1 = gtk_button_new_from_stock ("gtk-open"); gtk_widget_show (okbutton1); gtk_dialog_add_action_widget (GTK_DIALOG (data->dialog1),okbutton1,GTK_RESPONSE_OK); g_signal_connect (G_OBJECT (okbutton1),"clicked",G_CALLBACK (xa_open_with_dialog_execute_command),data); GTK_WIDGET_SET_FLAGS (okbutton1, GTK_CAN_DEFAULT); gtk_widget_show_all(data->dialog1); /* Let's parse the desktop files in all the system data dirs */ desktop_dirs = g_get_system_data_dirs(); while (desktop_dirs[x]) { xa_read_desktop_directories(data->apps_liststore,desktop_dirs[x]); x++; } gtk_tree_model_get_iter_first(GTK_TREE_MODEL(data->apps_liststore),&iter); gtk_tree_selection_select_iter(gtk_tree_view_get_selection (GTK_TREE_VIEW (apps_treeview)),&iter); g_signal_connect (G_OBJECT (apps_treeview), "row-activated",G_CALLBACK(xa_open_with_dialog_row_selected),data); g_signal_connect (G_OBJECT (data->dialog1), "destroy", G_CALLBACK(xa_destroy_open_with_dialog),data); }
extern "C" int addToGui(gpointer data) { plugData* plugdata=(plugData*)data; GtkTreeViewColumn* column; GtkTreeModel* model=NULL; GtkCellRenderer* renderer; GtkTreeIter iter; GtkWidget* menu; setTextDomain(true,plugdata); menu=gtk_menu_item_get_submenu((GtkMenuItem*)plugdata->mlist.menuView); hideMenu=gtk_menu_item_new_with_label(gettext("Hide Browser")); g_signal_connect(G_OBJECT(hideMenu),"activate",G_CALLBACK(toggleBrowser),plugdata); gtk_menu_shell_append(GTK_MENU_SHELL(menu),hideMenu); gtk_widget_show_all(plugdata->mlist.menuView); store=gtk_tree_store_new(NUM_COLUMNS,GDK_TYPE_PIXBUF,G_TYPE_STRING,G_TYPE_STRING); addFolderContents("/",&iter,true); model=GTK_TREE_MODEL(store); treeview=gtk_tree_view_new_with_model(model); gtk_tree_view_set_enable_tree_lines((GtkTreeView*)treeview,true); scrollbox=gtk_scrolled_window_new(NULL,NULL); gtk_scrolled_window_set_policy((GtkScrolledWindow*)scrollbox,GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC); gtk_container_add(GTK_CONTAINER(scrollbox),(GtkWidget*)treeview); gtk_box_pack_start((GtkBox*)plugdata->leftUserBox,scrollbox,true,true,0); gtk_widget_show_all(plugdata->leftUserBox); gtk_widget_set_size_request((GtkWidget*)scrollbox,100,-1); //pixbuf renderer=gtk_cell_renderer_pixbuf_new(); column=gtk_tree_view_column_new_with_attributes("path",renderer,"pixbuf",COLUMN_PIXBUF,NULL); gtk_tree_view_column_set_resizable(column,false); gtk_tree_view_column_set_sizing(column,GTK_TREE_VIEW_COLUMN_AUTOSIZE); gtk_tree_view_append_column((GtkTreeView*)treeview,column); gtk_tree_view_column_set_spacing(column,0); gtk_tree_view_column_set_expand(column,false); //colom file renderer=gtk_cell_renderer_text_new(); column=gtk_tree_view_column_new_with_attributes(NULL,renderer,"text",COLUMN_FILENAME,NULL); gtk_tree_view_column_set_resizable(column,true); gtk_tree_view_column_set_sizing(column,GTK_TREE_VIEW_COLUMN_AUTOSIZE); gtk_tree_view_append_column((GtkTreeView*)treeview,column); gtk_tree_view_column_set_expand(column,true); gtk_tree_view_column_set_spacing(column,0); gtk_tree_view_set_headers_visible((GtkTreeView*)treeview,false); g_signal_connect(treeview,"row-expanded",G_CALLBACK(expandRow),column); g_signal_connect(treeview,"row-collapsed",G_CALLBACK(collapseRow),column); g_signal_connect(treeview,"row-activated",G_CALLBACK(onRowActivated),NULL); leftBox=(GtkWidget*)plugdata->leftUserBox; doStartUpCheck(plugdata); showHideBrowser(plugdata,true); if(showing==true) showSide(true); else hideSide(true); setTextDomain(false,plugdata); return(0); }
static void setup_search (GnomeControlCenter *shell) { GtkWidget *search_view, *widget; GtkCellRenderer *renderer; GtkTreeViewColumn *column; GnomeControlCenterPrivate *priv = shell->priv; g_return_if_fail (priv->store != NULL); /* create the search filter */ priv->search_filter = gtk_tree_model_filter_new (GTK_TREE_MODEL (priv->store), NULL); gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER (priv->search_filter), (GtkTreeModelFilterVisibleFunc) model_filter_func, priv, NULL); /* set up the search view */ priv->search_view = search_view = gtk_tree_view_new (); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (search_view), FALSE); gtk_tree_view_set_model (GTK_TREE_VIEW (search_view), GTK_TREE_MODEL (priv->search_filter)); renderer = gtk_cell_renderer_pixbuf_new (); g_object_set (renderer, "follow-state", TRUE, "xpad", 15, "ypad", 10, "stock-size", GTK_ICON_SIZE_DIALOG, NULL); column = gtk_tree_view_column_new_with_attributes ("Icon", renderer, "gicon", COL_GICON, NULL); gtk_tree_view_column_set_expand (column, FALSE); gtk_tree_view_append_column (GTK_TREE_VIEW (priv->search_view), column); renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "xpad", 0, NULL); column = gtk_tree_view_column_new_with_attributes ("Name", renderer, "text", COL_NAME, NULL); gtk_tree_view_column_set_expand (column, FALSE); gtk_tree_view_append_column (GTK_TREE_VIEW (priv->search_view), column); renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "xpad", 15, NULL); column = gtk_tree_view_column_new_with_attributes ("Description", renderer, "text", COL_DESCRIPTION, NULL); gtk_tree_view_column_set_expand (column, TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW (priv->search_view), column); priv->search_scrolled = W (priv->builder, "search-scrolled-window"); gtk_container_add (GTK_CONTAINER (priv->search_scrolled), search_view); g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->search_view)), "changed", G_CALLBACK (on_search_selection_changed), shell); /* setup the search entry widget */ widget = (GtkWidget*) gtk_builder_get_object (priv->builder, "search-entry"); priv->search_entry = widget; priv->filter_string = g_strdup (""); g_signal_connect (widget, "changed", G_CALLBACK (search_entry_changed_cb), shell); g_signal_connect (widget, "key-press-event", G_CALLBACK (search_entry_key_press_event_cb), priv); gtk_widget_show (priv->search_view); }
void clist_init(void) { GtkTreeView *view = GTK_TREE_VIEW(clist_wnd); GtkTreeModel *model = GTK_TREE_MODEL(list); GtkCellRenderer *renderer; GtkTreeSelection *selection; gint i; list = gtk_list_store_new(CLIST_NCOLS, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER ); model = GTK_TREE_MODEL(list); gtk_tree_view_set_model(view, model); gtk_tree_view_set_headers_visible(view, TRUE); gtk_tree_view_set_headers_clickable(view, TRUE); gtk_tree_view_set_rules_hint(view, FALSE); renderer = gtk_cell_renderer_pixbuf_new(); gtk_tree_view_insert_column_with_attributes(view, -1, "", renderer, "pixbuf", COLUMN_ICON, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_insert_column_with_attributes(view, -1, _("Name"), renderer, "text", COLUMN_NAME, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_insert_column_with_attributes(view, -1, _("Type"), renderer, "text", COLUMN_TYPE, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_insert_column_with_attributes(view, -1, _("Size"), renderer, "text", COLUMN_SIZE, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_insert_column_with_attributes(view, -1, _("Date"), renderer, "text", COLUMN_DATE, NULL); for (i = 0; i < CLIST_NVCOLS; i++) { GtkTreeViewColumn *col; col = gtk_tree_view_get_column(view, i); gtk_tree_view_column_set_resizable(col, TRUE); gtk_tree_view_column_set_clickable(col, TRUE); g_signal_connect(G_OBJECT(col), "clicked", G_CALLBACK(column_clicked), view); } selection = gtk_tree_view_get_selection(view); gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE); gtk_tree_selection_set_select_function(selection, select_func, NULL, NULL); g_signal_connect(G_OBJECT(selection), "changed", G_CALLBACK(tree_selection_changed), NULL); }
static void thunar_uca_chooser_init (ThunarUcaChooser *uca_chooser) { GtkTreeViewColumn *column; GtkTreeSelection *selection; GtkCellRenderer *renderer; ThunarUcaModel *uca_model; GtkWidget *image; GtkWidget *label; GtkWidget *hbox; GtkWidget *swin; GtkWidget *vbox; /* configure the dialog window */ gtk_dialog_add_button (GTK_DIALOG (uca_chooser), GTK_STOCK_HELP, GTK_RESPONSE_HELP); gtk_dialog_add_button (GTK_DIALOG (uca_chooser), GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE); gtk_dialog_set_default_response (GTK_DIALOG (uca_chooser), GTK_RESPONSE_CLOSE); gtk_dialog_set_has_separator (GTK_DIALOG (uca_chooser), FALSE); gtk_window_set_default_size (GTK_WINDOW (uca_chooser), 500, 350); gtk_window_set_destroy_with_parent (GTK_WINDOW (uca_chooser), TRUE); gtk_window_set_title (GTK_WINDOW (uca_chooser), _("Custom Actions")); hbox = gtk_hbox_new (FALSE, 3); gtk_container_set_border_width (GTK_CONTAINER (hbox), 6); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (uca_chooser)->vbox), hbox, FALSE, TRUE, 0); gtk_widget_show (hbox); image = gtk_image_new_from_stock (GTK_STOCK_DIALOG_INFO, GTK_ICON_SIZE_DND); gtk_box_pack_start (GTK_BOX (hbox), image, FALSE, FALSE, 0); gtk_widget_show (image); label = gtk_label_new (_("You can configure custom actions that will appear in the\n" "file managers context menus for certain kinds of files.")); gtk_misc_set_alignment (GTK_MISC (label), 0.0f, 0.5f); gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, TRUE, 0); gtk_widget_show (label); hbox = gtk_hbox_new (FALSE, 3); gtk_container_set_border_width (GTK_CONTAINER (hbox), 6); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (uca_chooser)->vbox), hbox, TRUE, TRUE, 0); gtk_widget_show (hbox); swin = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swin), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (swin), GTK_SHADOW_IN); gtk_box_pack_start (GTK_BOX (hbox), swin, TRUE, TRUE, 0); gtk_widget_show (swin); uca_chooser->treeview = gtk_tree_view_new (); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (uca_chooser->treeview), FALSE); gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (uca_chooser->treeview), TRUE); gtk_container_add (GTK_CONTAINER (swin), uca_chooser->treeview); g_signal_connect_swapped (G_OBJECT (uca_chooser->treeview), "row-activated", G_CALLBACK (thunar_uca_chooser_edit_clicked), uca_chooser); gtk_widget_show (uca_chooser->treeview); uca_model = thunar_uca_model_get_default (); gtk_tree_view_set_model (GTK_TREE_VIEW (uca_chooser->treeview), GTK_TREE_MODEL (uca_model)); g_object_unref (G_OBJECT (uca_model)); column = gtk_tree_view_column_new (); gtk_tree_view_column_set_expand (column, TRUE); gtk_tree_view_column_set_resizable (column, FALSE); gtk_tree_view_append_column (GTK_TREE_VIEW (uca_chooser->treeview), column); renderer = g_object_new (GTK_TYPE_CELL_RENDERER_PIXBUF, "stock-size", GTK_ICON_SIZE_DND, "xpad", 2, "ypad", 2, NULL); gtk_tree_view_column_pack_start (column, renderer, FALSE); gtk_tree_view_column_set_attributes (column, renderer, "icon-name", THUNAR_UCA_MODEL_COLUMN_ICON, NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, renderer, TRUE); gtk_tree_view_column_set_attributes (column, renderer, "markup", THUNAR_UCA_MODEL_COLUMN_STOCK_LABEL, NULL); vbox = gtk_vbox_new (FALSE, 3); gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0); gtk_widget_show (vbox); uca_chooser->add_button = gtk_button_new (); gtk_widget_set_tooltip_text (uca_chooser->add_button, _("Add a new custom action.")); gtk_box_pack_start (GTK_BOX (vbox), uca_chooser->add_button, FALSE, FALSE, 0); g_signal_connect_swapped (G_OBJECT (uca_chooser->add_button), "clicked", G_CALLBACK (thunar_uca_chooser_add_clicked), uca_chooser); gtk_widget_show (uca_chooser->add_button); image = gtk_image_new_from_stock (GTK_STOCK_ADD, GTK_ICON_SIZE_BUTTON); gtk_container_add (GTK_CONTAINER (uca_chooser->add_button), image); gtk_widget_show (image); uca_chooser->edit_button = gtk_button_new (); gtk_widget_set_tooltip_text (uca_chooser->edit_button, _("Edit the currently selected action.")); gtk_box_pack_start (GTK_BOX (vbox), uca_chooser->edit_button, FALSE, FALSE, 0); g_signal_connect_swapped (G_OBJECT (uca_chooser->edit_button), "clicked", G_CALLBACK (thunar_uca_chooser_edit_clicked), uca_chooser); gtk_widget_show (uca_chooser->edit_button); image = gtk_image_new_from_stock (GTK_STOCK_EDIT, GTK_ICON_SIZE_BUTTON); gtk_container_add (GTK_CONTAINER (uca_chooser->edit_button), image); gtk_widget_show (image); uca_chooser->delete_button = gtk_button_new (); gtk_widget_set_tooltip_text (uca_chooser->delete_button, _("Delete the currently selected action.")); gtk_box_pack_start (GTK_BOX (vbox), uca_chooser->delete_button, FALSE, FALSE, 0); g_signal_connect_swapped (G_OBJECT (uca_chooser->delete_button), "clicked", G_CALLBACK (thunar_uca_chooser_delete_clicked), uca_chooser); gtk_widget_show (uca_chooser->delete_button); image = gtk_image_new_from_stock (GTK_STOCK_DELETE, GTK_ICON_SIZE_BUTTON); gtk_container_add (GTK_CONTAINER (uca_chooser->delete_button), image); gtk_widget_show (image); uca_chooser->up_button = gtk_button_new (); gtk_widget_set_tooltip_text (uca_chooser->up_button, _("Move the currently selected action up by one row.")); gtk_box_pack_start (GTK_BOX (vbox), uca_chooser->up_button, FALSE, FALSE, 0); g_signal_connect_swapped (G_OBJECT (uca_chooser->up_button), "clicked", G_CALLBACK (thunar_uca_chooser_up_clicked), uca_chooser); gtk_widget_show (uca_chooser->up_button); image = gtk_image_new_from_stock (GTK_STOCK_GO_UP, GTK_ICON_SIZE_BUTTON); gtk_container_add (GTK_CONTAINER (uca_chooser->up_button), image); gtk_widget_show (image); uca_chooser->down_button = gtk_button_new (); gtk_widget_set_tooltip_text (uca_chooser->down_button, _("Move the currently selected action down by one row.")); gtk_box_pack_start (GTK_BOX (vbox), uca_chooser->down_button, FALSE, FALSE, 0); g_signal_connect_swapped (G_OBJECT (uca_chooser->down_button), "clicked", G_CALLBACK (thunar_uca_chooser_down_clicked), uca_chooser); gtk_widget_show (uca_chooser->down_button); image = gtk_image_new_from_stock (GTK_STOCK_GO_DOWN, GTK_ICON_SIZE_BUTTON); gtk_container_add (GTK_CONTAINER (uca_chooser->down_button), image); gtk_widget_show (image); /* configure the tree view selection after the buttons have been created */ selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (uca_chooser->treeview)); gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE); g_signal_connect_swapped (G_OBJECT (selection), "changed", G_CALLBACK (thunar_uca_chooser_selection_changed), uca_chooser); thunar_uca_chooser_selection_changed (uca_chooser, selection); }
NewStylesheetDialog::NewStylesheetDialog(const ustring & worksheet, GtkWindow *transient_parent) { myworksheet = worksheet; Shortcuts shortcuts(0); newstylesheetdialog = gtk_dialog_new(); gtk_window_set_transient_for(GTK_WINDOW(newstylesheetdialog), transient_parent); if (!worksheet.empty()) { gtk_window_set_title(GTK_WINDOW(newstylesheetdialog), _("New style")); } else { gtk_window_set_title(GTK_WINDOW(newstylesheetdialog), _("New stylesheet")); } //gtk_window_set_position(GTK_WINDOW(newstylesheetdialog), GTK_WIN_POS_CENTER_ON_PARENT); dialog_vbox1 = gtk_dialog_get_content_area (GTK_DIALOG (newstylesheetdialog)); gtk_widget_show(dialog_vbox1); hbox2 = gtk_hbox_new(FALSE, 4); gtk_widget_show(hbox2); gtk_box_pack_start(GTK_BOX(dialog_vbox1), hbox2, TRUE, TRUE, 0); vbox1 = gtk_vbox_new(FALSE, 4); gtk_widget_show(vbox1); gtk_box_pack_start(GTK_BOX(hbox2), vbox1, TRUE, TRUE, 0); if (myworksheet.empty()) { hbox1 = gtk_hbox_new(FALSE, 4); gtk_widget_show(hbox1); gtk_box_pack_start(GTK_BOX(vbox1), hbox1, TRUE, TRUE, 0); label1 = gtk_label_new(_("Name")); gtk_widget_show(label1); gtk_box_pack_start(GTK_BOX(hbox1), label1, FALSE, FALSE, 0); shortcuts.label(label1); entry1 = gtk_entry_new(); gtk_widget_show(entry1); gtk_box_pack_start(GTK_BOX(hbox1), entry1, TRUE, TRUE, 0); } ustring info; if (!myworksheet.empty()) info = _("Select one or more styles from the list"); label_info = gtk_label_new(info.c_str()); gtk_widget_show(label_info); gtk_box_pack_start(GTK_BOX(vbox1), label_info, FALSE, FALSE, 0); gtk_misc_set_alignment(GTK_MISC(label_info), 0, 0.5); GSList *radiobutton_basic_group = NULL; radiobutton_basic = gtk_radio_button_new_with_mnemonic(NULL, _("Basic")); gtk_widget_show(radiobutton_basic); gtk_box_pack_start(GTK_BOX(vbox1), radiobutton_basic, FALSE, FALSE, 0); gtk_radio_button_set_group(GTK_RADIO_BUTTON(radiobutton_basic), radiobutton_basic_group); radiobutton_basic_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(radiobutton_basic)); shortcuts.button(radiobutton_basic); radiobutton_paragraph = gtk_radio_button_new_with_mnemonic(NULL, _("Basic, paragraph")); gtk_widget_show(radiobutton_paragraph); gtk_box_pack_start(GTK_BOX(vbox1), radiobutton_paragraph, FALSE, FALSE, 0); gtk_radio_button_set_group(GTK_RADIO_BUTTON(radiobutton_paragraph), radiobutton_basic_group); radiobutton_basic_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(radiobutton_paragraph)); shortcuts.button(radiobutton_paragraph); radiobutton_word_note = gtk_radio_button_new_with_mnemonic(NULL, _("Basic, paragraph, word, note")); gtk_widget_show(radiobutton_word_note); gtk_box_pack_start(GTK_BOX(vbox1), radiobutton_word_note, FALSE, FALSE, 0); gtk_radio_button_set_group(GTK_RADIO_BUTTON(radiobutton_word_note), radiobutton_basic_group); radiobutton_basic_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(radiobutton_word_note)); shortcuts.button(radiobutton_word_note); radiobutton_sbp = gtk_radio_button_new_with_mnemonic(NULL, _("SIL best practice")); gtk_widget_show(radiobutton_sbp); gtk_box_pack_start(GTK_BOX(vbox1), radiobutton_sbp, FALSE, FALSE, 0); gtk_radio_button_set_group(GTK_RADIO_BUTTON(radiobutton_sbp), radiobutton_basic_group); radiobutton_basic_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(radiobutton_sbp)); shortcuts.button(radiobutton_sbp); radiobutton_full = gtk_radio_button_new_with_mnemonic(NULL, _("Full")); gtk_widget_show(radiobutton_full); gtk_box_pack_start(GTK_BOX(vbox1), radiobutton_full, FALSE, FALSE, 0); gtk_radio_button_set_group(GTK_RADIO_BUTTON(radiobutton_full), radiobutton_basic_group); radiobutton_basic_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(radiobutton_full)); shortcuts.button(radiobutton_full); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radiobutton_full), true); if (!myworksheet.empty()) { expander1 = gtk_expander_new(NULL); gtk_widget_show(expander1); gtk_box_pack_start(GTK_BOX(vbox1), expander1, TRUE, TRUE, 0); label2 = gtk_label_new(_("Add non-standard style")); gtk_widget_show(label2); gtk_expander_set_label_widget(GTK_EXPANDER(expander1), label2); shortcuts.label(label2); hbox1 = gtk_hbox_new(FALSE, 4); gtk_widget_show(hbox1); gtk_container_add(GTK_CONTAINER(expander1), hbox1); label1 = gtk_label_new(_("Name")); gtk_widget_show(label1); gtk_box_pack_start(GTK_BOX(hbox1), label1, FALSE, FALSE, 0); shortcuts.label(label1); entry1 = gtk_entry_new(); gtk_widget_show(entry1); gtk_box_pack_start(GTK_BOX(hbox1), entry1, TRUE, TRUE, 0); scrolledwindow1 = gtk_scrolled_window_new(NULL, NULL); gtk_widget_show(scrolledwindow1); gtk_box_pack_start(GTK_BOX(hbox2), scrolledwindow1, TRUE, TRUE, 0); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow1), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolledwindow1), GTK_SHADOW_IN); treeview1 = gtk_tree_view_new(); gtk_widget_show(treeview1); gtk_container_add(GTK_CONTAINER(scrolledwindow1), treeview1); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeview1), FALSE); store1 = gtk_list_store_new(1, G_TYPE_STRING); gtk_tree_view_set_model(GTK_TREE_VIEW(treeview1), GTK_TREE_MODEL(store1)); g_object_unref(store1); GtkCellRenderer *renderer = gtk_cell_renderer_text_new(); column1 = gtk_tree_view_column_new_with_attributes("", renderer, "text", 0, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(treeview1), column1); select1 = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview1)); gtk_tree_selection_set_mode(select1, GTK_SELECTION_SINGLE); } dialog_action_area1 = gtk_dialog_get_action_area (GTK_DIALOG(newstylesheetdialog)); gtk_widget_show(dialog_action_area1); gtk_button_box_set_layout(GTK_BUTTON_BOX(dialog_action_area1), GTK_BUTTONBOX_END); new InDialogHelp(newstylesheetdialog, NULL, &shortcuts, "file/styles/stylesheet/new"); cancelbutton1 = gtk_button_new_from_stock("gtk-cancel"); gtk_widget_show(cancelbutton1); gtk_dialog_add_action_widget(GTK_DIALOG(newstylesheetdialog), cancelbutton1, GTK_RESPONSE_CANCEL); gtk_widget_set_can_default (GTK_WIDGET (cancelbutton1), true); okbutton = gtk_button_new_from_stock("gtk-ok"); gtk_widget_show(okbutton); gtk_dialog_add_action_widget(GTK_DIALOG(newstylesheetdialog), okbutton, GTK_RESPONSE_OK); gtk_widget_set_can_default (GTK_WIDGET (okbutton), true); shortcuts.stockbutton(cancelbutton1); shortcuts.stockbutton(okbutton); shortcuts.process(); g_signal_connect((gpointer) entry1, "changed", G_CALLBACK(on_entry_changed), gpointer(this)); g_signal_connect((gpointer) radiobutton_basic, "toggled", G_CALLBACK(on_radiobutton_basic_toggled), gpointer(this)); g_signal_connect((gpointer) radiobutton_paragraph, "toggled", G_CALLBACK(on_radiobutton_paragraph_toggled), gpointer(this)); g_signal_connect((gpointer) radiobutton_word_note, "toggled", G_CALLBACK(on_radiobutton_word_note_toggled), gpointer(this)); g_signal_connect((gpointer) radiobutton_sbp, "toggled", G_CALLBACK(on_radiobutton_sbp_toggled), gpointer(this)); g_signal_connect((gpointer) radiobutton_full, "toggled", G_CALLBACK(on_radiobutton_full_toggled), gpointer(this)); g_signal_connect((gpointer) okbutton, "clicked", G_CALLBACK(on_okbutton_clicked), gpointer(this)); gtk_widget_grab_focus(entry1); gtk_widget_grab_default(okbutton); gtk_label_set_mnemonic_widget(GTK_LABEL(label1), entry1); on_entry(); on_radiobutton(); }
void init_right_tree(void) { GtkTreeView *view = GTK_TREE_VIEW(tree2_w); GtkCellRenderer *renderer; GtkTreeSelection *sel; GtkTreeViewColumn *column; gint i; gtk_tree_view_set_model(view, model2); gtk_tree_view_set_headers_visible(view, TRUE); gtk_tree_view_set_rules_hint(view, TRUE); column = gtk_tree_view_column_new(); gtk_tree_view_append_column(view, column); gtk_tree_view_column_set_title(column, _("Options")); renderer = gtk_cell_renderer_pixbuf_new(); gtk_tree_view_column_pack_start(GTK_TREE_VIEW_COLUMN(column), renderer, FALSE); gtk_tree_view_column_set_attributes(GTK_TREE_VIEW_COLUMN(column), renderer, "pixbuf", COL_PIXBUF, "visible", COL_PIXVIS, NULL); renderer = gtk_cell_renderer_toggle_new(); gtk_tree_view_column_pack_start(GTK_TREE_VIEW_COLUMN(column), renderer, FALSE); gtk_tree_view_column_set_attributes(GTK_TREE_VIEW_COLUMN(column), renderer, "active", COL_BTNACT, "inconsistent", COL_BTNINC, "visible", COL_BTNVIS, "radio", COL_BTNRAD, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(GTK_TREE_VIEW_COLUMN(column), renderer, FALSE); gtk_tree_view_column_set_attributes(GTK_TREE_VIEW_COLUMN(column), renderer, "text", COL_OPTION, "foreground-gdk", COL_COLOR, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_insert_column_with_attributes(view, -1, _("Name"), renderer, "text", COL_NAME, "foreground-gdk", COL_COLOR, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_insert_column_with_attributes(view, -1, "N", renderer, "text", COL_NO, "foreground-gdk", COL_COLOR, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_insert_column_with_attributes(view, -1, "M", renderer, "text", COL_MOD, "foreground-gdk", COL_COLOR, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_insert_column_with_attributes(view, -1, "Y", renderer, "text", COL_YES, "foreground-gdk", COL_COLOR, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_insert_column_with_attributes(view, -1, _("Value"), renderer, "text", COL_VALUE, "editable", COL_EDIT, "foreground-gdk", COL_COLOR, NULL); g_signal_connect(G_OBJECT(renderer), "edited", G_CALLBACK(renderer_edited), NULL); column = gtk_tree_view_get_column(view, COL_NAME); gtk_tree_view_column_set_visible(column, show_name); column = gtk_tree_view_get_column(view, COL_NO); gtk_tree_view_column_set_visible(column, show_range); column = gtk_tree_view_get_column(view, COL_MOD); gtk_tree_view_column_set_visible(column, show_range); column = gtk_tree_view_get_column(view, COL_YES); gtk_tree_view_column_set_visible(column, show_range); column = gtk_tree_view_get_column(view, COL_VALUE); gtk_tree_view_column_set_visible(column, show_value); if (resizeable) { for (i = 0; i < COL_VALUE; i++) { column = gtk_tree_view_get_column(view, i); gtk_tree_view_column_set_resizable(column, TRUE); } } sel = gtk_tree_view_get_selection(view); gtk_tree_selection_set_mode(sel, GTK_SELECTION_SINGLE); }
/** Create widget for select question in single question form. * * This will also register the corresponding setter function. * * @param fe cdebconf frontend * @param question handled question * @param question_box the container for question widgets * @param model model for the possible choices * @return the created widget, NULL if something went wrong * @see focus_path() */ static int create_select_list(struct frontend * fe, struct question * question, GtkWidget * question_box, GtkTreeModel * model) { GtkTreePath * path = NULL; GtkWidget * view; GtkWidget * scroll; GtkWidget * frame; /* check NULL! */ view = gtk_tree_view_new_with_model(model); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(view), FALSE /* no headers */); gtk_tree_view_set_enable_search(GTK_TREE_VIEW(view), TRUE /* enable typeahead */); gtk_tree_view_set_search_column(GTK_TREE_VIEW(view), CHOICE_MODEL_TRANSLATED_VALUE); gtk_tree_selection_set_mode( gtk_tree_view_get_selection(GTK_TREE_VIEW(view)), GTK_SELECTION_BROWSE); if (!IS_SPECIAL_QUESTION(question)) { hide_expanders(GTK_TREE_VIEW(view)); } insert_choice_column(fe, GTK_TREE_VIEW(view)); g_signal_connect_swapped(G_OBJECT(view), "row-activated", G_CALLBACK(cdebconf_gtk_set_answer_ok), fe); if (should_expand_all(question->tag)) { gtk_tree_view_expand_all(GTK_TREE_VIEW(view)); } path = cdebconf_gtk_choice_model_get_first_selected(model); /* Select first row if there is no other default */ if (NULL == path) { path = gtk_tree_path_new_first(); } else { /* Only expand path when there was a previous selection. */ gtk_tree_view_expand_to_path(GTK_TREE_VIEW(view), path); } gtk_tree_view_set_cursor(GTK_TREE_VIEW(view), path, NULL /* don't focus a particular column */, FALSE /* don't start editing */); /* We need to focus the row *after* the widget realization, see #340007. */ g_signal_connect_after(view, "expose-event", G_CALLBACK(focus_path), path); /* path will be free'd in focus_path() */ scroll = gtk_scrolled_window_new(NULL /* create horizontal adjustement */, NULL /* create vertical adjustement */); gtk_container_add(GTK_CONTAINER(scroll), view); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); frame = gtk_frame_new(NULL); gtk_container_add(GTK_CONTAINER(frame), scroll); cdebconf_gtk_add_common_layout(fe, question, question_box, frame); gtk_widget_grab_focus(view); cdebconf_gtk_register_setter(fe, SETTER_FUNCTION(set_value_from_select), question, view); return DC_OK; }
void gui_init (dt_lib_module_t *self) { dt_lib_tagging_t *d = (dt_lib_tagging_t *)malloc(sizeof(dt_lib_tagging_t)); self->data = (void *)d; d->imgsel = -1; self->widget = gtk_vbox_new(TRUE, 5); gtk_widget_set_size_request(self->widget,100,-1); GtkBox *box, *hbox; GtkWidget *button; GtkWidget *w; GtkListStore *liststore; // left side, current box = GTK_BOX(gtk_vbox_new(FALSE, 0)); gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(box), TRUE, TRUE, 0); w = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(w), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_box_pack_start(box, w, TRUE, TRUE, 0); d->current = GTK_TREE_VIEW(gtk_tree_view_new()); gtk_tree_view_set_headers_visible(d->current, FALSE); liststore = gtk_list_store_new(DT_LIB_TAGGING_NUM_COLS, G_TYPE_STRING, G_TYPE_UINT); GtkTreeViewColumn *col = gtk_tree_view_column_new(); gtk_tree_view_append_column(d->current, col); GtkCellRenderer *renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(col, renderer, TRUE); gtk_tree_view_column_add_attribute(col, renderer, "text", DT_LIB_TAGGING_COL_TAG); gtk_tree_selection_set_mode(gtk_tree_view_get_selection(d->current), GTK_SELECTION_SINGLE); gtk_tree_view_set_model(d->current, GTK_TREE_MODEL(liststore)); g_object_unref(liststore); g_object_set(G_OBJECT(d->current), "tooltip-text", _("attached tags,\ndoubleclick to detach"), (char *)NULL); g_signal_connect(G_OBJECT (d->current), "row-activated", G_CALLBACK (detach_activated), (gpointer)self); gtk_container_add(GTK_CONTAINER(w), GTK_WIDGET(d->current)); // attach/detach buttons hbox = GTK_BOX(gtk_hbox_new(TRUE, 5)); button = gtk_button_new_with_label(_("attach")); d->attach_button = button; g_object_set(G_OBJECT(button), "tooltip-text", _("attach tag to all selected images"), (char *)NULL); gtk_box_pack_start(hbox, button, FALSE, TRUE, 0); g_signal_connect(G_OBJECT (button), "clicked", G_CALLBACK (attach_button_clicked), (gpointer)self); button = gtk_button_new_with_label(_("detach")); d->detach_button = button; g_object_set(G_OBJECT(button), "tooltip-text", _("detach tag from all selected images"), (char *)NULL); g_signal_connect(G_OBJECT (button), "clicked", G_CALLBACK (detach_button_clicked), (gpointer)self); gtk_box_pack_start(hbox, button, FALSE, TRUE, 0); gtk_box_pack_start(box, GTK_WIDGET(hbox), FALSE, TRUE, 0); // right side, related box = GTK_BOX(gtk_vbox_new(FALSE, 5)); gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(box), TRUE, TRUE, 5); // text entry and new button w = gtk_entry_new(); g_object_set(G_OBJECT(w), "tooltip-text", _("enter tag name"), (char *)NULL); gtk_box_pack_start(box, w, TRUE, TRUE, 0); gtk_widget_add_events(GTK_WIDGET(w), GDK_KEY_RELEASE_MASK); // g_signal_connect(G_OBJECT(w), "key-release-event", g_signal_connect(G_OBJECT(w), "changed", G_CALLBACK(tag_name_changed), (gpointer)self); g_signal_connect(G_OBJECT (w), "activate", G_CALLBACK (entry_activated), (gpointer)self); d->entry = GTK_ENTRY(w); dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(d->entry)); // related tree view w = gtk_scrolled_window_new(NULL, NULL); gtk_widget_set_size_request(w,-1,100); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(w), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_box_pack_start(box, w, TRUE, TRUE, 0); d->related = GTK_TREE_VIEW(gtk_tree_view_new()); gtk_tree_view_set_headers_visible(d->related, FALSE); liststore = gtk_list_store_new(DT_LIB_TAGGING_NUM_COLS, G_TYPE_STRING, G_TYPE_UINT); col = gtk_tree_view_column_new(); gtk_tree_view_append_column(d->related, col); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(col, renderer, TRUE); gtk_tree_view_column_add_attribute(col, renderer, "text", DT_LIB_TAGGING_COL_TAG); gtk_tree_selection_set_mode(gtk_tree_view_get_selection(d->related), GTK_SELECTION_SINGLE); gtk_tree_view_set_model(d->related, GTK_TREE_MODEL(liststore)); g_object_unref(liststore); g_object_set(G_OBJECT(d->related), "tooltip-text", _("related tags,\ndoubleclick to attach"), (char *)NULL); g_signal_connect(G_OBJECT (d->related), "row-activated", G_CALLBACK (attach_activated), (gpointer)self); gtk_container_add(GTK_CONTAINER(w), GTK_WIDGET(d->related)); // attach and delete buttons hbox = GTK_BOX(gtk_hbox_new(TRUE, 5)); button = gtk_button_new_with_label(_("new")); d->new_button = button; g_object_set(G_OBJECT(button), "tooltip-text", _("create a new tag with the\nname you entered"), (char *)NULL); gtk_box_pack_start(hbox, button, FALSE, TRUE, 0); g_signal_connect(G_OBJECT (button), "clicked", G_CALLBACK (new_button_clicked), (gpointer)self); button = gtk_button_new_with_label(_("delete")); d->delete_button = button; g_object_set(G_OBJECT(button), "tooltip-text", _("delete selected tag"), (char *)NULL); gtk_box_pack_start(hbox, button, FALSE, TRUE, 0); g_signal_connect(G_OBJECT (button), "clicked", G_CALLBACK (delete_button_clicked), (gpointer)self); gtk_box_pack_start(box, GTK_WIDGET(hbox), FALSE, TRUE, 0); // add entry completion GtkEntryCompletion *completion = gtk_entry_completion_new(); gtk_entry_completion_set_model(completion, gtk_tree_view_get_model(GTK_TREE_VIEW(d->related))); gtk_entry_completion_set_text_column(completion, 0); gtk_entry_completion_set_inline_completion(completion, TRUE); gtk_entry_set_completion(d->entry, completion); /* connect to mouse over id */ dt_control_signal_connect(darktable.signals, DT_SIGNAL_MOUSE_OVER_IMAGE_CHANGE, G_CALLBACK(_lib_tagging_redraw_callback), self); set_keyword(self, d); }
static void gconf_bookmarks_dialog_init (GConfBookmarksDialog *dialog) { GtkWidget *scrolled_window, *hbox, *vbox; GtkWidget *content_area; GtkCellRenderer *cell; GtkTreeViewColumn *column; GConfClient *client; hbox = gtk_hbox_new (FALSE, 6); gtk_container_set_border_width (GTK_CONTAINER (hbox), 5); content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog)); gtk_container_set_border_width (GTK_CONTAINER (dialog), 5); gtk_box_set_spacing (GTK_BOX (content_area), 2); gtk_window_set_destroy_with_parent (GTK_WINDOW (dialog), TRUE); gtk_window_set_default_size (GTK_WINDOW (dialog), 300, 200); gtk_dialog_add_button (GTK_DIALOG (dialog), GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE); gtk_window_set_title (GTK_WINDOW (dialog), _("Edit Bookmarks")); dialog->list_store = gtk_list_store_new (1, G_TYPE_STRING); g_signal_connect (dialog->list_store, "row_deleted", G_CALLBACK (gconf_bookmarks_dialog_row_deleted), dialog); scrolled_window = gtk_scrolled_window_new (NULL, NULL); gtk_box_pack_start (GTK_BOX (hbox), scrolled_window, TRUE, TRUE, 0); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_window), GTK_SHADOW_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); dialog->tree_view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (dialog->list_store)); gtk_tree_view_set_reorderable (GTK_TREE_VIEW (dialog->tree_view), TRUE); g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (dialog->tree_view)), "changed", G_CALLBACK (gconf_bookmarks_dialog_selection_changed), dialog); gconf_bookmarks_dialog_populate_model (dialog); column = gtk_tree_view_column_new (); cell = gtk_cell_renderer_pixbuf_new (); g_object_set (G_OBJECT (cell), "stock-id", STOCK_BOOKMARK, NULL); gtk_tree_view_column_pack_start (column, cell, FALSE); cell = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, cell, TRUE); gtk_tree_view_column_set_attributes (column, cell, "text", 0, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (dialog->tree_view), column); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (dialog->tree_view), FALSE); g_object_unref (dialog->list_store); gtk_container_add (GTK_CONTAINER (scrolled_window), dialog->tree_view); vbox = gtk_vbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0); dialog->delete_button = gtk_button_new_from_stock (GTK_STOCK_DELETE); gtk_widget_set_sensitive (dialog->delete_button, FALSE); g_signal_connect (dialog->delete_button, "clicked", G_CALLBACK (gconf_bookmarks_dialog_delete_bookmark), dialog); gtk_box_pack_start (GTK_BOX (vbox), dialog->delete_button, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (content_area), hbox, TRUE, TRUE, 0); gtk_widget_show_all (hbox); /* Listen for gconf changes */ client = gconf_client_get_default (); gconf_client_add_dir (client, BOOKMARKS_KEY, GCONF_CLIENT_PRELOAD_NONE, NULL); dialog->notify_id = gconf_client_notify_add (client, BOOKMARKS_KEY, gconf_bookmarks_dialog_bookmarks_key_changed, dialog, NULL, NULL); g_object_unref (client); }