static VALUE rg_set_cell_data_func(VALUE self, VALUE renderer) { volatile VALUE func = rb_block_proc(); G_RELATIVE(self, func); G_RELATIVE(renderer, func); gtk_tree_view_column_set_cell_data_func(_SELF(self), RVAL2CELLRENDERER(renderer), (GtkTreeCellDataFunc)cell_data_func, (gpointer)func, NULL); return self; }
GtkTreeViewColumn *add_vector_to_dialog (vector_table_options_D *dialog, VectorTable *pvt, int idx) { GList *llItr = NULL, *llCols = NULL ; GtkTreeViewColumn *col = NULL ; GtkCellRenderer *cr = NULL ; int idxCol = (-1 == idx ? idx : idx + 2) ; int idxVector = (-1 == idx ? pvt->vectors->icUsed - 1 : idx) ; char *psz = NULL ; int Nix, new_idx = -1 ; if (idx >= 0) { // Move to the first vector column if (NULL != (llCols = llItr = gtk_tree_view_get_columns (GTK_TREE_VIEW (dialog->tv)))) { if (NULL != (llItr = llItr->next)) llItr = llItr->next ; // Increment the indices for all vector columns following the new one. for (Nix = 0 ; llItr != NULL ; llItr = llItr->next, Nix++) if (Nix >= idx) if (NULL != (cr = g_object_get_data (G_OBJECT (llItr->data), "cr"))) { g_object_set_data (G_OBJECT (cr), "idxVector", (gpointer)(new_idx = (int)g_object_get_data (G_OBJECT (cr), "idxVector") + 1)) ; gtk_tree_view_column_set_title (GTK_TREE_VIEW_COLUMN (llItr->data), psz = g_strdup_printf ("%d", new_idx)) ; g_free (psz) ; } g_list_free (llCols) ; } } gtk_tree_view_insert_column (GTK_TREE_VIEW (dialog->tv), col = gtk_tree_view_column_new (), idxCol) ; gtk_tree_view_column_set_title (col, psz = g_strdup_printf ("%d", idxVector)) ; g_free (psz) ; gtk_tree_view_column_pack_start (col, cr = qcad_cell_renderer_vt_new (), FALSE) ; g_object_set (G_OBJECT (cr), "cell-background-gdk", &((gtk_widget_get_style (dialog->tv))->base[3]), "cell-background-set", FALSE, "editable", TRUE, NULL) ; gtk_tree_view_column_add_attribute (col, cr, "row-type", BUS_LAYOUT_MODEL_COLUMN_TYPE) ; gtk_tree_view_column_add_attribute (col, cr, "sensitive", VECTOR_TABLE_MODEL_COLUMN_ACTIVE) ; gtk_tree_view_column_set_clickable (col, TRUE) ; g_object_set_data (G_OBJECT (cr), "idxVector", (gpointer)idxVector) ; g_object_set_data (G_OBJECT (cr), "pvt", pvt) ; gtk_tree_view_column_set_cell_data_func (col, cr, vector_data_func, pvt, NULL) ; g_object_set_data (G_OBJECT (col), "cr", cr) ; g_object_set_data (G_OBJECT (cr), "col", col) ; g_signal_connect (G_OBJECT (col), "clicked", (GCallback)vector_column_clicked, dialog) ; g_signal_connect (G_OBJECT (cr), "clicked", (GCallback)vector_column_clicked, dialog) ; g_signal_connect (G_OBJECT (cr), "edited", (GCallback)vector_value_edited, dialog->tv) ; g_signal_connect (G_OBJECT (cr), "editing-started", (GCallback)vector_value_editing_started, dialog) ; return col ; }
/* * create env tree view and return a widget */ GtkWidget* envtree_init(void) { GtkCellRenderer *renderer; GtkTreeViewColumn *column; GtkTreeSelection *selection; /* (re)initialize globals in case plugin was reloaded but those not cleared */ page_read_only = FALSE; entering_new_var = FALSE; empty_row = NULL; being_edited_value = NULL; store = gtk_list_store_new ( N_COLUMNS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING); model = GTK_TREE_MODEL(store); tree = gtk_tree_view_new_with_model (model); g_object_unref(store); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(tree), TRUE); g_signal_connect(G_OBJECT(tree), "key-press-event", G_CALLBACK (on_envtree_keypressed), NULL); 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 = gtk_tree_view_column_new_with_attributes (_("Name"), renderer_name, "text", NAME, NULL); gtk_tree_view_column_set_resizable (column_name, TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column_name); renderer_value = gtk_cell_renderer_text_new (); column_value = gtk_tree_view_column_new_with_attributes (_("Value"), renderer_value, "text", VALUE, NULL); 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_column_set_resizable (column_value, TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column_value); /* Last invisible column */ renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("", renderer, "text", LAST_VISIBLE, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column); /* add empty row */ add_empty_row(); /* set multiple selection */ selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree)); gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE); return tree; }
static void aw_system_view_create_columns (AwTreeView *view) { GtkCellRenderer *cell; /* === title column === */ cell = gtk_cell_renderer_text_new (); gtk_tree_view_column_set_cell_data_func (aw_tree_view_append_primary_column (view, cell), cell, aw_system_view_title_cell_cb, NULL, NULL); /* === detail column === */ cell = gtk_cell_renderer_text_new (); gtk_tree_view_column_set_cell_data_func (aw_tree_view_append_secondary_column (view, cell), cell, aw_system_view_detail_cell_cb, NULL, NULL); }
void treeview2_set_up_news(GtkTreeView *treeview) { #ifdef DEBUG printf("treeview2_set_up_news\n"); #endif GtkTreeViewColumn *col; GtkCellRenderer *renderer; gint i; gtk_tree_selection_set_mode(gtk_tree_view_get_selection(treeview), GTK_SELECTION_NONE); gtk_tree_view_set_headers_visible(treeview, FALSE); gtk_tree_view_set_rules_hint(treeview, FALSE); for(i = 0; i < 3; i++) { col = gtk_tree_view_column_new(); gtk_tree_view_append_column(treeview, col); renderer = treeview_helper_cell_renderer_text_new(); gtk_tree_view_column_pack_start(col, renderer, TRUE); if(i == 0) gtk_tree_view_column_add_attribute(col, renderer, "markup", 0); else if(i == 1) gtk_tree_view_column_set_cell_data_func(col, renderer, treeview_helper_news, NULL, NULL); else gtk_tree_view_column_set_cell_data_func(col, renderer, treeview_helper_news_additional, NULL, NULL); g_object_set(renderer, "wrap-mode", PANGO_WRAP_WORD, NULL); g_object_set(renderer, "wrap-width", 400, NULL); g_object_set(renderer, "yalign", 0.0, NULL); } }
static void createTab(char *name) { logInfo("Creating IRC console tab '%s'", name); char *dupname = strdup(name); // vertical layout GtkWidget *vLayout = gtk_vbox_new(false, 1); // scroll GtkWidget *scroll = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_container_add(GTK_CONTAINER(vLayout), GTK_WIDGET(scroll)); GtkWidget *input = gtk_entry_new(); GtkRcStyle *style = gtk_widget_get_modifier_style(GTK_WIDGET(input)); PangoFontDescription *font = pango_font_description_from_string("Monospace Normal"); style->font_desc = font; gtk_widget_modify_style(GTK_WIDGET(input), style); gtk_container_add(GTK_CONTAINER(vLayout), GTK_WIDGET(input)); g_signal_connect(GTK_OBJECT(input), "activate", GTK_SIGNAL_FUNC(inputActivate), dupname); gtk_box_set_child_packing(GTK_BOX(vLayout), GTK_WIDGET(input), false, true, 0, GTK_PACK_END); // list GtkWidget *list = gtk_tree_view_new(); gtk_container_add(GTK_CONTAINER(scroll), GTK_WIDGET(list)); // list columns gtk_tree_view_append_column(GTK_TREE_VIEW(list), gtk_tree_view_column_new_with_attributes("Timestamp", gtk_cell_renderer_text_new(), "text", ROW_TIME, NULL)); GtkCellRenderer *renderer = gtk_cell_renderer_text_new(); GtkTreeViewColumn *column = gtk_tree_view_column_new_with_attributes("Message", renderer, "text", ROW_MESSAGE, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(list), column); gtk_tree_view_column_set_cell_data_func(column, renderer, &formatMessageCell, NULL, NULL); // create store GtkListStore *store = gtk_list_store_new(N_ROWS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT); gtk_tree_view_set_model(GTK_TREE_VIEW(list), GTK_TREE_MODEL(store)); GtkWidget *title = gtk_label_new(name); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), GTK_WIDGET(vLayout), GTK_WIDGET(title)); IrcConsoleTab *tab = ALLOCATE_OBJECT(IrcConsoleTab); g_object_ref(G_OBJECT(list)); tab->lines = 0; tab->list = list; tab->store = store; g_hash_table_insert(tabs, dupname, tab); gtk_widget_show_all(GTK_WIDGET(notebook)); }
static GtkTreeView* ug_selector_view_new (const gchar* title, gboolean active_toggled) { GtkTreeView* view; GtkCellRenderer* renderer; GtkTreeViewColumn* column; view = (GtkTreeView*) gtk_tree_view_new (); // gtk_tree_view_set_fixed_height_mode (view, TRUE); // UgSelectorItem.mark renderer = gtk_cell_renderer_toggle_new (); column = gtk_tree_view_column_new (); gtk_tree_view_column_set_title (column, "M"); gtk_tree_view_column_pack_start (column, renderer, TRUE); gtk_tree_view_column_set_cell_data_func (column, renderer, col_set_toggle, NULL, NULL); gtk_tree_view_column_set_resizable (column, FALSE); gtk_tree_view_column_set_alignment (column, 0.5); gtk_tree_view_column_set_min_width (column, 15); // gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_append_column (view, column); if (active_toggled) { g_signal_connect (renderer, "toggled", G_CALLBACK (on_cell_toggled), view); } // UgSelectorItem.uri renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new (); gtk_tree_view_column_set_title (column, title); gtk_tree_view_column_pack_start (column, renderer, TRUE); gtk_tree_view_column_set_cell_data_func (column, renderer, col_set_uri, NULL, NULL); gtk_tree_view_column_set_resizable (column, TRUE); // gtk_tree_view_column_set_expand (column, TRUE); // gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_append_column (view, column); gtk_widget_show (GTK_WIDGET (view)); return view; }
static void gitg_window_parser_finished(GtkBuildable *buildable, GtkBuilder *builder) { if (parent_iface.parser_finished) parent_iface.parser_finished(buildable, builder); // Store widgets GitgWindow *window = GITG_WINDOW(buildable); window->priv->vpaned_main = GTK_WIDGET(gtk_builder_get_object(builder, "vpaned_main")); window->priv->hpaned_commit = GTK_WIDGET(gtk_builder_get_object(builder, "hpaned_commit")); window->priv->vpaned_commit = GTK_WIDGET(gtk_builder_get_object(builder, "vpaned_commit")); window->priv->notebook_main = GTK_NOTEBOOK(gtk_builder_get_object(builder, "notebook_main")); window->priv->tree_view = GTK_TREE_VIEW(gtk_builder_get_object(builder, "tree_view_rv")); window->priv->statusbar = GTK_STATUSBAR(gtk_builder_get_object(builder, "statusbar")); window->priv->revision_view = GITG_REVISION_VIEW(gtk_builder_get_object(builder, "revision_view")); window->priv->revision_tree_view = GITG_REVISION_TREE_VIEW(gtk_builder_get_object(builder, "revision_tree_view")); window->priv->commit_view = GITG_COMMIT_VIEW(gtk_builder_get_object(builder, "hpaned_commit")); restore_state(window); window->priv->edit_group = GTK_ACTION_GROUP(gtk_builder_get_object(builder, "action_group_menu_edit")); GtkTreeViewColumn *col = GTK_TREE_VIEW_COLUMN(gtk_builder_get_object(builder, "rv_column_subject")); window->priv->renderer_path = GITG_CELL_RENDERER_PATH(gtk_builder_get_object(builder, "rv_renderer_subject")); gtk_tree_view_column_set_cell_data_func(col, GTK_CELL_RENDERER(window->priv->renderer_path), (GtkTreeCellDataFunc)on_renderer_path, window, NULL); GtkRecentFilter *filter = gtk_recent_filter_new(); gtk_recent_filter_add_group(filter, "gitg"); GtkRecentChooser *chooser = GTK_RECENT_CHOOSER(gtk_builder_get_object(builder, "RecentOpenAction")); gtk_recent_chooser_add_filter(chooser, filter); // Intialize branches build_branches_combo(window, builder); // Create search entry build_search_entry(window, builder); gtk_builder_connect_signals(builder, window); // Connect signals GtkTreeSelection *selection = gtk_tree_view_get_selection(window->priv->tree_view); g_signal_connect(selection, "changed", G_CALLBACK(on_selection_changed), window); g_signal_connect(window->priv->revision_view, "parent-activated", G_CALLBACK(on_parent_activated), window); g_signal_connect(window->priv->tree_view, "motion-notify-event", G_CALLBACK(on_tree_view_motion), window); g_signal_connect(window->priv->tree_view, "button-release-event", G_CALLBACK(on_tree_view_button_release), window); }
GtkWidget *hview_get_domain_window(HviewWidgetsT *w) { GtkWidget *window; GtkCellRenderer *renderer; GtkTreeViewColumn *col; window = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_widget_set_size_request(GTK_WIDGET(window), 175, HVIEW_TREE_WINDOW_HEIGHT); w->domain_view = gtk_tree_view_new(); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW( w->domain_view), VOH_LIST_COLUMN_NAME, HVIEW_DOMAIN_COLUMN_TITLE, renderer, "text", VOH_LIST_COLUMN_NAME, NULL); col = gtk_tree_view_get_column(GTK_TREE_VIEW(w->domain_view), VOH_LIST_COLUMN_NAME); gtk_tree_view_column_set_cell_data_func(col, renderer, hview_tree_cell_func, NULL, NULL); renderer = gtk_cell_renderer_pixbuf_new(); gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW( w->domain_view), VOH_LIST_COLUMN_ICON, NULL, renderer, "pixbuf", VOH_LIST_COLUMN_ICON, NULL); col = gtk_tree_view_get_column(GTK_TREE_VIEW(w->domain_view), VOH_LIST_COLUMN_ICON); g_signal_connect(G_OBJECT(w->domain_view), "row-activated", G_CALLBACK(hview_domain_row_activated_call), (gpointer) w); gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(window), w->domain_view); return window; }
static void update_toggle_renderers (EmpathyIndividualLinker *self) { EmpathyIndividualLinkerPriv *priv = GET_PRIV (self); /* Re-setting the cell data func to the same function causes a refresh of the * entire column, ensuring that each toggle button is correctly active or * inactive. This is necessary because one Individual might appear multiple * times in the list (in different groups), so toggling one instance of the * Individual should toggle all of them. */ gtk_tree_view_column_set_cell_data_func (priv->toggle_column, priv->toggle_renderer, (GtkTreeCellDataFunc) contact_toggle_cell_data_func, self, NULL); }
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)); }
/* Add three columns to the GtkTreeView. All three of the columns will be * displayed as text, although one is a gboolean value and another is * an integer. */ static void setup_tree_view (GtkWidget *treeview) { GtkCellRenderer *renderer; GtkTreeViewColumn *column; renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Standard Colors", renderer, "text", COLOR, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column); gtk_tree_view_column_set_cell_data_func (column, renderer, cell_data_func, NULL, NULL); }
static GtkCellRenderer *set_col_func( GtkTreeView *view, int col_id, GtkTreeCellDataFunc fn, gpointer dataptr, GDestroyNotify destroyfn) { GtkTreeViewColumn *col = gtk_tree_view_get_column(view, col_id); GList *rs_list = gtk_cell_layout_get_cells(GTK_CELL_LAYOUT(col)); if(rs_list == NULL) return NULL; GtkCellRenderer *r = GTK_CELL_RENDERER(g_list_first(rs_list)->data); g_list_free(rs_list); gtk_tree_view_column_set_cell_data_func(col, r, fn, dataptr, destroyfn); return g_object_ref(r); }
static GtkTreeViewColumn * add_column( GtkTreeView *tv, const gchar *name, gint id, gfloat xalign, GtkTreeCellDataFunc cell_data_func, gint fg_col, gint bg_col) { GtkTreeViewColumn *column; GtkCellRenderer *renderer; renderer = create_cell_renderer(xalign); g_object_set(G_OBJECT(renderer), "foreground-set", TRUE, "background-set", TRUE, (void *) 0); if (cell_data_func) { column = gtk_tree_view_column_new_with_attributes(name, renderer, (void *) 0); gtk_tree_view_column_set_cell_data_func(column, renderer, cell_data_func, GUINT_TO_POINTER(id), NULL); } else { column = gtk_tree_view_column_new_with_attributes(name, renderer, "text", id, (void *) 0); } if (fg_col >= 0) gtk_tree_view_column_add_attribute(column, renderer, "foreground-gdk", fg_col); if (bg_col >= 0) gtk_tree_view_column_add_attribute(column, renderer, "background-gdk", bg_col); g_object_set(column, "fixed-width", 100, "min-width", 1, "reorderable", FALSE, "resizable", TRUE, "sizing", GTK_TREE_VIEW_COLUMN_FIXED, (void *) 0); gtk_tree_view_append_column(tv, column); return column; }
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 GtkTreeViewColumn * create_column(int column_id, const char *title, gfloat xalign, GtkCellRenderer *renderer, GtkTreeCellDataFunc cell_data_func) { GtkTreeViewColumn *column; if (!renderer) { renderer = create_text_cell_renderer(xalign); } column = gtk_tree_view_column_new_with_attributes(title, renderer, (void *) 0); gtk_tree_view_column_set_cell_data_func(column, renderer, cell_data_func, uint_to_pointer(column_id), NULL); return column; }
static void create_view_and_model() { GtkTreeViewColumn *col; GtkCellRenderer *renderer; bdk_window.view = gtk_tree_view_new(); gtk_tree_view_set_enable_tree_lines(GTK_TREE_VIEW(bdk_window.view), TRUE); col = gtk_tree_view_column_new(); gtk_tree_view_column_set_title(col, "Variable"); gtk_tree_view_append_column(GTK_TREE_VIEW(bdk_window.view), 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", COL_VARIABLE); /* Columm #2 */ col = gtk_tree_view_column_new(); gtk_tree_view_column_set_title(col, "Value"); gtk_tree_view_append_column(GTK_TREE_VIEW(bdk_window.view), 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", COL_VALUE); gtk_tree_view_column_set_cell_data_func(col, renderer, age_cell_data_func, NULL, NULL); create_and_fill_model(); gtk_tree_view_set_model(GTK_TREE_VIEW(bdk_window.view), bdk_window.model); g_object_unref(bdk_window.model); gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(bdk_window.view)), GTK_SELECTION_NONE); g_signal_connect(bdk_window.view, "row-activated", (GCallback) view_onRowActivated, NULL); }
GtkWidget *sigview_init(void) { GtkWidget *sw, *tv; GtkTreeViewColumn *col; GtkCellRenderer *cel; sw = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_ALWAYS, GTK_POLICY_AUTOMATIC); tv = gtk_tree_view_new(); gtk_container_add(GTK_CONTAINER(sw), tv); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(tv), FALSE); g_object_set(G_OBJECT(tv), "reorderable", TRUE, NULL); col = gtk_tree_view_column_new_with_attributes(NULL, gtk_cell_renderer_text_new(), "text", 0, "foreground", 1, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(tv), col); cel = gtk_cell_renderer_signal_new(); g_object_set(G_OBJECT(cel), "ypad", 1, NULL); g_signal_connect(tv, "scroll-event", G_CALLBACK(do_scroll_event), cel); g_signal_connect(tv, "button-press-event", G_CALLBACK(do_button_event), cel); g_signal_connect(tv, "button-release-event", G_CALLBACK(do_button_event), cel); col = gtk_tree_view_column_new(); g_object_set_data(G_OBJECT(tv), "signalcol", col); g_object_set_data(G_OBJECT(tv), "signalcel", cel); gtk_tree_view_column_pack_start(col, cel, TRUE); gtk_tree_view_column_set_cell_data_func(col, cel, format_func, NULL, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(tv), col); g_signal_connect_swapped(col, "notify::width", G_CALLBACK(col_resized), tv); siglist = gtk_list_store_new(3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT); gtk_tree_view_set_model(GTK_TREE_VIEW(tv), GTK_TREE_MODEL(siglist)); GtkObject *pan = gtk_adjustment_new(0, 0, 0, 1, 1, 1); g_object_set_data(G_OBJECT(tv), "hadj", pan); gtk_range_set_adjustment(GTK_RANGE(GTK_SCROLLED_WINDOW(sw)->hscrollbar), GTK_ADJUSTMENT(pan)); g_signal_connect(pan, "value-changed", G_CALLBACK(pan_changed), tv); return sw; }
static inline void gwy_graph_data_pack_renderer(GwyGraphData *graph_data, GtkTreeViewColumn *column, gint id) { GtkCellRenderer *renderer; renderer = gtk_cell_renderer_text_new(); gtk_cell_renderer_text_set_fixed_height_from_font (GTK_CELL_RENDERER_TEXT(renderer), 1); g_object_set(renderer, "xalign", 1.0, NULL); if (id) g_object_set_qdata(G_OBJECT(renderer), quark_id, GINT_TO_POINTER(id)); gtk_tree_view_column_pack_start(column, renderer, TRUE); gtk_tree_view_column_set_cell_data_func(column, renderer, render_data, graph_data, NULL); }
GtkWidget* create_hotkey_editor(void) { GtkWidget *hotkey_tree_view = NULL; GtkCellRenderer *renderer = NULL; GtkListStore *model = NULL; GtkTreeViewColumn *column = NULL; GtkTreeIter iter = {0}; /* create a tree view */ hotkey_tree_view = gtk_tree_view_new(); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(hotkey_tree_view), FALSE); g_signal_connect (hotkey_tree_view, "button-press-event", G_CALLBACK (start_editing_cb), NULL); g_signal_connect (hotkey_tree_view, "row-activated", G_CALLBACK (start_editing_keybd_cb), NULL); g_object_set(hotkey_tree_view, "visible", TRUE, NULL); /* create the Egg Cell Renderer and connect to signals */ renderer = (GtkCellRenderer*) gtk_cell_renderer_accel_new (); g_object_set(renderer, "editable", TRUE, NULL); g_signal_connect (renderer, "accel-edited", G_CALLBACK (accel_edited_callback), hotkey_tree_view); g_signal_connect (renderer, "accel-cleared", G_CALLBACK (accel_cleared_callback), hotkey_tree_view); /* create a column and set the created renderer - append the same to the tree view */ column = gtk_tree_view_column_new_with_attributes ("Shortcut", renderer, NULL); /* since it's a custom renderer, setting the data to the cell needs to be custom as well */ gtk_tree_view_column_set_cell_data_func (column, renderer, accel_set_func, NULL, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW(hotkey_tree_view), column); /* create the list store for the tree */ model = gtk_list_store_new (1, G_TYPE_POINTER); gtk_tree_view_set_model (GTK_TREE_VIEW (hotkey_tree_view), GTK_TREE_MODEL(model)); gtk_list_store_append (model, &iter); gtk_list_store_set (model, &iter, HOTKEY_COLUMN, &app_hotkey, -1); /* The tree view has acquired its own reference to the * model, so we can drop ours. That way the model will * be freed automatically when the tree view is destroyed */ g_object_unref (model); g_object_set(hotkey_tree_view, "visible", TRUE, NULL); return hotkey_tree_view; }
/* * Init book section view * Called from copy_entry in entry.c * Called from move_entry in entry.c */ static gboolean init_book_section_view(GtkTreeView *section_view) { GtkTreeViewColumn *view_col = NULL; GtkCellRenderer *cell_rend = NULL; // Create section column view_col = gtk_tree_view_column_new(); gtk_tree_view_column_set_title(view_col, "Section"); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(section_view), FALSE); gtk_tree_view_append_column(GTK_TREE_VIEW(section_view), view_col); // Create section cell_rend with get_book_section_name callback cell_rend = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(view_col, cell_rend, TRUE); gtk_tree_view_column_set_cell_data_func (view_col, cell_rend, get_book_section_name, NULL, NULL); return TRUE; } // Init book section view
GtkTreeViewColumn *tree_view_column(GtkWidget *tree_view, int index, const char *title, data_func_t data_func, unsigned int flags) { GtkCellRenderer *renderer; GtkTreeViewColumn *col; double xalign = 0.0; /* left as default */ PangoAlignment align; gboolean visible; align = (flags & ALIGN_LEFT) ? PANGO_ALIGN_LEFT : (flags & ALIGN_RIGHT) ? PANGO_ALIGN_RIGHT : PANGO_ALIGN_CENTER; visible = !(flags & INVISIBLE); renderer = gtk_cell_renderer_text_new(); col = gtk_tree_view_column_new(); gtk_tree_view_column_set_title(col, title); if (!(flags & UNSORTABLE)) gtk_tree_view_column_set_sort_column_id(col, index); gtk_tree_view_column_set_resizable(col, TRUE); gtk_tree_view_column_pack_start(col, renderer, TRUE); if (data_func) gtk_tree_view_column_set_cell_data_func(col, renderer, data_func, (void *)(long)index, NULL); else gtk_tree_view_column_add_attribute(col, renderer, "text", index); gtk_object_set(GTK_OBJECT(renderer), "alignment", align, NULL); switch (align) { case PANGO_ALIGN_LEFT: xalign = 0.0; break; case PANGO_ALIGN_CENTER: xalign = 0.5; break; case PANGO_ALIGN_RIGHT: xalign = 1.0; break; } gtk_cell_renderer_set_alignment(GTK_CELL_RENDERER(renderer), xalign, 0.5); gtk_tree_view_column_set_visible(col, visible); gtk_tree_view_append_column(GTK_TREE_VIEW(tree_view), col); return col; }
void EntityList_constructWindow(GtkWindow* main_window) { ASSERT_MESSAGE(getEntityList().m_window == 0, "error"); GtkWindow* window = create_persistent_floating_window("Entity List", main_window); gtk_window_add_accel_group(window, global_accel); getEntityList().m_positionTracker.connect(window); getEntityList().m_window = window; { GtkScrolledWindow* scr = create_scrolled_window(GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_container_add(GTK_CONTAINER(window), GTK_WIDGET(scr)); { GtkWidget* view = gtk_tree_view_new(); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(view), FALSE); GtkCellRenderer* renderer = gtk_cell_renderer_text_new(); GtkTreeViewColumn* column = gtk_tree_view_column_new(); gtk_tree_view_column_pack_start(column, renderer, TRUE); gtk_tree_view_column_set_cell_data_func(column, renderer, entitylist_treeviewcolumn_celldatafunc, 0, 0); GtkTreeSelection* select = gtk_tree_view_get_selection (GTK_TREE_VIEW(view)); gtk_tree_selection_set_mode(select, GTK_SELECTION_MULTIPLE); g_signal_connect(G_OBJECT(view), "row_expanded", G_CALLBACK(entitylist_treeview_row_expanded), 0); g_signal_connect(G_OBJECT(view), "row_collapsed", G_CALLBACK(entitylist_treeview_rowcollapsed), 0); gtk_tree_view_append_column (GTK_TREE_VIEW (view), column); gtk_widget_show(view); gtk_container_add (GTK_CONTAINER(scr), view); getEntityList().m_tree_view = GTK_TREE_VIEW(view); } } EntityList_ConnectSignals(getEntityList().m_tree_view); AttachEntityTreeModel(); }
GtkWidget *hview_get_detail_window(HviewWidgetsT *w, gint page) { GtkWidget *window; GtkCellRenderer *renderer; GtkTreeViewColumn *col; GtkWidget *view; window = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); // gtk_widget_set_size_request(GTK_WIDGET(window), // HVIEW_DETAIL_WINDOW_WIDTH, // HVIEW_DETAIL_WINDOW_HEIGHT); w->tab_views[page].detail_view = view = gtk_tree_view_new(); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(view), FALSE); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(view), -1, NULL, renderer, "text", 0, NULL); col = gtk_tree_view_get_column(GTK_TREE_VIEW(view), 0); gtk_tree_view_column_set_cell_data_func(col, renderer, hview_detail_cell_func, NULL, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(view), -1, NULL, renderer, "text", 1, NULL); gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(window), view); return window; }
/** * Add a column to the GtkTreeView. * * This function adds a column to the treeview. * * @param tree The GtkTreeView which will have a new column appended. * @param column_id The numerical tag for this column. * @param title The title displayed in the column header. * @param xalign A number between 0.0 (left) and 1.0 (right) * horizontal alignment. * @param cell_data_func The function which will render that data * to show in the cell. If, NULL gtk will try to render the data * as appropriate for the type. * */ static void add_column( GtkTreeView *tv, gint column_id, const gchar *title, gfloat xalign, GtkTreeIterCompareFunc sortfunc, GtkTreeCellDataFunc cell_data_func) { GtkTreeViewColumn *column; GtkCellRenderer *renderer; g_assert(column_id >= 0); g_assert(column_id <= c_us_num); g_assert(tv); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes(title, renderer, (void *) 0); gtk_tree_view_column_set_cell_data_func(column, renderer, cell_data_func, GINT_TO_POINTER(column_id), NULL); g_object_set(renderer, "xalign", xalign, "xpad", GUI_CELL_RENDERER_XPAD, "ypad", GUI_CELL_RENDERER_YPAD, (void *) 0); g_object_set(column, "fixed-width", 1, "min-width", 1, "resizable", TRUE, "reorderable", TRUE, "sizing", GTK_TREE_VIEW_COLUMN_FIXED, (void *) 0); gtk_tree_view_column_set_sort_column_id(column, column_id); gtk_tree_view_append_column(GTK_TREE_VIEW(tv), column); gtk_tree_sortable_set_sort_func( GTK_TREE_SORTABLE(gtk_tree_view_get_model(tv)), column_id, sortfunc, NULL, NULL); }
static void create_column(GtkWidget* tree , FxMain* UNUSED(fxmain)) { GtkCellRenderer* renderer; GtkTreeViewColumn *col , *col0; renderer = gtk_cell_renderer_pixbuf_new(); col = gtk_tree_view_column_new(); gtk_tree_view_column_pack_start(col, renderer , FALSE); gtk_tree_view_column_add_attribute(col, renderer, "pixbuf", B_PIXBUF_COL); gtk_tree_view_append_column(GTK_TREE_VIEW(tree), col); renderer = gtk_cell_renderer_text_new(); col0 = gtk_tree_view_column_new(); gtk_tree_view_column_pack_start(col0, renderer , FALSE); gtk_tree_view_column_set_cell_data_func(col0 , renderer , text_cell_data_func , NULL , NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(tree), col0); }
void search_preferences_initialize_setting_treeview(GtkWidget *dialog) { GtkTreeView *view; GtkTreeStore *store; GtkCellRenderer *renderer; GtkTreeViewColumn *column; view = GTK_TREE_VIEW (sr_get_gladewidget(SETTING_PREF_TREEVIEW)->widget); store = gtk_tree_store_new (3, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_BOOLEAN); gtk_tree_view_set_model (view, GTK_TREE_MODEL (store)); gtk_tree_selection_set_mode (gtk_tree_view_get_selection (view), GTK_SELECTION_SINGLE); renderer = gtk_cell_renderer_toggle_new (); column = gtk_tree_view_column_new_with_attributes (_("Default"), renderer, "active", PREF_DEFAULT_COLUMN, NULL); g_signal_connect (renderer, "toggled", G_CALLBACK (on_search_preferences_treeview_enable_toggle), NULL); gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_AUTOSIZE); gtk_tree_view_append_column (view, column); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes (_("Name"), renderer, "text", PREF_NAME_COLUMN, NULL); g_signal_connect (view, "row-activated", G_CALLBACK (on_search_preferences_row_activated), renderer); gtk_tree_view_column_set_cell_data_func (column, renderer, on_search_preferences_colorize_setting, NULL, NULL); gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_AUTOSIZE); gtk_tree_view_append_column (view, column); }
/* sortcolidx == -1 means 'sortcolidx = colidx' */ static void append_col (GtkTreeView * treeview, const char *label, int colidx, int sortcolidx, gint maxwidth) { GtkTreeViewColumn *col; GtkCellRenderer *renderer; renderer = gtk_cell_renderer_text_new (); g_object_set (G_OBJECT (renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL); col = gtk_tree_view_column_new_with_attributes (label, renderer, "text", colidx, NULL); g_object_set (G_OBJECT (col), "resizable", TRUE, NULL); gtk_tree_view_column_set_sort_indicator (col, TRUE); if (sortcolidx == -1) sortcolidx = colidx; gtk_tree_view_column_set_sort_column_id (col, sortcolidx); gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_FIXED); if (maxwidth) { gtk_tree_view_column_set_fixed_width (col, maxwidth); gtk_tree_view_column_set_expand (col, FALSE); } else gtk_tree_view_column_set_expand (col, TRUE); gtk_tree_view_column_set_cell_data_func (col, renderer, (GtkTreeCellDataFunc) treecell_func, NULL, NULL); gtk_tree_view_append_column (treeview, col); gtk_tree_view_columns_autosize (treeview); gtk_tree_view_set_fixed_height_mode (treeview, TRUE); }
static void fx_many_create_all_column(FxMany* fxmany) { GtkCellRenderer* renderer; GtkTreeViewColumn *col , *col1; GtkWidget* tree = fxmany->tree; renderer = gtk_cell_renderer_toggle_new(); g_signal_connect(renderer , "toggled" , G_CALLBACK(fx_many_item_toggled) , fxmany); col = gtk_tree_view_column_new(); gtk_tree_view_column_pack_start(col , renderer , TRUE); gtk_tree_view_column_add_attribute(col, renderer, "active", S_CHECK_COL); gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (col) , GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_fixed_width (GTK_TREE_VIEW_COLUMN (col), 40); gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (col), TRUE); gtk_tree_view_append_column(GTK_TREE_VIEW(tree) , col); renderer = gtk_cell_renderer_pixbuf_new(); GtkTreeViewColumn* col0 = gtk_tree_view_column_new(); gtk_tree_view_column_pack_start(col0, renderer , FALSE); gtk_tree_view_column_add_attribute(col0, renderer, "pixbuf", S_PIXBUF_COL); gtk_tree_view_append_column(GTK_TREE_VIEW(tree), col0); renderer = gtk_cell_renderer_text_new(); col1 = gtk_tree_view_column_new(); gtk_tree_view_column_pack_start(col1, renderer , FALSE); gtk_tree_view_column_set_cell_data_func(col1 , renderer , fx_many_text_cell_data_func , NULL , NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(tree), col1); gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (col) , GTK_TREE_VIEW_COLUMN_FIXED); }
/** * query_favorite_selector_new * * Returns: a new #GtkWidget */ GtkWidget * query_favorite_selector_new (TConnection *tcnc) { QueryFavoriteSelector *tsel; GdaTreeManager *manager; g_return_val_if_fail (T_IS_CONNECTION (tcnc), NULL); tsel = QUERY_FAVORITE_SELECTOR (g_object_new (QUERY_FAVORITE_SELECTOR_TYPE, NULL)); tsel->priv->tcnc = g_object_ref (tcnc); g_signal_connect (t_connection_get_favorites (tsel->priv->tcnc), "favorites-changed", G_CALLBACK (favorites_changed_cb), tsel); /* create tree managers */ tsel->priv->tree = gda_tree_new (); manager = mgr_favorites_new (tcnc, T_FAVORITES_QUERIES, ORDER_KEY_QUERIES); gda_tree_add_manager (tsel->priv->tree, manager); g_object_unref (manager); /* update the tree's contents */ if (! gda_tree_update_all (tsel->priv->tree, NULL)) { 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_resource (GDAUI_BAR (label), "/images/gda-browser-bookmark.png"); 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, 7, G_TYPE_INT, MGR_FAVORITES_POSITION_ATT_NAME, 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, G_TYPE_STRING, MGR_FAVORITES_NAME_ATT_NAME, G_TYPE_STRING, "summary"); treeview = ui_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); g_object_set ((GObject*) renderer, "yalign", 0., NULL); /* text */ renderer = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, renderer, TRUE); gtk_tree_view_column_set_cell_data_func (column, renderer, (GtkTreeCellDataFunc) cell_data_func, NULL, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column); gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED); /* 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); g_signal_connect (G_OBJECT (treeview), "popup-menu", G_CALLBACK (popup_menu_cb), tsel); g_signal_connect (G_OBJECT (treeview), "button-press-event", G_CALLBACK (button_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; }