static void account_chooser_setup (EmpathyAccountChooser *chooser) { EmpathyAccountChooserPriv *priv; GtkListStore *store; GtkCellRenderer *renderer; GtkComboBox *combobox; priv = GET_PRIV (chooser); /* Set up combo box with new store */ combobox = GTK_COMBO_BOX (chooser); gtk_cell_layout_clear (GTK_CELL_LAYOUT (combobox)); store = gtk_list_store_new (COL_ACCOUNT_COUNT, GDK_TYPE_PIXBUF, /* Image */ G_TYPE_STRING, /* Name */ G_TYPE_BOOLEAN, /* Enabled */ G_TYPE_UINT, /* Row type */ TP_TYPE_ACCOUNT); gtk_tree_sortable_set_default_sort_func (GTK_TREE_SORTABLE (store), account_cmp, chooser, NULL); gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (store), GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, GTK_SORT_ASCENDING); gtk_combo_box_set_model (combobox, GTK_TREE_MODEL (store)); renderer = gtk_cell_renderer_pixbuf_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox), renderer, FALSE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combobox), renderer, "pixbuf", COL_ACCOUNT_IMAGE, "sensitive", COL_ACCOUNT_ENABLED, NULL); renderer = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox), renderer, TRUE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combobox), renderer, "text", COL_ACCOUNT_TEXT, "sensitive", COL_ACCOUNT_ENABLED, NULL); /* Populate accounts */ tp_account_manager_prepare_async (priv->manager, NULL, account_manager_prepared_cb, chooser); g_object_unref (store); }
// TreeView für die Tracks erstellen void music_track_setup_tree (void) { GtkCellRenderer *renderer; GtkTreeViewColumn *column; GtkTreeSortable *sortable; // TreeView holen track_tree = GTK_TREE_VIEW (interface_get_widget ("treeview_tracks")); // Track Nummer renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Nr.", renderer, "text", COL_TRACK_NR, NULL); gtk_tree_view_column_set_sort_column_id (column, COL_TRACK_NR); gtk_tree_view_append_column (GTK_TREE_VIEW (track_tree), column); // Titel renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Titel", renderer, "text", COL_TRACK_TITLE, NULL); gtk_tree_view_column_set_sort_column_id (column, COL_TRACK_TITLE); gtk_tree_view_append_column (GTK_TREE_VIEW (track_tree), column); // Artist renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Artist", renderer, "text", COL_TRACK_ARTIST, NULL); gtk_tree_view_column_set_sort_column_id (column, COL_TRACK_ARTIST); gtk_tree_view_append_column (GTK_TREE_VIEW (track_tree), column); // Album renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Album", renderer, "text", COL_TRACK_ALBUM, NULL); gtk_tree_view_column_set_sort_column_id (column, COL_TRACK_ALBUM); gtk_tree_view_append_column (GTK_TREE_VIEW (track_tree), column); // Store erstellen track_store = gtk_list_store_new (COLS_TRACK, G_TYPE_INT, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT); // Sortierung sortable = GTK_TREE_SORTABLE (track_store); gtk_tree_sortable_set_sort_column_id (sortable, COL_TRACK_NR, GTK_SORT_ASCENDING); // Store dem Tree anhängen gtk_tree_view_set_model (GTK_TREE_VIEW (track_tree), GTK_TREE_MODEL (track_store)); }
static void trg_tree_view_sort_menu_item_toggled(GtkCheckMenuItem * w, gpointer data) { GtkTreeSortable *model = GTK_TREE_SORTABLE(data); trg_column_description *desc = (trg_column_description *) g_object_get_data(G_OBJECT(w), GDATA_KEY_COLUMN_DESC); if (gtk_check_menu_item_get_active(w)) { GtkSortType sortType; gtk_tree_sortable_get_sort_column_id(model, NULL, &sortType); gtk_tree_sortable_set_sort_column_id(model, desc->model_column, sortType); } }
static GtkListStore *action_store_create(void) { GtkListStore *store; store = gtk_list_store_new(N_COLUMNS, G_TYPE_POINTER, G_TYPE_STRING, G_TYPE_STRING); gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(store), COL_ID, GTK_SORT_ASCENDING); action_store_fill(store); g_object_weak_ref(G_OBJECT(store), sig_store_destroyed, NULL); return store; }
void CMatchingDlg::SetSortMode(int column) { m_FrameSort = column; for (GSList *ptr=m_FrameCols; ptr!=NULL; ptr=ptr->next) { tColData *col = (tColData*)ptr->data; if (col->data->column == column) { gtk_tree_view_column_set_sort_indicator(col->col, true); GtkSortType dir = (column!=FCOL_STARS ? GTK_SORT_ASCENDING : GTK_SORT_DESCENDING); gtk_tree_view_column_set_sort_order(col->col, dir); gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(m_Frames), column, dir); } else { gtk_tree_view_column_set_sort_indicator(col->col, false); } } }
static void load_sort_order (CryptUIKeyStore *ckstore) { GtkSortType ord = GTK_SORT_ASCENDING; gchar *sort = NULL; const gchar *name; if (ckstore->priv->sortable) sort = _cryptui_gconf_get_string (SEAHORSE_RECIPIENTS_SORT_KEY); name = sort ? sort : ""; /* Prefix with a minus means descending */ if (name[0] == '-') { ord = GTK_SORT_DESCENDING; name++; } /* Prefix with a plus meaning ascending */ else if (name[0] == '+') { ord = GTK_SORT_ASCENDING; name++; } if (g_ascii_strcasecmp ("name", name) == 0) gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (ckstore), CRYPTUI_KEY_STORE_NAME, ord); else if (g_ascii_strcasecmp ("id", name) == 0) gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (ckstore), CRYPTUI_KEY_STORE_KEYID, ord); else gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (ckstore), GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, ord); g_free (sort); }
int histo_before_chunk(void *hook_data, void *call_data) { EventsRequest *histo_events_request = (EventsRequest*)hook_data; LttvTraceset *histo_traceset = (LttvTraceset*)call_data; #if 0 /* Desactivate sort */ gtk_tree_sortable_set_sort_column_id( GTK_TREE_SORTABLE(cfd->process_list->list_store), TRACE_COLUMN, GTK_SORT_ASCENDING); #endif //0 histo_drawing_chunk_begin(histo_events_request, histo_traceset); return 0; }
static void fi_gui_files_sort_restore(void) { #if GTK_CHECK_VERSION(2,6,0) g_return_if_fail(files_sort_depth > 0); files_sort_depth--; if (0 == files_sort_depth) { if (GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID != files_sort_column) { gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(store_files), files_sort_column, files_sort_order); } } #endif /* Gtk+ => 2.6.0 */ }
static void ggg_plan_dialog_init (GggPlanDialog *self) { GggPlanDialogPrivate *priv; GtkWidget *table, *image, *label; GtkCellRenderer *cell; priv = self->priv = GET_PRIVATE (self); gtk_window_set_title (GTK_WINDOW (self), _("Cellular Data Connection Wizard")); gtk_dialog_add_buttons (GTK_DIALOG (self), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, "Manual Configuration", GTK_RESPONSE_REJECT, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, NULL); table = gtk_table_new (2, 5, FALSE); g_object_set (table, "row-spacing", 6, "column-spacing", 6, "border-width", 6, NULL); gtk_widget_show (table); image = gtk_image_new_from_stock (GTK_STOCK_NETWORK, GTK_ICON_SIZE_DIALOG); gtk_widget_show (image); gtk_table_attach_defaults (GTK_TABLE (table), image, 0, 1, 0, 2); label = gtk_label_new (_("Select your 3G Plan")); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_widget_show (label); gtk_table_attach_defaults (GTK_TABLE (table), label, 1, 3, 0, 1); priv->store = gtk_list_store_new (2, REST_TYPE_XML_NODE, G_TYPE_STRING); gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (priv->store), 1, GTK_SORT_ASCENDING); priv->combo = gtk_combo_box_new_with_model (GTK_TREE_MODEL (priv->store)); cell = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (priv->combo), cell, TRUE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (priv->combo), cell, "text", 1, NULL); gtk_widget_show (priv->combo); gtk_table_attach_defaults (GTK_TABLE (table), priv->combo, 1, 3, 1, 2); gtk_container_add (GTK_CONTAINER (GTK_DIALOG (self)->vbox), table); }
static GtkWidget* gwy_module_browser_construct(GtkWidget *parent) { static const gchar *columns[] = { N_("Module"), N_("Version"), N_("Author"), }; GtkWidget *tree; GtkListStore *store; GtkTreeSelection *selection; GtkCellRenderer *renderer; GtkTreeViewColumn *column; gsize i; store = gtk_list_store_new(MODEL_LAST, G_TYPE_POINTER, G_TYPE_POINTER, G_TYPE_BOOLEAN); gwy_module_foreach((GHFunc)gwy_module_browser_store_module, store); _gwy_module_failure_foreach((GHFunc)gwy_module_browser_store_failure, store); gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(store), MODEL_NAME, compare_modules, NULL, NULL); gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(store), MODEL_NAME, GTK_SORT_ASCENDING); tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store)); gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(tree), TRUE); g_object_unref(store); for (i = 0; i < G_N_ELEMENTS(columns); i++) { renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes(_(columns[i]), renderer, NULL); gtk_tree_view_column_set_cell_data_func(column, renderer, gwy_module_browser_render, GUINT_TO_POINTER(i), NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column); } selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree)); gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE); g_signal_connect(tree, "cursor-changed", G_CALLBACK(update_module_info_cb), parent); return tree; }
static void gtk_boursorama_app_activate(GApplication *application) { GtkBoursoramaApp* app = (GtkBoursoramaApp*) application; app->win = gtk_boursorama_app_window_new(GTK_BOURSORAMA_APP(app)); app->win->tree_model_sort = gtk_tree_model_sort_new_with_model(GTK_TREE_MODEL(app->list_store_action_list)); gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(app->win->tree_model_sort), ACTION_NAME, GTK_SORT_ASCENDING); gtk_tree_view_set_model(app->win->tree, GTK_TREE_MODEL(app->win->tree_model_sort)); g_object_unref(app->win->tree_model_sort); gtk_window_present(GTK_WINDOW(app->win)); g_thread_new("http thread", app_logic_thread_func, app); app->last_update_time = g_get_real_time(); g_timeout_add(500, gtk_boursorama_app_label_update, app); }
/* * Disable Search Stats sorting. */ static void search_stats_gui_disable_sort(void) { #if GTK_CHECK_VERSION(2,6,0) GtkTreeSortable *sortable; GtkSortType order; int column; sortable = GTK_TREE_SORTABLE(store_search_stats); if (gtk_tree_sortable_get_sort_column_id(sortable, &column, &order)) { gtk_tree_sortable_set_sort_column_id(sortable, GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID, GTK_SORT_DESCENDING); } #endif /* Gtk+ >= 2.6.0 */ }
/** * Sets root * @param root A gchar */ void rs_dir_selector_set_root(RSDirSelector *selector, const gchar *root) { GtkTreeModel *model; GtkTreeSortable *sortable; model = create_and_fill_model(root); sortable = GTK_TREE_SORTABLE(model); gtk_tree_sortable_set_sort_column_id(sortable, COL_NAME, GTK_SORT_ASCENDING); gtk_tree_view_set_model(GTK_TREE_VIEW(selector->view), model); g_object_unref(model); /* destroy model automatically with view */ }
static void search_gui_disable_sort(struct search *search) { if (search && search->sort) { #if GTK_CHECK_VERSION(2,6,0) GtkTreeModel *model; GtkTreeSortable *sortable; model = gtk_tree_view_get_model(GTK_TREE_VIEW(search->tree)); sortable = GTK_TREE_SORTABLE(model); if (gtk_tree_sortable_get_sort_column_id(sortable, NULL, NULL)) { gtk_tree_sortable_set_sort_column_id(sortable, GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID, GTK_SORT_DESCENDING); } #endif /* Gtk+ >= 2.6.0 */ } }
GtkWidget *create_view() { GtkTreeViewColumn *col; GtkCellRenderer *renderer; GtkWidget *view; g_store = gtk_list_store_new(NB_COL, G_TYPE_STRING, G_TYPE_STRING, GDK_TYPE_PIXBUF); view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(g_store)); gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(view), TRUE); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(view), FALSE); g_object_unref(g_store); // destroy store automatically with view renderer = gtk_cell_renderer_text_new(); col = gtk_tree_view_column_new(); gtk_tree_view_column_pack_start(col, renderer, TRUE); gtk_tree_view_column_add_attribute(col, renderer, "text", COL_THEME_FILE); gtk_tree_view_column_set_visible(col, FALSE); gtk_tree_view_append_column(GTK_TREE_VIEW(view),col); renderer = gtk_cell_renderer_text_new(); col = gtk_tree_view_column_new(); gtk_tree_view_column_pack_start(col, renderer, TRUE); gtk_tree_view_column_add_attribute(col, renderer, "text", COL_THEME_NAME); gtk_tree_view_append_column(GTK_TREE_VIEW(view),col); g_width_list = 200; g_height_list = 30; g_renderer = gtk_cell_renderer_pixbuf_new(); g_object_set(g_renderer, "xalign", 0.0, NULL); gtk_cell_renderer_set_fixed_size(g_renderer, g_width_list, g_height_list); // specific to gtk-2.18 or higher //gtk_cell_renderer_set_padding(g_renderer, 5, 5); col = gtk_tree_view_column_new(); gtk_tree_view_column_pack_start(col, g_renderer, TRUE); gtk_tree_view_column_add_attribute(col, g_renderer, "pixbuf", COL_SNAPSHOT); gtk_tree_view_append_column(GTK_TREE_VIEW(view),col); GtkTreeSortable *sortable; sortable = GTK_TREE_SORTABLE(g_store); gtk_tree_sortable_set_sort_column_id(sortable, COL_THEME_FILE, GTK_SORT_ASCENDING); gtk_tree_sortable_set_sort_func(sortable, COL_THEME_FILE, theme_name_compare, NULL, NULL); return view; }
static GtkListStore * load_icon_cat (IconBrowserData * data, gchar * cat) { GtkListStore *store; GList *i, *icons; gint size, w, h; gtk_icon_size_lookup (GTK_ICON_SIZE_MENU, &w, &h); size = MIN (w, h); store = gtk_list_store_new (2, GDK_TYPE_PIXBUF, G_TYPE_STRING); icons = gtk_icon_theme_list_icons (data->theme, cat); for (i = icons; i; i = i->next) { GtkTreeIter iter; GdkPixbuf *pb, *spb; spb = pb = gtk_icon_theme_load_icon (data->theme, i->data, size, GTK_ICON_LOOKUP_GENERIC_FALLBACK, NULL); if (pb) { /* scale pixbuf if needed */ w = gdk_pixbuf_get_width (pb); h = gdk_pixbuf_get_height (pb); if (w > size || h > size) { pb = gdk_pixbuf_scale_simple (spb, size, size, GDK_INTERP_BILINEAR); g_object_unref (spb); } } gtk_list_store_append (store, &iter); gtk_list_store_set (store, &iter, 0, pb, 1, i->data, -1); if (pb) g_object_unref (pb); g_free (i->data); } g_list_free (icons); gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (store), 1, GTK_SORT_ASCENDING); return store; }
static void client_init() { if(!client_tree_view) { client_tree_view = gtk_tree_view_new(); /* Create a client list that stores their Nick name, ID, Real Name, Website, Email*/ client_list = gtk_list_store_new(6,G_TYPE_STRING,G_TYPE_INT,G_TYPE_INT,G_TYPE_STRING,G_TYPE_STRING,G_TYPE_STRING); GtkCellRenderer *client_view_rend = gtk_cell_renderer_text_new(); /* Set the 1st column to be viewable in the treeview */ gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(client_tree_view),-1,"Clients",client_view_rend,"text",0,NULL); gtk_tree_view_set_model(GTK_TREE_VIEW(client_tree_view),GTK_TREE_MODEL(client_list)); gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(client_list), 0, GTK_SORT_ASCENDING); g_signal_connect(G_OBJECT(client_tree_view), "row-activated", G_CALLBACK(client_activated), NULL); g_signal_connect(G_OBJECT(client_tree_view), "button-press-event", G_CALLBACK(client_popup_menu), NULL); g_signal_connect(G_OBJECT(client_tree_view), "popup-menu", G_CALLBACK(client_popup_menu_key), NULL); } }
/* When there's a new node to display in the node treeview, call this. | Create a new model containing the nodes of the given net, insert | the model into the treeview and unref the old model. */ static void node_model_update (LibraryMenuType * menu) { GtkTreeModel *model; model = node_model; node_model = node_model_create (menu); gtk_tree_view_set_model (node_treeview, node_model); gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (node_model), NODE_NAME_COLUMN, GTK_SORT_ASCENDING); /* We could be using gtk_list_store_clear() on the same model, but it's | just as easy that we've created a new one and here unref the old one. */ if (model) g_object_unref (G_OBJECT (model)); }
GtkWidget *get_widget_list (GtkWidget *box, GtkTreeSelection **sel) { GtkWidget *sw; GtkWidget *event_view; GtkCellRenderer *rend; GtkTreeViewColumn *col; GtkTargetEntry gte [] = {{"STRING", 0, GTK_IMHTML_DRAG_STRING}}; if (tree_list == NULL) { tree_list = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_POINTER); gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE(tree_list), 0, GTK_SORT_ASCENDING); update_widget_list (tree_list); g_object_ref (G_OBJECT(tree_list)); } /* List of widgets */ sw = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW(sw), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW(sw), GTK_SHADOW_IN); gtk_box_pack_start (GTK_BOX(box), sw, TRUE, TRUE, 0); event_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(tree_list)); *sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (event_view)); rend = gtk_cell_renderer_text_new (); col = gtk_tree_view_column_new_with_attributes (_("Widget"), rend, "markup", 0, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (event_view), col); gtk_tree_view_column_set_sort_column_id (col, 0); gtk_container_add (GTK_CONTAINER(sw), event_view); /* Drag and Drop */ gtk_tree_view_enable_model_drag_source( GTK_TREE_VIEW(event_view), GDK_BUTTON1_MASK, gte, 1, GDK_ACTION_COPY); g_signal_connect(G_OBJECT(event_view), "drag-data-get", G_CALLBACK(drag_data_get_cb), tree_list); return event_view; }
static void build_sources_view (GdictPrefDialog *dialog) { GtkTreeViewColumn *column; GtkCellRenderer *renderer; if (dialog->sources_list) return; dialog->sources_list = gtk_list_store_new (SOURCES_N_COLUMNS, G_TYPE_BOOLEAN, /* active */ G_TYPE_STRING, /* name */ G_TYPE_STRING /* description */); gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (dialog->sources_list), SOURCES_DESCRIPTION_COLUMN, GTK_SORT_ASCENDING); renderer = gtk_cell_renderer_toggle_new (); gtk_cell_renderer_toggle_set_radio (GTK_CELL_RENDERER_TOGGLE (renderer), TRUE); g_signal_connect (renderer, "toggled", G_CALLBACK (source_renderer_toggled_cb), dialog); column = gtk_tree_view_column_new_with_attributes ("active", renderer, "active", SOURCES_ACTIVE_COLUMN, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (dialog->sources_view), column); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("description", renderer, "text", SOURCES_DESCRIPTION_COLUMN, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (dialog->sources_view), column); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (dialog->sources_view), FALSE); gtk_tree_view_set_model (GTK_TREE_VIEW (dialog->sources_view), GTK_TREE_MODEL (dialog->sources_list)); g_signal_connect (dialog->sources_view, "row-activated", G_CALLBACK (sources_view_row_activated_cb), dialog); }
// Create the Tree View GtkWidget* ShaderSelector::createTreeView() { // Tree model GtkTreeStore* store = gtk_tree_store_new(N_COLUMNS, G_TYPE_STRING, // display name in tree G_TYPE_STRING, // full shader name GDK_TYPE_PIXBUF); // Instantiate the helper class that populates the tree according to the paths gtkutil::VFSTreePopulator populator(store); ShaderNameVisitor func(populator, _prefixes); GlobalShaderSystem().foreachShaderName(func); // Now visit the created GtkTreeIters to load the actual data into the tree DataInserter inserter; populator.forEachNode(inserter); // Tree view _treeView = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store)); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(_treeView), FALSE); g_object_unref(store); // tree view owns the reference now // Single visible column, containing the directory/shader name and the icon gtk_tree_view_append_column(GTK_TREE_VIEW(_treeView), gtkutil::IconTextColumn(_("Value"), NAME_COL, IMAGE_COL)); // Set the tree store to sort on this column gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(store), NAME_COL, GTK_SORT_ASCENDING); // Use the TreeModel's full string search function gtk_tree_view_set_search_equal_func(GTK_TREE_VIEW(_treeView), gtkutil::TreeModel::equalFuncStringContains, NULL, NULL); // Get selection and connect the changed callback _selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(_treeView)); g_signal_connect(G_OBJECT(_selection), "changed", G_CALLBACK(_onSelChange), this); // Pack into scrolled window and frame return gtkutil::ScrolledFrame(_treeView); }
static void phidias_items_classic_set_model (PhidiasItemsViewer *self, GtkTreeModel *items) { GtkTreeModel *sorter; PhidiasItemsClassic *item; item = PHIDIAS_ITEMS_CLASSIC (self); webkit_web_view_load_html_string (WEBKIT_WEB_VIEW (item->priv->description), "", "file://"); sorter = gtk_tree_view_get_model (GTK_TREE_VIEW (item->priv->list)); if (sorter != NULL) g_object_unref (sorter); sorter = gtk_tree_model_sort_new_with_model (items); gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (sorter), ITEM_INFO_DATE, GTK_SORT_DESCENDING); gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (sorter), ITEM_INFO_DATE, sort_items, NULL, NULL); gtk_tree_view_set_model (GTK_TREE_VIEW (item->priv->list), sorter); scroll_to_position (item); }
static void fi_gui_files_sort_save(void) { #if GTK_CHECK_VERSION(2,6,0) if (0 == files_sort_depth++) { GtkTreeSortable *sortable; GtkSortType order; int column; sortable = GTK_TREE_SORTABLE(store_files); if (gtk_tree_sortable_get_sort_column_id(sortable, &column, &order)) { files_sort_column = column; files_sort_order = order; gtk_tree_sortable_set_sort_column_id(sortable, GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID, order); } } #endif /* Gtk+ => 2.6.0 */ }
/** * ephy_node_view_set_sort: * @view: an #EphyNodeView * @value_type: type of the value held at @prop_id by the model * @prop_id: column id in the model * @sort_type: the sort mode * * Adds a sort column to the @view corresponding to @prop_id in the model. **/ void ephy_node_view_set_sort (EphyNodeView *view, GType value_type, guint prop_id, GtkSortType sort_type) { GtkTreeSortable *sortable = GTK_TREE_SORTABLE (view->priv->sortmodel); int column; column = ephy_tree_model_node_add_prop_column (view->priv->nodemodel, value_type, prop_id); view->priv->sort_column = column; view->priv->sort_type = sort_type; gtk_tree_sortable_set_default_sort_func (sortable, (GtkTreeIterCompareFunc)ephy_node_view_sort_func, view, NULL); gtk_tree_sortable_set_sort_column_id (sortable, GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, sort_type); }
void create_user_privileges_table (void) { GtkWidget *list; GtkTreeModel *model, *filter_model; GtkCellRenderer *renderer; GtkTreeViewColumn *column; GtkTreeIter iter; list = gst_dialog_get_widget (tool->main_dialog, "user_privileges"); model = GTK_TREE_MODEL (gtk_list_store_new (3, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_OBJECT)); filter_model = gtk_tree_model_filter_new (model, NULL); gtk_tree_view_set_model (GTK_TREE_VIEW (list), filter_model); g_object_unref (filter_model); g_object_unref (model); gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (model), COL_DESCRIPTION, GTK_SORT_ASCENDING); gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER (filter_model), privileges_table_visible_func, NULL, NULL); column = gtk_tree_view_column_new (); renderer = gtk_cell_renderer_toggle_new (); gtk_tree_view_column_pack_start (column, renderer, FALSE); gtk_tree_view_column_set_attributes (column, renderer, "active", COL_MEMBER, NULL); g_signal_connect (G_OBJECT (renderer), "toggled", G_CALLBACK (on_user_privilege_toggled), filter_model); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_end (column, renderer, TRUE); gtk_tree_view_column_set_attributes (column, renderer, "text", COL_DESCRIPTION, NULL); gtk_tree_view_column_set_sort_column_id (column, 1); gtk_tree_view_insert_column (GTK_TREE_VIEW (list), column, 0); }
static void specific_bug_300089 (void) { /* Test case for GNOME Bugzilla bug 300089. Written by * Matthias Clasen. */ GtkTreeModel *sort_model, *child_model; GtkTreePath *path; GtkTreeIter iter, iter2, sort_iter; g_test_bug ("300089"); child_model = GTK_TREE_MODEL (gtk_tree_store_new (1, G_TYPE_STRING)); gtk_tree_store_append (GTK_TREE_STORE (child_model), &iter, NULL); gtk_tree_store_set (GTK_TREE_STORE (child_model), &iter, 0, "A", -1); gtk_tree_store_append (GTK_TREE_STORE (child_model), &iter, NULL); gtk_tree_store_set (GTK_TREE_STORE (child_model), &iter, 0, "B", -1); gtk_tree_store_append (GTK_TREE_STORE (child_model), &iter2, &iter); gtk_tree_store_set (GTK_TREE_STORE (child_model), &iter2, 0, "D", -1); gtk_tree_store_append (GTK_TREE_STORE (child_model), &iter2, &iter); gtk_tree_store_set (GTK_TREE_STORE (child_model), &iter2, 0, "E", -1); gtk_tree_store_append (GTK_TREE_STORE (child_model), &iter, NULL); gtk_tree_store_set (GTK_TREE_STORE (child_model), &iter, 0, "C", -1); sort_model = GTK_TREE_MODEL (gtk_tree_model_sort_new_with_model (child_model)); gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (sort_model), 0, GTK_SORT_ASCENDING); path = gtk_tree_path_new_from_indices (1, 1, -1); /* make sure a level is constructed */ gtk_tree_model_get_iter (sort_model, &sort_iter, path); /* change the "E" row in a way that causes it to change position */ gtk_tree_model_get_iter (child_model, &iter, path); gtk_tree_store_set (GTK_TREE_STORE (child_model), &iter, 0, "A", -1); gtk_tree_path_free (path); }
static void xkb_layout_chooser_available_language_variants_fill (GtkBuilder * chooser_dialog) { GtkWidget *cbl = CWID ("xkb_languages_available"); GtkWidget *cbv = CWID ("xkb_language_variants_available"); GtkListStore *list_store; GtkTreeIter liter; list_store = gtk_list_store_new (4, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING); if (gtk_combo_box_get_active_iter (GTK_COMBO_BOX (cbl), &liter)) { GtkTreeModel *lm = gtk_combo_box_get_model (GTK_COMBO_BOX (cbl)); gchar *lang_id; AddVariantData data = { list_store, 0 }; /* Now the variants of the selected layout */ gtk_tree_model_get (lm, &liter, COMBO_BOX_MODEL_COL_REAL_ID, &lang_id, -1); data.lang_id = lang_id; xkl_config_registry_foreach_language_variant (config_registry, lang_id, (TwoConfigItemsProcessFunc) xkb_layout_chooser_add_variant_to_available_language_variants, &data); g_free (lang_id); } /* Turn on sorting after filling the store, since that's faster */ gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (list_store), COMBO_BOX_MODEL_COL_SORT, GTK_SORT_ASCENDING); gtk_combo_box_set_model (GTK_COMBO_BOX (cbv), GTK_TREE_MODEL (list_store)); gtk_combo_box_set_active (GTK_COMBO_BOX (cbv), 0); }
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 goa_panel_accounts_model_constructed (GObject *object) { GoaPanelAccountsModel *model = GOA_PANEL_ACCOUNTS_MODEL (object); GType types[GOA_PANEL_ACCOUNTS_MODEL_N_COLUMNS]; G_STATIC_ASSERT (5 == GOA_PANEL_ACCOUNTS_MODEL_N_COLUMNS); types[0] = G_TYPE_STRING; types[1] = GOA_TYPE_OBJECT; types[2] = G_TYPE_BOOLEAN; types[3] = G_TYPE_STRING; types[4] = G_TYPE_ICON; gtk_list_store_set_column_types (GTK_LIST_STORE (model), GOA_PANEL_ACCOUNTS_MODEL_N_COLUMNS, types); gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (model), GOA_PANEL_ACCOUNTS_MODEL_COLUMN_SORT_KEY, GTK_SORT_ASCENDING); g_signal_connect (model->client, "account-added", G_CALLBACK (on_account_added), model); g_signal_connect (model->client, "account-removed", G_CALLBACK (on_account_removed), model); g_signal_connect (model->client, "account-changed", G_CALLBACK (on_account_changed), model); init_model (model); if (G_OBJECT_CLASS (goa_panel_accounts_model_parent_class)->constructed != NULL) G_OBJECT_CLASS (goa_panel_accounts_model_parent_class)->constructed (object); }
static void go_component_mime_dialog_init (GOComponentMimeDialog *dlg) { GtkListStore *list = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_STRING); GtkWidget *w = gtk_tree_view_new_with_model (GTK_TREE_MODEL (list)); GtkCellRenderer *renderer; GtkTreeViewColumn *column; GSList *mime_types = go_components_get_mime_types (); GSList *l = mime_types; GtkTreeIter iter; char const *mime_type; gtk_dialog_add_buttons (&dlg->base, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_window_set_modal (GTK_WINDOW (dlg), TRUE); gtk_window_set_destroy_with_parent (GTK_WINDOW (dlg), TRUE); dlg->sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (w)); g_signal_connect_swapped (w, "button-press-event", G_CALLBACK (button_press_cb), dlg); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Object type:", renderer, "text", 0, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (w), column); gtk_tree_selection_set_mode (dlg->sel, GTK_SELECTION_BROWSE); gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (list), 0, GTK_SORT_ASCENDING); while (l) { mime_type = (char const *) l->data; if (go_components_get_priority (mime_type) >= GO_MIME_PRIORITY_PARTIAL) { gtk_list_store_append (list, &iter); gtk_list_store_set (list, &iter, 0, go_mime_type_get_description (mime_type), 1, mime_type, -1); } l = l->next; } dlg->list = GTK_TREE_MODEL (list); gtk_container_add (GTK_CONTAINER (gtk_dialog_get_content_area (&dlg->base)), w); gtk_widget_show_all (gtk_dialog_get_content_area (&dlg->base)); }