static void _new_contents(Helper * helper) { GtkWidget * widget; GtkTreeModel * model; GtkCellRenderer * renderer; GtkTreeViewColumn * column; widget = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(widget), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); model = gtk_tree_model_filter_new(GTK_TREE_MODEL(helper->store), NULL); gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(model), _helper_filter_contents, NULL, NULL); model = gtk_tree_model_sort_new_with_model(model); helper->contents = gtk_tree_view_new_with_model(model); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(helper->contents), FALSE); gtk_tree_view_set_search_column(GTK_TREE_VIEW(helper->contents), HSC_CONTENTS_PACKAGE); renderer = gtk_cell_renderer_pixbuf_new(); column = gtk_tree_view_column_new_with_attributes(NULL, renderer, "pixbuf", HSC_ICON, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(helper->contents), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes(_("Package"), renderer, "text", HSC_CONTENTS_PACKAGE, NULL); gtk_tree_view_column_set_sort_column_id(column, HSC_CONTENTS_PACKAGE); gtk_tree_view_append_column(GTK_TREE_VIEW(helper->contents), column); gtk_tree_view_column_clicked(column); g_signal_connect(helper->contents, "row-activated", G_CALLBACK( _helper_on_contents_row_activated), helper); gtk_container_add(GTK_CONTAINER(widget), helper->contents); gtk_notebook_append_page(GTK_NOTEBOOK(helper->notebook), widget, gtk_label_new(_("Contents"))); }
static void adblock_ui_build_treeview (AdblockUI *dialog) { GtkCellRenderer *renderer; dialog->priv->store = gtk_list_store_new (N_COLUMNS, G_TYPE_STRING); renderer = gtk_cell_renderer_text_new (); g_object_set(renderer, "editable", TRUE, NULL); g_signal_connect(renderer, "edited", (GCallback) adblock_ui_cell_edited_cb, (gpointer)dialog); gtk_tree_view_insert_column_with_attributes (dialog->priv->treeview, COL_FILTER_URI, _("Filter URI"), renderer, "text", COL_FILTER_URI, NULL); gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (dialog->priv->store), COL_FILTER_URI, GTK_SORT_ASCENDING); gtk_tree_view_set_model (dialog->priv->treeview, GTK_TREE_MODEL (dialog->priv->store)); gtk_tree_view_set_search_column (dialog->priv->treeview, COL_FILTER_URI); g_object_unref (dialog->priv->store); dialog->priv->selection = gtk_tree_view_get_selection (dialog->priv->treeview); gtk_tree_selection_set_mode (dialog->priv->selection, GTK_SELECTION_SINGLE); dialog->priv->dirty = FALSE; }
/** * Create a new GtkTreeView for search results. */ GtkWidget * search_gui_create_tree(void) { GtkTreeModel *model = create_results_model(); GtkTreeSelection *selection; GtkTreeView *tv; tv = GTK_TREE_VIEW(gtk_tree_view_new_with_model(model)); g_object_unref(model); selection = gtk_tree_view_get_selection(tv); gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE); gtk_tree_view_set_headers_clickable(tv, TRUE); gtk_tree_view_set_headers_visible(tv, TRUE); gtk_tree_view_set_enable_search(tv, TRUE); gtk_tree_view_set_search_column(tv, 0); gtk_tree_view_set_rules_hint(tv, TRUE); gtk_tree_view_set_search_equal_func(tv, search_by_regex, NULL, NULL); tree_view_set_fixed_height_mode(tv, TRUE); /* add columns to the tree view */ add_results_columns(tv); tree_view_restore_visibility(tv, PROP_SEARCH_RESULTS_COL_VISIBLE); tree_view_restore_widths(tv, PROP_SEARCH_RESULTS_COL_WIDTHS); gui_signal_connect(tv, "cursor-changed", on_tree_view_search_results_select_row, tv); gui_signal_connect(tv, "leave-notify-event", on_leave_notify, NULL); return GTK_WIDGET(tv); }
static void trg_peers_tree_view_setup_columns(TrgPeersTreeView * self, TrgPeersModel *model) { TrgTreeView *ttv = TRG_TREE_VIEW(self); trg_column_description *desc; desc = trg_tree_view_reg_column(ttv, TRG_COLTYPE_ICONTEXT, PEERSCOL_IP, _("IP"), "ip", 0); desc->model_column_extra = PEERSCOL_ICON; trg_tree_view_reg_column(ttv, TRG_COLTYPE_TEXT, PEERSCOL_HOST, _("Host"), "host", 0); #ifdef HAVE_GEOIP if (trg_peers_model_has_country_db(model)) trg_tree_view_reg_column(ttv, TRG_COLTYPE_TEXT, PEERSCOL_COUNTRY, _("Country"), "country", 0); if (trg_peers_model_has_city_db(model)) trg_tree_view_reg_column(ttv, TRG_COLTYPE_TEXT, PEERSCOL_CITY, _("City"), "city", 0); #endif trg_tree_view_reg_column(ttv, TRG_COLTYPE_SPEED, PEERSCOL_DOWNSPEED, _("Down Speed"), "down-speed", 0); trg_tree_view_reg_column(ttv, TRG_COLTYPE_SPEED, PEERSCOL_UPSPEED, _("Up Speed"), "up-speed", 0); trg_tree_view_reg_column(ttv, TRG_COLTYPE_PROG, PEERSCOL_PROGRESS, _("Progress"), "progress", 0); trg_tree_view_reg_column(ttv, TRG_COLTYPE_TEXT, PEERSCOL_FLAGS, _("Flags"), "flags", 0); trg_tree_view_reg_column(ttv, TRG_COLTYPE_TEXT, PEERSCOL_CLIENT, _("Client"), "client", 0); gtk_tree_view_set_search_column(GTK_TREE_VIEW(self), PEERSCOL_HOST); }
/* * Return a GtkTreeView* populated with data from all desktop entries. */ GtkWidget * apps_tree_new() { GtkWidget *apps_tree; GtkListStore *apps; GtkTreeViewColumn *name_col; GValue g_3 = G_VALUE_INIT; GtkCellRenderer *cellr; g_value_init(&g_3, G_TYPE_INT); g_value_set_int(&g_3, 3); if ((apps = collect_apps()) == NULL) return NULL; apps_tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(apps)); cellr = bs_cell_renderer_entry_new(); name_col = gtk_tree_view_column_new_with_attributes( "Entry", cellr, "name", NAME_COLUMN, "exec", EXEC_COLUMN, "icon", ICON_COLUMN, NULL); g_object_set_property(G_OBJECT(cellr), "xpad", &g_3); g_object_set_property(G_OBJECT(cellr), "ypad", &g_3); gtk_tree_view_append_column(GTK_TREE_VIEW(apps_tree), name_col); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(apps_tree), FALSE); gtk_tree_view_set_enable_search(GTK_TREE_VIEW(apps_tree), TRUE); gtk_tree_view_set_search_column(GTK_TREE_VIEW(apps_tree), 0); gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(apps), NAME_COLUMN, GTK_SORT_ASCENDING); return apps_tree; }
void MergeWinState(struct SubWin *d, int state) { if (d->Win) { sub_window_set_visibility(d, state); return; } if (! state) { return; } list_sub_window_create(d, "Merge Window", MERG_WIN_COL_NUM, Mlist, Mergewin_xpm, Mergewin48_xpm); d->data.data->update = MergeWinUpdate; d->data.data->setup_dialog = MergeDialog; d->data.data->dialog = &DlgMerge; d->data.data->obj = chkobject("merge"); sub_win_create_popup_menu(d->data.data, POPUP_ITEM_NUM, Popup_list, G_CALLBACK(popup_show_cb)); init_dnd(d); gtk_tree_view_set_enable_search(GTK_TREE_VIEW(d->data.data->text), TRUE); gtk_tree_view_set_search_column(GTK_TREE_VIEW(d->data.data->text), MERG_WIN_COL_FILE); tree_view_set_tooltip_column(GTK_TREE_VIEW(d->data.data->text), MERG_WIN_COL_FILE); }
static void LoadCheatListItems(int index) { GtkListStore *store = gtk_list_store_new(2, G_TYPE_BOOLEAN, G_TYPE_STRING); GtkTreeIter iter; GtkWidget *widget; int i; widget = gtk_builder_get_object(builder, "GtkCList_Cheat"); for (i = 0; i < NumCheats; i++) { gtk_list_store_append(store, &iter); gtk_list_store_set(store, &iter, 0, Cheats[i].Enabled, 1, Cheats[i].Descr, -1); } gtk_tree_view_set_model(GTK_TREE_VIEW(widget), GTK_TREE_MODEL(store)); g_object_unref(G_OBJECT(store)); gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(widget), TRUE); gtk_tree_view_set_search_column(GTK_TREE_VIEW(widget), 1); gtk_widget_show(widget); if (index >= NumCheats) { index = NumCheats - 1; } if (index >= 0) { GtkTreePath *path; GtkTreeSelection *sel; path = gtk_tree_path_new_from_indices(index, -1); sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(widget)); gtk_tree_selection_select_path(sel, path); gtk_tree_path_free(path); } }
static void build_search_entry(GitgWindow *window, GtkBuilder *builder) { GtkWidget *box = GTK_WIDGET(gtk_builder_get_object(builder, "hbox_top")); GtkWidget *entry = sexy_icon_entry_new(); GtkImage *image = GTK_IMAGE(gtk_image_new_from_stock(GTK_STOCK_FIND, GTK_ICON_SIZE_MENU)); sexy_icon_entry_set_icon(SEXY_ICON_ENTRY(entry), SEXY_ICON_ENTRY_PRIMARY, image); gtk_tree_view_set_search_entry(window->priv->tree_view, GTK_ENTRY(entry)); gtk_widget_show(entry); gtk_box_pack_end(GTK_BOX(box), entry, FALSE, FALSE, 0); GtkBuilder *b = gitg_utils_new_builder( "gitg-menus.xml"); GtkUIManager *manager = GTK_UI_MANAGER(gtk_builder_get_object(b, "uiman")); window->priv->search_popup = GTK_WIDGET(g_object_ref(gtk_ui_manager_get_widget(manager, "/ui/search_popup"))); gtk_builder_connect_signals(b, window); g_object_unref(b); g_signal_connect(entry, "icon-pressed", G_CALLBACK(on_search_icon_pressed), window); gtk_tree_view_set_search_column(window->priv->tree_view, 1); gtk_tree_view_set_search_equal_func(window->priv->tree_view, search_equal_func, window, NULL); GtkAccelGroup *group = gtk_accel_group_new(); GClosure *closure = g_cclosure_new(G_CALLBACK(focus_search), entry, NULL); gtk_accel_group_connect(group, GDK_f, GDK_CONTROL_MASK, 0, closure); gtk_window_add_accel_group(GTK_WINDOW(window), group); }
void search_column_activate(GtkAction *action, gint column, GtkTreeView *tree_view) { if (!gtk_toggle_action_get_active(GTK_TOGGLE_ACTION(action))) return; gtk_tree_view_set_search_column(tree_view, column); }
void iopen_init(GtkWidget *window) { parent_window = window; GtkWidget *main_vbox = gtk_vbox_new(false, 0); iopen_buffer = buffer_create(); iopen_buffer->single_line = true; load_empty(iopen_buffer); iopen_editor = new_editor(iopen_buffer, true); buffer_set_onchange(iopen_buffer, iopen_buffer_onchange); config_set(&(iopen_buffer->config), CFG_AUTOWRAP, "0"); config_set(&(iopen_buffer->config), CFG_AUTOCOMPL_POPUP, "0"); iopen_editor->single_line_escape = &iopen_escape; iopen_editor->single_line_return = &iopen_enter; iopen_editor->single_line_other_keys = &iopen_other_keys; gtk_box_pack_start(GTK_BOX(main_vbox), GTK_WIDGET(iopen_editor), FALSE, FALSE, 0); results_list = gtk_list_store_new(4, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_DOUBLE); gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(results_list), 3, GTK_SORT_ASCENDING); results_tree = gtk_tree_view_new(); crt = gtk_cell_renderer_text_new(); iopen_recoloring(); gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(results_tree), -1, "Show", crt, "markup", 0, NULL); gtk_tree_view_set_model(GTK_TREE_VIEW(results_tree), GTK_TREE_MODEL(results_list)); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(results_tree), FALSE); gtk_tree_view_set_search_column(GTK_TREE_VIEW(results_tree), 1); g_signal_connect(G_OBJECT(results_tree), "row-activated", G_CALLBACK(result_activated_callback), NULL); GtkWidget *results_scroll = gtk_scrolled_window_new(NULL, NULL); gtk_container_add(GTK_CONTAINER(results_scroll), results_tree); gtk_box_pack_start(GTK_BOX(main_vbox), frame_piece(TRUE), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(main_vbox), results_scroll, TRUE, TRUE, 0); iopen_window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_decorated(GTK_WINDOW(iopen_window), TRUE); gtk_window_set_default_size(GTK_WINDOW(iopen_window), 640, 480); g_signal_connect(G_OBJECT(iopen_window), "delete-event", G_CALLBACK(delete_callback), NULL); g_signal_connect(G_OBJECT(iopen_window), "map_event", G_CALLBACK(map_callback), NULL); gtk_container_add(GTK_CONTAINER(iopen_window), main_vbox); file_recursor_requests = g_async_queue_new(); tags_requests = g_async_queue_new(); buffers_requests = g_async_queue_new(); g_thread_new("iopen file recursion", iopen_recursor_thread, NULL); g_thread_new("tags iteration", iopen_tags_thread, NULL); g_thread_new("buffer iteration", iopen_buffer_thread, NULL); }
static void file_view_init (AnjutaFileView *object) { GtkCellRenderer* renderer_pixbuf; GtkCellRenderer* renderer_display; GtkTreeViewColumn* column; GtkTreeSelection* selection; GtkTreeModel* sort_model; AnjutaFileViewPrivate* priv = ANJUTA_FILE_VIEW_GET_PRIVATE (object); priv->current_selection = NULL; priv->model = file_model_new (GTK_TREE_VIEW(object), NULL); g_signal_connect_object (priv->model, "directory-expanded", G_CALLBACK (file_view_directory_expanded), object, 0); sort_model = gtk_tree_model_sort_new_with_model(GTK_TREE_MODEL(priv->model)); gtk_tree_view_set_model (GTK_TREE_VIEW(object), sort_model); /* set_model takes a reference so we can release the reference we got when * the sort_model was created. */ g_object_unref (sort_model); gtk_tree_sortable_set_default_sort_func (GTK_TREE_SORTABLE(sort_model), file_view_sort_model, NULL, NULL); renderer_pixbuf = gtk_cell_renderer_pixbuf_new (); renderer_display = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new (); gtk_tree_view_column_set_title (column, _("Filename")); gtk_tree_view_column_pack_start (column, renderer_pixbuf, FALSE); gtk_tree_view_column_pack_start (column, renderer_display, FALSE); gtk_tree_view_column_set_cell_data_func(column, renderer_pixbuf, file_view_render_pixbuf_with_emblem, object, NULL); gtk_tree_view_column_set_attributes (column, renderer_display, "markup", COLUMN_DISPLAY, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (object), column); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (object)); g_signal_connect (selection, "changed", G_CALLBACK (file_view_selection_changed), object); /* DND */ gtk_tree_view_enable_model_drag_source (GTK_TREE_VIEW(object), GDK_BUTTON1_MASK, uri_targets, 1, GDK_ACTION_MOVE); /* Typeahead search */ gtk_tree_view_set_search_column (GTK_TREE_VIEW (object), COLUMN_FILENAME); }
/* Static functions */ static void gal_view_instance_save_as_dialog_set_instance (GalViewInstanceSaveAsDialog *dialog, GalViewInstance *instance) { GtkListStore *store; GtkCellRenderer *renderer; gint ii, view_count; dialog->instance = instance; store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_POINTER); view_count = gal_view_collection_get_count (instance->collection); for (ii = 0; ii < view_count; ii++) { GalViewCollectionItem *item; GtkTreeIter iter; gchar *title = NULL; item = gal_view_collection_get_view_item ( instance->collection, ii); title = e_str_without_underscores (item->title); gtk_list_store_append (store, &iter); gtk_list_store_set ( store, &iter, COL_GALVIEW_NAME, title, COL_GALVIEW_DATA, item, -1); g_free (title); } gtk_tree_sortable_set_sort_column_id ( GTK_TREE_SORTABLE (store), COL_GALVIEW_NAME, GTK_SORT_ASCENDING); /* attaching treeview to model */ gtk_tree_view_set_model (dialog->treeview, GTK_TREE_MODEL (store)); gtk_tree_view_set_search_column (dialog->treeview, COL_GALVIEW_NAME); dialog->model = GTK_TREE_MODEL (store); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes ( dialog->treeview, COL_GALVIEW_NAME, _("Name"), renderer, "text", COL_GALVIEW_NAME, NULL); /* set sort column */ gtk_tree_sortable_set_sort_column_id ( GTK_TREE_SORTABLE (dialog->model), COL_GALVIEW_NAME, GTK_SORT_ASCENDING); }
static gboolean serverstats_idle_handler(ss_str * s) { GtkTreeIter iter; MpdDBStats *stats = NULL; if (s->data == NULL || !mpd_check_connected(connection) || cancel_query) { if (gtk_tree_model_get_iter_first(s->model, &iter)) { do { guint d; gulong i; gchar *value = NULL; gtk_tree_model_get(s->model, &iter, 0, &i, -1); d = (guint) 100 *(i / (double)s->max_i); value = format_time_real(i, ""); gtk_list_store_set(GTK_LIST_STORE(s->model), &iter, 2, d, 3, value, -1); g_free(value); } while (gtk_tree_model_iter_next(s->model, &iter)); } if (s->data) mpd_data_free(s->data); gtk_tree_view_set_model(GTK_TREE_VIEW(serverstats_tree), s->model); gtk_tree_view_set_search_column(GTK_TREE_VIEW(serverstats_tree), 1); gtk_widget_set_sensitive(GTK_WIDGET(s->box), TRUE); gtk_widget_hide(gtk_widget_get_parent(s->pb)); if (cancel_query) gtk_list_store_clear(GTK_LIST_STORE(s->model)); g_free(s); cancel_query = FALSE; return FALSE; } mpd_database_search_stats_start(connection); mpd_database_search_add_constraint(connection, s->tag, s->data->tag); stats = mpd_database_search_stats_commit(connection); if (stats) { gtk_list_store_prepend(GTK_LIST_STORE(s->model), &iter); gtk_list_store_set(GTK_LIST_STORE(s->model), &iter, 0, (unsigned long)(stats->playTime), 1, s->data->tag, -1); s->max_i = MAX(s->max_i, stats->playTime); mpd_database_search_free_stats(stats); } /* limit the amount of updating to 0.2 % */ if ((int)((1000 * s->hits) / s->total) % 5 == 0) { gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(s->pb), s->hits / (double)s->total); } s->hits++; s->data = mpd_data_get_next(s->data); return TRUE; }
SidebarIndexPage::SidebarIndexPage(Control* control) : AbstractSidebarPage( control) { XOJ_INIT_TYPE(SidebarIndexPage); this->searchTimeout = 0; this->hasContents = false; this->treeViewBookmarks = gtk_tree_view_new(); g_object_ref(this->treeViewBookmarks); gtk_tree_view_set_enable_search(GTK_TREE_VIEW(treeViewBookmarks), true); gtk_tree_view_set_search_column(GTK_TREE_VIEW(treeViewBookmarks), DOCUMENT_LINKS_COLUMN_NAME); gtk_tree_view_set_search_equal_func(GTK_TREE_VIEW(treeViewBookmarks), (GtkTreeViewSearchEqualFunc) treeSearchFunction, this, NULL); this->scrollBookmarks = gtk_scrolled_window_new(NULL, NULL); g_object_ref(this->scrollBookmarks); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollBookmarks), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrollBookmarks), GTK_SHADOW_IN); GtkTreeSelection* selection = gtk_tree_view_get_selection(GTK_TREE_VIEW( treeViewBookmarks)); gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeViewBookmarks), FALSE); gtk_container_add(GTK_CONTAINER(scrollBookmarks), treeViewBookmarks); GtkTreeViewColumn* 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(treeViewBookmarks), column); GtkCellRenderer* renderer = (GtkCellRenderer*) g_object_new( GTK_TYPE_CELL_RENDERER_TEXT, "ellipsize", PANGO_ELLIPSIZE_END, 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", DOCUMENT_LINKS_COLUMN_NAME, NULL); renderer = gtk_cell_renderer_text_new(); 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", DOCUMENT_LINKS_COLUMN_PAGE_NUMBER, NULL); g_object_set(G_OBJECT(renderer), "style", PANGO_STYLE_ITALIC, NULL); g_signal_connect(treeViewBookmarks, "cursor-changed", G_CALLBACK(treeBookmarkSelected), this); gtk_widget_show(this->treeViewBookmarks); registerListener(control); }
static void logview_loglist_init (LogviewLoglist *list) { GtkTreeStore *model; GtkTreeViewColumn *column; GtkTreeSelection *selection; GtkCellRenderer *cell; list->priv = GET_PRIVATE (list); list->priv->has_day_selection = FALSE; list->priv->selection = NULL; model = gtk_tree_store_new (5, LOGVIEW_TYPE_LOG, G_TYPE_STRING, G_TYPE_INT, G_TYPE_BOOLEAN, G_TYPE_POINTER); gtk_tree_view_set_model (GTK_TREE_VIEW (list), GTK_TREE_MODEL (model)); list->priv->model = model; gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (list), FALSE); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (list)); gtk_tree_selection_set_mode (selection, GTK_SELECTION_BROWSE); g_signal_connect (selection, "changed", G_CALLBACK (tree_selection_changed_cb), list); cell = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new (); gtk_tree_view_column_pack_start (column, cell, TRUE); gtk_tree_view_column_set_attributes (column, cell, "text", LOG_NAME, "weight-set", LOG_WEIGHT_SET, "weight", LOG_WEIGHT, NULL); gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (list->priv->model), LOG_NAME, GTK_SORT_ASCENDING); gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (list->priv->model), LOG_NAME, (GtkTreeIterCompareFunc) loglist_sort_func, list, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (list), column); gtk_tree_view_set_search_column (GTK_TREE_VIEW (list), -1); list->priv->manager = logview_manager_get (); g_signal_connect (list->priv->manager, "log-added", G_CALLBACK (manager_log_added_cb), list); g_signal_connect (list->priv->manager, "log-closed", G_CALLBACK (manager_log_closed_cb), list); g_signal_connect_after (list->priv->manager, "active-changed", G_CALLBACK (manager_active_changed_cb), list); g_signal_connect (list, "row-expanded", G_CALLBACK (row_expanded_cb), list); }
static void gtk_app_chooser_widget_init (GtkAppChooserWidget *self) { GtkTreeSelection *selection; GtkTreeModel *sort; GtkGesture *gesture; self->priv = gtk_app_chooser_widget_get_instance_private (self); gtk_widget_set_has_surface (GTK_WIDGET (self), FALSE); gtk_widget_init_template (GTK_WIDGET (self)); /* Various parts of the GtkTreeView code need custom code to setup, mostly * because we lack signals to connect to, or properties to set. */ selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (self->priv->program_list)); gtk_tree_selection_set_select_function (selection, gtk_app_chooser_selection_func, self, NULL); sort = gtk_tree_view_get_model (GTK_TREE_VIEW (self->priv->program_list)); gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (sort), COLUMN_NAME, GTK_SORT_ASCENDING); gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (sort), COLUMN_NAME, gtk_app_chooser_sort_func, self, NULL); gtk_tree_view_set_search_column (GTK_TREE_VIEW (self->priv->program_list), COLUMN_NAME); gtk_tree_view_set_search_equal_func (GTK_TREE_VIEW (self->priv->program_list), gtk_app_chooser_search_equal_func, NULL, NULL); gtk_tree_view_column_set_cell_data_func (self->priv->column, self->priv->secondary_padding, padding_cell_renderer_func, NULL, NULL); self->priv->monitor = g_app_info_monitor_get (); g_signal_connect (self->priv->monitor, "changed", G_CALLBACK (app_info_changed), self); gesture = gtk_gesture_multi_press_new (); gtk_gesture_single_set_button (GTK_GESTURE_SINGLE (gesture), GDK_BUTTON_SECONDARY); g_signal_connect (gesture, "pressed", G_CALLBACK (gtk_app_chooser_row_pressed_cb), self); gtk_widget_add_controller (self->priv->program_list, GTK_EVENT_CONTROLLER (gesture)); }
void gucharmap_chapters_view_set_model (GucharmapChaptersView *view, GucharmapChaptersModel *model) { GucharmapChaptersViewPrivate *priv = view->priv; GtkTreeView *tree_view = GTK_TREE_VIEW (view); priv->model = model; gtk_tree_view_set_model (tree_view, GTK_TREE_MODEL (model)); if (!model) return; gtk_tree_view_column_set_title (priv->column, gucharmap_chapters_model_get_title (model)); /* Need to re-set this here since it's set to -1 when the tree view model changes! */ gtk_tree_view_set_search_column (tree_view, GUCHARMAP_CHAPTERS_MODEL_COLUMN_LABEL); }
int main(int argc, char *argv[]) { gtk_init(&argc, &argv); gchar *dirname = g_path_get_dirname(argv[0]); gchar *dataFilename = g_build_filename(dirname, "phonebook.dat", NULL); base_t *ctx = base_new(dataFilename); g_free(dirname); g_free(dataFilename); GtkWidget *window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(window), "PSP1Beleg"); gtk_window_set_default_size(GTK_WINDOW(window), 640, 480); gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER); g_signal_connect_swapped(G_OBJECT(window), "destroy", G_CALLBACK(gtk_main_quit), NULL); gbase_list_singleton = gbase_list_new(ctx); tree_view_singleton = gtk_tree_view_new_with_model(GTK_TREE_MODEL(gbase_list_singleton)); g_object_unref(gbase_list_singleton); //fill_model(gbase_list_singleton); gtk_tree_view_set_search_column(GTK_TREE_VIEW(tree_view_singleton), GBASE_LIST_COL_NUMBER); g_signal_connect(G_OBJECT(tree_view_singleton), "key-press-event", G_CALLBACK(on_key_press), NULL); append_column(GBASE_LIST_COL_NUMBER, "Phone Number"); append_column(GBASE_LIST_COL_NAME, "Surname"); append_column(GBASE_LIST_COL_FORENAME, "Forename"); GtkWidget *scrolled_window = gtk_scrolled_window_new(NULL, NULL); gtk_container_add(GTK_CONTAINER(scrolled_window), tree_view_singleton); gtk_container_add(GTK_CONTAINER(window), scrolled_window); gtk_widget_show_all(window); gtk_main(); bool ok = base_save(ctx); base_delete(ctx); return ok ? 0 : 1; }
void treeview2_set_up_constants(GtkTreeView *treeview, gint type) { #ifdef DEBUG printf("treeview2_set_up_constants\n"); #endif GtkTreeViewColumn *col; GtkCellRenderer *renderer; gchar *titles[2] = {_("Name"), _("Value")}; gint i; gtk_tree_selection_set_mode(gtk_tree_view_get_selection(treeview), GTK_SELECTION_SINGLE); gtk_tree_view_set_headers_visible(treeview, TRUE); gtk_tree_view_set_rules_hint(treeview, TRUE); gtk_tree_view_set_search_column(treeview, 0); gtk_tree_view_set_search_equal_func(treeview, treeview_helper_search_equal_strings, NULL, NULL); for(i = 0; i < 2; i++) { col = gtk_tree_view_column_new(); gtk_tree_view_column_set_title(col, titles[i]); gtk_tree_view_append_column(treeview, col); renderer = treeview_helper_cell_renderer_text_new(); gtk_tree_view_column_pack_start(col, renderer, TRUE); gtk_tree_view_column_add_attribute(col, renderer, "text", i); if(i == 1) { g_object_set(renderer, "editable", TRUE, NULL); g_signal_connect (renderer, "edited", (type == CONSTANTS_TYPE_APP) ? G_CALLBACK (treeview_helper_constants_app_editing_done) : G_CALLBACK (treeview_helper_constants_editing_done), treeview); } } }
static void bar_exif_advanced_build_view(ExifBar *eb) { GtkListStore *store; if (eb->listview) return; store = gtk_list_store_new(7, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING); eb->listview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store)); g_object_unref(store); gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(eb->listview), TRUE); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(eb->listview), TRUE); if (eb->allow_search) { gtk_tree_view_set_search_column(GTK_TREE_VIEW(eb->listview), EXIF_ADVCOL_NAME); } else { gtk_tree_view_set_enable_search(GTK_TREE_VIEW(eb->listview), FALSE); } bar_exif_add_column_check(eb->listview, "", EXIF_ADVCOL_ENABLED); bar_exif_add_column(eb->listview, _("Tag"), EXIF_ADVCOL_TAG, FALSE); bar_exif_add_column(eb->listview, _("Name"), EXIF_ADVCOL_NAME, FALSE); bar_exif_add_column(eb->listview, _("Value"), EXIF_ADVCOL_VALUE, TRUE); bar_exif_add_column(eb->listview, _("Format"), EXIF_ADVCOL_FORMAT, FALSE); bar_exif_add_column(eb->listview, _("Elements"), EXIF_ADVCOL_ELEMENTS, FALSE); bar_exif_add_column(eb->listview, _("Description"), EXIF_ADVCOL_DESCRIPTION, FALSE); eb->advanced_scrolled = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(eb->advanced_scrolled), GTK_SHADOW_IN); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(eb->advanced_scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS); gtk_box_pack_start(GTK_BOX(eb->vbox), eb->advanced_scrolled, TRUE, TRUE, 0); gtk_container_add(GTK_CONTAINER(eb->advanced_scrolled), eb->listview); gtk_widget_show(eb->listview); }
static void new_chatroom_dialog_model_setup (EmpathyNewChatroomDialog *dialog) { GtkTreeView *view; GtkListStore *store; GtkTreeSelection *selection; /* View */ view = GTK_TREE_VIEW (dialog->treeview); g_signal_connect (view, "row-activated", G_CALLBACK (new_chatroom_dialog_model_row_activated_cb), dialog); /* Store/Model */ store = gtk_list_store_new (COL_COUNT, G_TYPE_STRING, /* Invite */ G_TYPE_STRING, /* Password */ G_TYPE_STRING, /* Name */ G_TYPE_STRING, /* Room */ G_TYPE_STRING, /* Member count */ G_TYPE_INT, /* Member count int */ G_TYPE_STRING); /* Tool tip */ dialog->model = GTK_TREE_MODEL (store); gtk_tree_view_set_model (view, dialog->model); gtk_tree_view_set_tooltip_column (view, COL_TOOLTIP); gtk_tree_view_set_search_column (view, COL_NAME); /* Selection */ selection = gtk_tree_view_get_selection (view); gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (store), COL_NAME, GTK_SORT_ASCENDING); g_signal_connect (selection, "changed", G_CALLBACK (new_chatroom_dialog_model_selection_changed), dialog); /* Columns */ new_chatroom_dialog_model_add_columns (dialog); }
static void apply_window_create_list_view_columns(GtkWidget *list_view) { GtkTreeViewColumn *column; GtkCellRenderer *renderer; renderer = gtk_cell_renderer_text_new(); g_object_set(G_OBJECT(renderer), "editable", TRUE, NULL); column = gtk_tree_view_column_new_with_attributes (_("Tag"), renderer, "text", TAG_NAME, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(list_view), column); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_set_search_column(GTK_TREE_VIEW(list_view), TAG_NAME); g_signal_connect(G_OBJECT(renderer), "edited", G_CALLBACK(tag_apply_selected_edited), list_view); }
static GtkWidget *pluginwindow_list_view_create(PluginWindow *pluginwindow) { GtkTreeView *list_view; GtkTreeSelection *selector; GtkTreeModel *model; model = GTK_TREE_MODEL(pluginwindow_create_data_store()); list_view = GTK_TREE_VIEW(gtk_tree_view_new_with_model(model)); g_object_unref(model); gtk_tree_view_set_rules_hint(list_view, prefs_common.use_stripes_everywhere); gtk_tree_view_set_search_column (list_view, 0); selector = gtk_tree_view_get_selection(list_view); gtk_tree_selection_set_mode(selector, GTK_SELECTION_BROWSE); gtk_tree_selection_set_select_function(selector, pluginwindow_selected, pluginwindow, NULL); /* create the columns */ pluginwindow_create_list_view_columns(GTK_WIDGET(list_view)); return GTK_WIDGET(list_view); }
static void prepare_file_view(void) { GtkCellRenderer *text_renderer; GtkTreeViewColumn *column; GtkTreeSelection *selection; PangoFontDescription *pfd; file_store = gtk_list_store_new(FILEVIEW_N_COLUMNS, G_TYPE_STRING, G_TYPE_STRING); gtk_tree_view_set_model(GTK_TREE_VIEW(file_view), GTK_TREE_MODEL(file_store)); text_renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new(); gtk_tree_view_column_pack_start(column, text_renderer, TRUE); gtk_tree_view_column_set_attributes(column, text_renderer, "text", FILEVIEW_COLUMN_NAME, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(file_view), column); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(file_view), FALSE); gtk_tree_view_set_enable_search(GTK_TREE_VIEW(file_view), TRUE); gtk_tree_view_set_search_column(GTK_TREE_VIEW(file_view), FILEVIEW_COLUMN_NAME); pfd = pango_font_description_from_string(geany_data->interface_prefs->tagbar_font); gtk_widget_modify_font(file_view, pfd); pango_font_description_free(pfd); /* selection handling */ selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(file_view)); gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE); g_signal_connect(G_OBJECT(file_view), "button-release-event", G_CALLBACK(on_button_release), NULL); g_signal_connect(G_OBJECT(file_view), "button-press-event", G_CALLBACK(on_button_press), NULL); g_signal_connect(G_OBJECT(file_view), "key-press-event", G_CALLBACK(on_key_press), NULL); }
BookmarkList * bookmark_list_new (gboolean menu_icons) { BookmarkList *book_list; GtkWidget *scrolled; GtkTreeView *list_view; book_list = g_new0 (BookmarkList, 1); book_list->list = NULL; book_list->menu_icons = menu_icons; /* Create the widgets. */ 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_ETCHED_IN); book_list->list_store = gtk_list_store_new (BOOK_LIST_NUM_COLUMNS, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING); list_view = (GtkTreeView*) gtk_tree_view_new_with_model (GTK_TREE_MODEL (book_list->list_store)); gtk_tree_view_set_rules_hint (list_view, FALSE); add_columns (list_view); gtk_tree_view_set_headers_visible (list_view, FALSE); gtk_tree_view_set_enable_search (list_view, TRUE); gtk_tree_view_set_search_column (list_view, BOOK_LIST_COLUMN_NAME); book_list->list_view = (GtkWidget*) list_view; gtk_container_add (GTK_CONTAINER (scrolled), book_list->list_view); book_list->root_widget = scrolled; return book_list; }
static PanelAddtoDialog * panel_addto_dialog_new (PanelWidget *panel_widget) { PanelAddtoDialog *dialog; GtkWidget *dialog_vbox; 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; dialog->name_notify = panel_profile_toplevel_notify_add ( dialog->panel_widget->toplevel, "name", (MateConfClientNotifyFunc) 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_has_separator (GTK_DIALOG (dialog->addto_dialog), 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)); gtk_box_set_spacing (GTK_BOX (dialog_vbox), 12); gtk_container_set_border_width (GTK_CONTAINER (dialog_vbox), 5); 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); inner_vbox = gtk_vbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (dialog_vbox), inner_vbox, TRUE, TRUE, 0); 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); gtk_widget_show_all (dialog_vbox); 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 void plugin_manager_create(void) { GtkWidget *window; GtkWidget *vbox; #ifdef USE_UPDATE_CHECK_PLUGIN GtkWidget *update_check_btn; #endif GtkWidget *close_btn; GtkWidget *confirm_area; GtkWidget *scrolledwin; GtkWidget *treeview; GtkListStore *store; GtkTreeSelection *selection; GtkTreeViewColumn *column; GtkCellRenderer *renderer; window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(window), _("Plug-in manager")); gtk_widget_set_size_request(window, 600, 400); gtk_window_set_policy(GTK_WINDOW(window), FALSE, TRUE, TRUE); gtk_container_set_border_width(GTK_CONTAINER(window), 8); vbox = gtk_vbox_new(FALSE, 6); gtk_widget_show(vbox); gtk_container_add(GTK_CONTAINER(window), vbox); gtkut_stock_button_set_create(&confirm_area, #ifdef USE_UPDATE_CHECK_PLUGIN &update_check_btn, _("Check for _update"), &close_btn, GTK_STOCK_CLOSE, NULL, NULL); gtkut_box_set_reverse_order(GTK_BOX(confirm_area), TRUE); #else &close_btn, GTK_STOCK_CLOSE, NULL, NULL, NULL, NULL); #endif gtk_widget_show(confirm_area); gtk_box_pack_end(GTK_BOX(vbox), confirm_area, FALSE, FALSE, 0); gtk_widget_grab_default(close_btn); g_signal_connect(G_OBJECT(window), "delete_event", G_CALLBACK(plugin_manager_deleted), NULL); g_signal_connect(G_OBJECT(window), "key_press_event", G_CALLBACK(key_pressed), NULL); #ifdef USE_UPDATE_CHECK_PLUGIN g_signal_connect(G_OBJECT(update_check_btn), "clicked", G_CALLBACK(plugin_manager_update_check), NULL); #endif g_signal_connect(G_OBJECT(close_btn), "clicked", G_CALLBACK(plugin_manager_deleted), NULL); scrolledwin = gtk_scrolled_window_new(NULL, NULL); gtk_widget_show(scrolledwin); gtk_widget_set_size_request(scrolledwin, -1, -1); gtk_box_pack_start(GTK_BOX(vbox), scrolledwin, TRUE, TRUE, 0); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwin), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolledwin), GTK_SHADOW_IN); store = gtk_list_store_new(N_COLS, G_TYPE_STRING); treeview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store)); g_object_unref(G_OBJECT(store)); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeview), TRUE); gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(treeview), TRUE); gtk_tree_view_set_search_column(GTK_TREE_VIEW(treeview), COL_INFO); #if GTK_CHECK_VERSION(2, 10, 0) gtk_tree_view_set_grid_lines(GTK_TREE_VIEW(treeview), GTK_TREE_VIEW_GRID_LINES_HORIZONTAL); #endif selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview)); gtk_tree_selection_set_mode(selection, GTK_SELECTION_BROWSE); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes (_("Plug-in information"), renderer, "text", COL_INFO, NULL); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE); gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column); gtk_widget_show(treeview); gtk_container_add(GTK_CONTAINER(scrolledwin), treeview); gtk_widget_show_all(window); pm_window.window = window; pm_window.close_btn = close_btn; pm_window.treeview = treeview; pm_window.store = store; pm_window.selection = selection; }
void Config_macros(GtkAction *action, gpointer data) { GtkWidget *vbox, *hbox; GtkWidget *sw; GtkTreeModel *model; GtkWidget *treeview; GtkWidget *button; GtkWidget *separator; /* create window, etc */ window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (window), _("Configure Macros")); g_signal_connect (window, "destroy", G_CALLBACK (gtk_widget_destroyed), &window); gtk_container_set_border_width (GTK_CONTAINER (window), 8); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8); gtk_container_add (GTK_CONTAINER (window), vbox); 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_box_pack_start (GTK_BOX (vbox), sw, TRUE, TRUE, 0); /* create tree model */ model = create_model (); /* create tree view */ treeview = gtk_tree_view_new_with_model (model); gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (treeview), TRUE); gtk_tree_view_set_search_column (GTK_TREE_VIEW (treeview), COLUMN_SHORTCUT); g_object_unref (model); gtk_container_add (GTK_CONTAINER (sw), treeview); /* add columns to the tree view */ add_columns (GTK_TREE_VIEW (treeview)); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4); gtk_box_set_homogeneous (GTK_BOX (hbox), TRUE); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); button = gtk_button_new_with_mnemonic (_("_Add")); g_signal_connect(button, "clicked", G_CALLBACK(Add_shortcut), (gpointer)model); gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0); button = gtk_button_new_with_mnemonic (_("_Delete")); g_signal_connect(button, "clicked", G_CALLBACK(Delete_shortcut), (gpointer)treeview); gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0); button = gtk_button_new_with_mnemonic (_("_Capture Shortcut")); g_signal_connect(button, "clicked", G_CALLBACK(Capture_shortcut), (gpointer)treeview); gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0); separator = gtk_separator_new(GTK_ORIENTATION_HORIZONTAL); gtk_box_pack_start (GTK_BOX (vbox), separator, FALSE, TRUE, 0); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4); gtk_box_set_homogeneous (GTK_BOX (hbox), TRUE); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); button = gtk_button_new_from_stock (GTK_STOCK_HELP); g_signal_connect(button, "clicked", G_CALLBACK(Help_screen), (gpointer)window); gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0); button = gtk_button_new_from_stock (GTK_STOCK_OK); g_signal_connect(button, "clicked", G_CALLBACK(Save_shortcuts), (gpointer)treeview); g_signal_connect_swapped(button, "clicked", G_CALLBACK(gtk_widget_destroy), (gpointer)window); gtk_box_pack_end (GTK_BOX (hbox), button, TRUE, TRUE, 0); button = gtk_button_new_from_stock (GTK_STOCK_CANCEL); g_signal_connect_swapped(button, "clicked", G_CALLBACK(gtk_widget_destroy), (gpointer)window); gtk_box_pack_end (GTK_BOX (hbox), button, TRUE, TRUE, 0); gtk_window_set_default_size (GTK_WINDOW(window), 300, 400); gtk_widget_show_all(window); }
static GtkWidget * input_chooser_new (GtkWindow *main_window, GtkListStore *active_sources) { GtkBuilder *builder; GtkWidget *chooser; GtkWidget *filtered_list; GtkWidget *filter_entry; GtkTreeViewColumn *visible_column; GtkTreeSelection *selection; GtkListStore *model; GtkTreeModelFilter *filtered_model; GtkTreeIter iter; GError *error = NULL; builder = gtk_builder_new (); gtk_builder_add_from_resource (builder, "/ui/gnome-region-panel-input-chooser.ui", &error); if (error) g_error ("Problem parsing ui file %s", error->message); chooser = WID ("input_source_chooser"); input_chooser = chooser; g_object_add_weak_pointer (G_OBJECT (chooser), (gpointer *) &input_chooser); g_object_set_data_full (G_OBJECT (chooser), "builder", builder, g_object_unref); filtered_list = WID ("filtered_input_source_list"); filter_entry = WID ("input_source_filter"); g_object_set_data (G_OBJECT (chooser), "filtered_input_source_list", filtered_list); visible_column = gtk_tree_view_column_new_with_attributes ("Input Sources", gtk_cell_renderer_text_new (), "text", NAME_COLUMN, NULL); gtk_window_set_transient_for (GTK_WINDOW (chooser), main_window); gtk_tree_view_append_column (GTK_TREE_VIEW (filtered_list), visible_column); /* We handle searching ourselves, thank you. */ gtk_tree_view_set_enable_search (GTK_TREE_VIEW (filtered_list), FALSE); gtk_tree_view_set_search_column (GTK_TREE_VIEW (filtered_list), -1); g_signal_connect_swapped (G_OBJECT (filter_entry), "activate", G_CALLBACK (entry_activated), builder); g_signal_connect_swapped (G_OBJECT (filter_entry), "notify::text", G_CALLBACK (filter_changed), builder); g_signal_connect (G_OBJECT (filter_entry), "icon-release", G_CALLBACK (filter_clear), NULL); filtered_model = GTK_TREE_MODEL_FILTER (gtk_builder_get_object (builder, "filtered_input_source_model")); model = GTK_LIST_STORE (gtk_builder_get_object (builder, "input_source_model")); populate_model (model, active_sources); gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (model), NAME_COLUMN, GTK_SORT_ASCENDING); gtk_tree_model_filter_set_visible_func (filtered_model, filter_func, NULL, NULL); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (filtered_list)); g_signal_connect (G_OBJECT (selection), "changed", G_CALLBACK (selection_changed), builder); if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (filtered_model), &iter)) gtk_tree_selection_select_iter (selection, &iter); g_signal_connect (G_OBJECT (filtered_list), "row-activated", G_CALLBACK (row_activated), builder); gtk_widget_grab_focus (filter_entry); gtk_widget_show (chooser); return chooser; }
GtkWidget * gimp_action_view_new (GimpUIManager *manager, const gchar *select_action, gboolean show_shortcuts) { GtkTreeView *view; GtkTreeViewColumn *column; GtkCellRenderer *cell; GtkTreeStore *store; GtkTreeModel *filter; GtkAccelGroup *accel_group; GList *list; GtkTreePath *select_path = NULL; g_return_val_if_fail (GIMP_IS_UI_MANAGER (manager), NULL); store = gtk_tree_store_new (GIMP_ACTION_VIEW_N_COLUMNS, G_TYPE_BOOLEAN, /* COLUMN_VISIBLE */ GTK_TYPE_ACTION, /* COLUMN_ACTION */ G_TYPE_STRING, /* COLUMN_STOCK_ID */ G_TYPE_STRING, /* COLUMN_LABEL */ G_TYPE_STRING, /* COLUMN_LABEL_CASEFOLD */ G_TYPE_STRING, /* COLUMN_NAME */ G_TYPE_UINT, /* COLUMN_ACCEL_KEY */ GDK_TYPE_MODIFIER_TYPE, /* COLUMN_ACCEL_MASK */ G_TYPE_CLOSURE); /* COLUMN_ACCEL_CLOSURE */ accel_group = gtk_ui_manager_get_accel_group (GTK_UI_MANAGER (manager)); for (list = gtk_ui_manager_get_action_groups (GTK_UI_MANAGER (manager)); list; list = g_list_next (list)) { GimpActionGroup *group = list->data; GList *actions; GList *list2; GtkTreeIter group_iter; gtk_tree_store_append (store, &group_iter, NULL); gtk_tree_store_set (store, &group_iter, GIMP_ACTION_VIEW_COLUMN_STOCK_ID, group->stock_id, GIMP_ACTION_VIEW_COLUMN_LABEL, group->label, -1); actions = gtk_action_group_list_actions (GTK_ACTION_GROUP (group)); actions = g_list_sort (actions, (GCompareFunc) gimp_action_name_compare); for (list2 = actions; list2; list2 = g_list_next (list2)) { GtkAction *action = list2->data; const gchar *name = gtk_action_get_name (action); const gchar *stock_id = gtk_action_get_stock_id (action); gchar *label; gchar *label_casefold; guint accel_key = 0; GdkModifierType accel_mask = 0; GClosure *accel_closure = NULL; GtkTreeIter action_iter; if (strstr (name, "-menu") || strstr (name, "-popup") || name[0] == '<') continue; label = gimp_strip_uline (gtk_action_get_label (action)); if (! (label && strlen (label))) { g_free (label); label = g_strdup (name); } label_casefold = g_utf8_casefold (label, -1); if (show_shortcuts) { accel_closure = gtk_action_get_accel_closure (action); if (accel_closure) { GtkAccelKey *key; key = gtk_accel_group_find (accel_group, gimp_action_view_accel_find_func, accel_closure); if (key && key->accel_key && key->accel_flags & GTK_ACCEL_VISIBLE) { accel_key = key->accel_key; accel_mask = key->accel_mods; } } } gtk_tree_store_append (store, &action_iter, &group_iter); gtk_tree_store_set (store, &action_iter, GIMP_ACTION_VIEW_COLUMN_VISIBLE, TRUE, GIMP_ACTION_VIEW_COLUMN_ACTION, action, GIMP_ACTION_VIEW_COLUMN_STOCK_ID, stock_id, GIMP_ACTION_VIEW_COLUMN_LABEL, label, GIMP_ACTION_VIEW_COLUMN_LABEL_CASEFOLD, label_casefold, GIMP_ACTION_VIEW_COLUMN_NAME, name, GIMP_ACTION_VIEW_COLUMN_ACCEL_KEY, accel_key, GIMP_ACTION_VIEW_COLUMN_ACCEL_MASK, accel_mask, GIMP_ACTION_VIEW_COLUMN_ACCEL_CLOSURE, accel_closure, -1); g_free (label); g_free (label_casefold); if (select_action && ! strcmp (select_action, name)) { select_path = gtk_tree_model_get_path (GTK_TREE_MODEL (store), &action_iter); } } g_list_free (actions); } filter = gtk_tree_model_filter_new (GTK_TREE_MODEL (store), NULL); g_object_unref (store); view = g_object_new (GIMP_TYPE_ACTION_VIEW, "model", filter, "rules-hint", TRUE, NULL); g_object_unref (filter); gtk_tree_model_filter_set_visible_column (GTK_TREE_MODEL_FILTER (filter), GIMP_ACTION_VIEW_COLUMN_VISIBLE); GIMP_ACTION_VIEW (view)->manager = g_object_ref (manager); GIMP_ACTION_VIEW (view)->show_shortcuts = show_shortcuts; gtk_tree_view_set_search_column (GTK_TREE_VIEW (view), GIMP_ACTION_VIEW_COLUMN_LABEL); column = gtk_tree_view_column_new (); gtk_tree_view_column_set_title (column, _("Action")); cell = gtk_cell_renderer_pixbuf_new (); gtk_tree_view_column_pack_start (column, cell, FALSE); gtk_tree_view_column_set_attributes (column, cell, "stock-id", GIMP_ACTION_VIEW_COLUMN_STOCK_ID, NULL); cell = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, cell, TRUE); gtk_tree_view_column_set_attributes (column, cell, "text", GIMP_ACTION_VIEW_COLUMN_LABEL, NULL); gtk_tree_view_append_column (view, column); if (show_shortcuts) { g_signal_connect (view, "button-press-event", G_CALLBACK (gimp_action_view_button_press), NULL); g_signal_connect (accel_group, "accel-changed", G_CALLBACK (gimp_action_view_accel_changed), view); column = gtk_tree_view_column_new (); gtk_tree_view_column_set_title (column, _("Shortcut")); cell = gtk_cell_renderer_accel_new (); g_object_set (cell, "mode", GTK_CELL_RENDERER_MODE_EDITABLE, "editable", TRUE, NULL); gtk_tree_view_column_pack_start (column, cell, TRUE); gtk_tree_view_column_set_attributes (column, cell, "accel-key", GIMP_ACTION_VIEW_COLUMN_ACCEL_KEY, "accel-mods", GIMP_ACTION_VIEW_COLUMN_ACCEL_MASK, NULL); g_signal_connect (cell, "accel-edited", G_CALLBACK (gimp_action_view_accel_edited), view); g_signal_connect (cell, "accel-cleared", G_CALLBACK (gimp_action_view_accel_cleared), view); gtk_tree_view_append_column (view, column); } column = gtk_tree_view_column_new (); gtk_tree_view_column_set_title (column, _("Name")); cell = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, cell, TRUE); gtk_tree_view_column_set_attributes (column, cell, "text", GIMP_ACTION_VIEW_COLUMN_NAME, NULL); gtk_tree_view_append_column (view, column); if (select_path) { gimp_action_view_select_path (GIMP_ACTION_VIEW (view), select_path); gtk_tree_path_free (select_path); } return GTK_WIDGET (view); }