static void preferences_languages_setup (EmpathyPreferences *preferences) { EmpathyPreferencesPriv *priv = GET_PRIV (preferences); GtkTreeView *view; GtkListStore *store; GtkTreeSelection *selection; GtkTreeViewColumn *column; GtkCellRenderer *renderer; guint col_offset; view = GTK_TREE_VIEW (priv->treeview_spell_checker); store = gtk_list_store_new (COL_LANG_COUNT, G_TYPE_BOOLEAN, /* enabled */ G_TYPE_STRING, /* code */ G_TYPE_STRING); /* name */ gtk_tree_view_set_model (view, GTK_TREE_MODEL (store)); selection = gtk_tree_view_get_selection (view); gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE); renderer = gtk_cell_renderer_toggle_new (); g_signal_connect (renderer, "toggled", G_CALLBACK (preferences_languages_cell_toggled_cb), preferences); column = gtk_tree_view_column_new_with_attributes (NULL, renderer, "active", COL_LANG_ENABLED, NULL); gtk_tree_view_append_column (view, column); renderer = gtk_cell_renderer_text_new (); col_offset = gtk_tree_view_insert_column_with_attributes (view, -1, _("Language"), renderer, "text", COL_LANG_NAME, NULL); g_object_set_data (G_OBJECT (renderer), "column", GINT_TO_POINTER (COL_LANG_NAME)); column = gtk_tree_view_get_column (view, col_offset - 1); gtk_tree_view_column_set_sort_column_id (column, COL_LANG_NAME); gtk_tree_view_column_set_resizable (column, FALSE); gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE); g_object_unref (store); }
void glade_gtk_treeview_set_child_property (GladeWidgetAdaptor * adaptor, GObject * container, GObject * child, const gchar * property_name, const GValue * value) { if (strcmp (property_name, "position") == 0) { gtk_tree_view_remove_column (GTK_TREE_VIEW (container), GTK_TREE_VIEW_COLUMN (child)); gtk_tree_view_insert_column (GTK_TREE_VIEW (container), GTK_TREE_VIEW_COLUMN (child), g_value_get_int (value)); } else /* Chain Up */ GWA_GET_CLASS (GTK_TYPE_CONTAINER)->child_set_property (adaptor, container, child, property_name, value); }
/** * Triggered when user clicks on a column header. Create and pop up a * menu to allow CSV config change. * * \param button Button placed at the title column. * \param ev Not used. * \param no_column Position of the column. * * \return FALSE */ gboolean csv_import_header_on_click ( GtkWidget * button, gint *no_column ) { GtkWidget * menu, * col; col = g_object_get_data ( G_OBJECT ( button ), "column" ); menu = csv_import_fields_menu ( GTK_TREE_VIEW_COLUMN ( col ), GPOINTER_TO_INT ( no_column ), g_object_get_data ( G_OBJECT(col), "assistant" ) ); gtk_menu_popup ( GTK_MENU(menu), NULL, NULL, NULL, NULL, 3, gtk_get_current_event_time()); return FALSE; }
/* Generate the tree view */ GtkWidget * gzrt_wmain_tree_generate ( MAINWIN * c ) { GtkWidget * menu = menu_generate( c ); GtkWidget * tv = gtk_tree_view_new(); GtkListStore * ls = gtk_list_store_new( sizeof(Cols) / sizeof(struct ColumnSpec), G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, -1 ); /* Right click handler */ g_signal_connect(tv, "button-press-event", G_CALLBACK(click_handler), (gpointer)menu); /* Create columns */ for( int i = 0; i < sizeof(Cols) / sizeof(struct ColumnSpec); i++ ) { GtkCellRenderer * r = gtk_cell_renderer_text_new(); GtkTreeViewColumn * col; /* Font? */ if( Cols[i].font ) g_object_set( G_OBJECT(r), "font", FONT, NULL ); gtk_tree_view_insert_column_with_attributes( GTK_TREE_VIEW(tv), -1, Cols[i].title, r, "text", i, NULL ); col = gtk_tree_view_get_column( GTK_TREE_VIEW(tv), i ); gtk_tree_view_column_set_resizable( col, TRUE ); if( i == 1 ) gtk_tree_view_column_set_expand( GTK_TREE_VIEW_COLUMN(col), TRUE ); } /* Generate data */ for( int i = 0; i < z64fs_entries( c->z->fs ); i++ ) { GtkTreeIter j; gtk_list_store_append( GTK_LIST_STORE(ls), &j ); for( int k = 0; k < sizeof(Cols) / sizeof(struct ColumnSpec); k++ ) { char buffer[64]; Cols[k].func( buffer, i, c ); gtk_list_store_set( GTK_LIST_STORE(ls), &j, k, buffer, -1 ); } } /* Set model */ gtk_tree_view_set_model( GTK_TREE_VIEW(tv), GTK_TREE_MODEL(ls) ); /* Return it */ return tv; }
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); }
void init_left_tree(void) { GtkTreeView *view = GTK_TREE_VIEW(tree1_w); GtkCellRenderer *renderer; GtkTreeSelection *sel; GtkTreeViewColumn *column; gtk_tree_view_set_model(view, model1); gtk_tree_view_set_headers_visible(view, TRUE); gtk_tree_view_set_rules_hint(view, FALSE); column = gtk_tree_view_column_new(); gtk_tree_view_append_column(view, column); gtk_tree_view_column_set_title(column, _("Options")); renderer = gtk_cell_renderer_toggle_new(); gtk_tree_view_column_pack_start(GTK_TREE_VIEW_COLUMN(column), renderer, FALSE); gtk_tree_view_column_set_attributes(GTK_TREE_VIEW_COLUMN(column), renderer, "active", COL_BTNACT, "inconsistent", COL_BTNINC, "visible", COL_BTNVIS, "radio", COL_BTNRAD, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(GTK_TREE_VIEW_COLUMN(column), renderer, FALSE); gtk_tree_view_column_set_attributes(GTK_TREE_VIEW_COLUMN(column), renderer, "text", COL_OPTION, "foreground-gdk", COL_COLOR, NULL); sel = gtk_tree_view_get_selection(view); gtk_tree_selection_set_mode(sel, GTK_SELECTION_SINGLE); gtk_widget_realize(tree1_w); }
// Create and bind the tree model to the tree view for the chapter list // Also, connect up the signal that lets us know the selection has changed static void bind_chapter_tree_model(signal_user_data_t *ud) { GtkCellRenderer *cell; GtkTreeViewColumn *column; GtkListStore *treestore; GtkTreeView *treeview; g_debug("bind_chapter_tree_model()\n"); treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "chapters_list")); treestore = gtk_list_store_new(5, G_TYPE_INT, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_BOOLEAN); gtk_tree_view_set_model(treeview, GTK_TREE_MODEL(treestore)); cell = ghb_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes( _("Index"), cell, "text", 0, NULL); gtk_tree_view_append_column(treeview, GTK_TREE_VIEW_COLUMN(column)); cell = ghb_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes( _("Start"), cell, "text", 1, NULL); gtk_tree_view_append_column(treeview, GTK_TREE_VIEW_COLUMN(column)); cell = ghb_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes( _("Duration"), cell, "text", 2, NULL); gtk_tree_view_append_column(treeview, GTK_TREE_VIEW_COLUMN(column)); cell = ghb_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes( _("Title"), cell, "text", 3, "editable", 4, NULL); gtk_tree_view_append_column(treeview, GTK_TREE_VIEW_COLUMN(column)); g_signal_connect(cell, "key-press-event", chapter_keypress_cb, ud); g_signal_connect(cell, "edited", chapter_edited_cb, ud); g_debug("Done\n"); }
static void refresh_log (GitLogPane *self) { Git *plugin; GtkTreeView *log_view; GtkTreeViewColumn *graph_column; plugin = ANJUTA_PLUGIN_GIT (anjuta_dock_pane_get_plugin (ANJUTA_DOCK_PANE (self))); log_view = GTK_TREE_VIEW (gtk_builder_get_object (self->priv->builder, "log_view")); graph_column = GTK_TREE_VIEW_COLUMN (gtk_builder_get_object (self->priv->builder, "graph_column")); /* Unref the previous command if it's still running. */ if (self->priv->log_command) g_object_unref (self->priv->log_command); gtk_tree_view_set_model (log_view, NULL); /* We don't support filters for now */ self->priv->log_command = git_log_command_new (plugin->project_root_directory, self->priv->selected_branch, self->priv->path, NULL, NULL, NULL, NULL, NULL, NULL); /* Hide the graph column if we're looking at the log of a path. The graph * won't be correct in this case. */ if (self->priv->path) gtk_tree_view_column_set_visible (graph_column, FALSE); else gtk_tree_view_column_set_visible (graph_column, TRUE); g_signal_connect_object (G_OBJECT (self->priv->log_command), "command-finished", G_CALLBACK (on_log_command_finished), self, 0); gtk_list_store_clear (self->priv->log_model); /* Show the loading spinner */ git_log_pane_set_view_mode (self, LOG_VIEW_LOADING); anjuta_command_start (ANJUTA_COMMAND (self->priv->log_command)); }
/* Create the list of "messages" */ static GtkWidget *create_list( void ) { GtkWidget *scrolled_window; GtkWidget *tree_view; GtkListStore *model; GtkTreeIter iter; GtkCellRenderer *cell; GtkTreeViewColumn *column; int i; /* Create a new scrolled window, with scrollbars only if needed */ scrolled_window = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); model = gtk_list_store_new (1, G_TYPE_STRING); tree_view = gtk_tree_view_new (); gtk_container_add (GTK_CONTAINER (scrolled_window), tree_view); gtk_tree_view_set_model (GTK_TREE_VIEW (tree_view), GTK_TREE_MODEL (model)); gtk_widget_show (tree_view); /* Add some messages to the window */ for (i = 0; i < 10; i++) { gchar *msg = g_strdup_printf ("Message #%d", i); gtk_list_store_append (GTK_LIST_STORE (model), &iter); gtk_list_store_set (GTK_LIST_STORE (model), &iter, 0, msg, -1); g_free (msg); } cell = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Messages", cell, "text", 0, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), GTK_TREE_VIEW_COLUMN (column)); return scrolled_window; }
/* Technically a list, but if we do go to 80 demos, we may want to move to a tree */ static GtkWidget * create_tree (void) { GtkTreeSelection *selection; GtkCellRenderer *cell; GtkWidget *tree_view; GtkTreeViewColumn *column; GtkTreeStore *model; GtkTreeIter iter; gint i; model = gtk_tree_store_new_with_types (NUM_COLUMNS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER, G_TYPE_BOOLEAN); tree_view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (model)); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)); gtk_tree_selection_set_type (GTK_TREE_SELECTION (selection), GTK_TREE_SELECTION_SINGLE); gtk_widget_set_usize (tree_view, 200, -1); for (i=0; i < G_N_ELEMENTS (testgtk_demos); i++) { gtk_tree_store_append (GTK_TREE_STORE (model), &iter, NULL); gtk_tree_store_set (GTK_TREE_STORE (model), &iter, TITLE_COLUMN, testgtk_demos[i].title, FILENAME_COLUMN, testgtk_demos[i].filename, FUNC_COLUMN, testgtk_demos[i].func, ITALIC_COLUMN, FALSE, -1); } cell = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Widget", cell, "text", TITLE_COLUMN, "italic", ITALIC_COLUMN, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), GTK_TREE_VIEW_COLUMN (column)); g_signal_connect (selection, "selection-changed", selection_cb, model); g_signal_connect (tree_view, "button-press-event", G_CALLBACK (button_press_event_cb), model); return tree_view; }
// Create and bind the tree model to the tree view for the preset list // Also, connect up the signal that lets us know the selection has changed static void bind_presets_tree_model(signal_user_data_t *ud) { GtkCellRenderer *cell; GtkTreeViewColumn *column; GtkTreeStore *treestore; GtkTreeView *treeview; GtkTreeSelection *selection; GtkWidget *widget; GtkTargetEntry SrcEntry; SrcEntry.target = "DATA"; SrcEntry.flags = GTK_TARGET_SAME_WIDGET; g_debug("bind_presets_tree_model()\n"); treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "presets_list")); selection = gtk_tree_view_get_selection(treeview); treestore = gtk_tree_store_new(6, G_TYPE_STRING, G_TYPE_INT, G_TYPE_INT, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_BOOLEAN); gtk_tree_view_set_model(treeview, GTK_TREE_MODEL(treestore)); cell = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes(_("Preset Name"), cell, "text", 0, "weight", 1, "style", 2, "foreground", 3, "editable", 5, NULL); g_signal_connect(cell, "edited", preset_edited_cb, ud); gtk_tree_view_append_column(treeview, GTK_TREE_VIEW_COLUMN(column)); gtk_tree_view_column_set_expand(column, TRUE); gtk_tree_view_set_tooltip_column(treeview, 4); gtk_tree_view_enable_model_drag_dest(treeview, &SrcEntry, 1, GDK_ACTION_MOVE); gtk_tree_view_enable_model_drag_source(treeview, GDK_BUTTON1_MASK, &SrcEntry, 1, GDK_ACTION_MOVE); g_signal_connect(treeview, "drag_data_received", presets_drag_cb, ud); g_signal_connect(treeview, "drag_motion", presets_drag_motion_cb, ud); g_signal_connect(treeview, "row_expanded", presets_row_expanded_cb, ud); g_signal_connect(treeview, "row_collapsed", presets_row_expanded_cb, ud); g_signal_connect(selection, "changed", presets_list_selection_changed_cb, ud); widget = GHB_WIDGET(ud->builder, "presets_remove"); gtk_widget_set_sensitive(widget, FALSE); g_debug("Done\n"); }
/* create a profile list widget */ static GtkWidget* create_profile_list (void) { GtkTreeSelection *selection; GtkCellRenderer *cell; GtkWidget *tree_view; GtkTreeViewColumn *column; GtkListStore *model; model = gtk_list_store_new (COLUMN_LAST, G_TYPE_STRING, G_TYPE_OBJECT); tree_view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (model)); //terminal_util_set_atk_name_description (tree_view, _("Profile list"), NULL); g_object_unref (G_OBJECT (model)); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)); gtk_tree_selection_set_mode (GTK_TREE_SELECTION (selection), GTK_SELECTION_MULTIPLE); refill_profile_treeview (tree_view); cell = gtk_cell_renderer_text_new (); g_object_set (G_OBJECT (cell), "xpad", 2, NULL); column = gtk_tree_view_column_new_with_attributes (NULL, cell, "text", COLUMN_NAME, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), GTK_TREE_VIEW_COLUMN (column)); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (tree_view), FALSE); return tree_view; }
void ListBox::create(Window &parent, unsigned x, unsigned y, unsigned width, unsigned height, const char *text) { listBox->selection = -1; object->widget = gtk_scrolled_window_new(0, 0); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(object->widget), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(object->widget), GTK_SHADOW_ETCHED_IN); gtk_widget_set_size_request(object->widget, width, height); lstring list; list.split("\t", text); GType *v = (GType*)malloc(list.size() * sizeof(GType)); for(unsigned i = 0; i < list.size(); i++) v[i] = G_TYPE_STRING; listBox->store = gtk_list_store_newv(list.size(), v); free(v); object->subWidget = gtk_tree_view_new_with_model(GTK_TREE_MODEL(listBox->store)); gtk_container_add(GTK_CONTAINER(object->widget), object->subWidget); g_object_unref(G_OBJECT(listBox->store)); //alternate color of each row if there is more than one column gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(object->subWidget), list.size() >= 2); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(object->subWidget), false); for(unsigned i = 0; i < list.size(); i++) { listBox->column[i].renderer = gtk_cell_renderer_text_new(); listBox->column[i].column = gtk_tree_view_column_new_with_attributes( list[i], listBox->column[i].renderer, "text", i, (void*)0 ); listBox->column[i].label = gtk_label_new(list[i]); gtk_tree_view_column_set_widget(GTK_TREE_VIEW_COLUMN(listBox->column[i].column), listBox->column[i].label); gtk_tree_view_append_column(GTK_TREE_VIEW(object->subWidget), listBox->column[i].column); gtk_widget_show(listBox->column[i].label); } g_signal_connect_swapped(G_OBJECT(object->subWidget), "cursor-changed", G_CALLBACK(ListBox_change), (gpointer)this); g_signal_connect_swapped(G_OBJECT(object->subWidget), "row-activated", G_CALLBACK(ListBox_activate), (gpointer)this); if(parent.window->defaultFont) setFont(*parent.window->defaultFont); gtk_fixed_put(GTK_FIXED(parent.object->formContainer), object->widget, x, y); gtk_widget_show(object->subWidget); gtk_widget_show(object->widget); }
static void col_edited_helper(GtkCellRendererText *cell, gchar *path_string, gchar *new_text, gpointer _s_model) { GncOwner *owner; GtkTreeModel *s_model; GtkTreeIter s_iter; GncTreeViewOwnerColumnTextEdited col_edited_cb; GtkTreeViewColumn *col; col_edited_cb = g_object_get_data(G_OBJECT(cell), "column_edited_callback"); col = GTK_TREE_VIEW_COLUMN(g_object_get_data(G_OBJECT(cell), "column_view")); s_model = GTK_TREE_MODEL(_s_model); if (!gtk_tree_model_get_iter_from_string(s_model, &s_iter, path_string)) return; owner = gnc_tree_view_owner_get_owner_from_iter(s_model, &s_iter); col_edited_cb(owner, col, new_text); }
void list_store_set_sort_all(GtkWidget *tview) { GList *list, *ptr; int i; GtkTreeViewColumn *column; list = gtk_tree_view_get_columns(GTK_TREE_VIEW(tview)); if (list == NULL) return; for (ptr = list, i = 0; ptr; ptr = ptr->next, i++) { column = GTK_TREE_VIEW_COLUMN(ptr->data); gtk_tree_view_column_set_sort_column_id(column, i); gtk_tree_view_column_set_clickable(column, TRUE); } gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(tview), TRUE); g_list_free(list); }
void skin_view_realize(GtkTreeView * treeview) { GtkListStore *store; GtkTreeViewColumn *column; GtkCellRenderer *renderer; GtkTreeSelection *selection; gtk_widget_show_all(GTK_WIDGET(treeview)); gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(treeview), TRUE); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeview), FALSE); store = gtk_list_store_new(SKIN_VIEW_N_COLS, GDK_TYPE_PIXBUF, G_TYPE_STRING , G_TYPE_STRING); gtk_tree_view_set_model(treeview, GTK_TREE_MODEL(store)); g_object_unref (store); column = gtk_tree_view_column_new(); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE); gtk_tree_view_column_set_spacing(column, 16); gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), GTK_TREE_VIEW_COLUMN(column)); renderer = gtk_cell_renderer_pixbuf_new(); gtk_tree_view_column_pack_start(column, renderer, FALSE); gtk_tree_view_column_set_attributes(column, renderer, "pixbuf", SKIN_VIEW_COL_PREVIEW, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(column, renderer, TRUE); gtk_tree_view_column_set_attributes(column, renderer, "markup", SKIN_VIEW_COL_FORMATTEDNAME, NULL); selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview)); gtk_tree_selection_set_mode(selection, GTK_SELECTION_BROWSE); g_signal_connect(treeview, "cursor-changed", G_CALLBACK(skin_view_on_cursor_changed), NULL); }
static void preferences_sound_setup (EmpathyPreferences *preferences) { EmpathyPreferencesPriv *priv = GET_PRIV (preferences); GtkTreeView *view; GtkListStore *store; GtkCellRenderer *renderer; GtkTreeViewColumn *column; view = GTK_TREE_VIEW (priv->treeview_sounds); store = gtk_list_store_new (COL_SOUND_COUNT, G_TYPE_BOOLEAN, /* enabled */ G_TYPE_STRING, /* name */ G_TYPE_STRING); /* key */ gtk_tree_view_set_model (view, GTK_TREE_MODEL (store)); renderer = gtk_cell_renderer_toggle_new (); g_signal_connect (renderer, "toggled", G_CALLBACK (preferences_sound_cell_toggled_cb), preferences); column = gtk_tree_view_column_new (); gtk_tree_view_column_pack_start (column, renderer, FALSE); gtk_tree_view_column_add_attribute (column, renderer, "active", COL_SOUND_ENABLED); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, renderer, FALSE); gtk_tree_view_column_add_attribute (column, renderer, "text", COL_SOUND_NAME); gtk_tree_view_append_column (view, column); gtk_tree_view_column_set_resizable (column, FALSE); gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE); g_object_unref (store); }
static void contact_widget_model_populate_columns (EmpathyContactWidget *information) { GtkTreeView *view; GtkTreeModel *model; GtkTreeViewColumn *column; GtkCellRenderer *renderer; guint col_offset; view = GTK_TREE_VIEW (information->treeview_groups); model = gtk_tree_view_get_model (view); renderer = gtk_cell_renderer_toggle_new (); g_signal_connect (renderer, "toggled", G_CALLBACK (contact_widget_cell_toggled), information); column = gtk_tree_view_column_new_with_attributes (_("Select"), renderer, "active", COL_ENABLED, NULL); gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_fixed_width (column, 50); gtk_tree_view_append_column (view, column); renderer = gtk_cell_renderer_text_new (); col_offset = gtk_tree_view_insert_column_with_attributes (view, -1, _("Group"), renderer, "text", COL_NAME, /* "editable", COL_EDITABLE, */ NULL); g_object_set_data (G_OBJECT (renderer), "column", GINT_TO_POINTER (COL_NAME)); column = gtk_tree_view_get_column (view, col_offset - 1); gtk_tree_view_column_set_sort_column_id (column, COL_NAME); gtk_tree_view_column_set_resizable (column,FALSE); gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE); }
void clearlooks_treeview_get_header_index (GtkTreeView *tv, GtkWidget *header, gint *column_index, gint *columns, gboolean *resizable) { GList *list, *list_start; *column_index = *columns = 0; list_start = list = gtk_tree_view_get_columns (tv); do { GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN(list->data); if ( column->button == header ) { *column_index = *columns; *resizable = column->resizable; } if ( column->visible ) (*columns)++; } while ((list = g_list_next(list))); g_list_free (list_start); }
static void reset_sort_order (FsearchApplicationWindow *win) { g_assert (FSEARCH_WINDOW_IS_WINDOW (win)); GList *list = gtk_tree_view_get_columns (GTK_TREE_VIEW (win->listview)); GList *l; for (l = list; l != NULL; l = l->next) { GtkTreeViewColumn *col = GTK_TREE_VIEW_COLUMN (l->data); if (l == list) { gtk_tree_view_column_set_sort_order (col, GTK_SORT_ASCENDING); gtk_tree_view_column_set_sort_indicator (col, TRUE); gtk_tree_view_column_set_sort_column_id (col, SORT_ID_NAME); } else { gtk_tree_view_column_set_sort_order (col, GTK_SORT_ASCENDING); gtk_tree_view_column_set_sort_indicator (col, FALSE); } } g_list_free (list); }
static void fx_many_create_selected_column(FxMany* fxmany) { GtkCellRenderer* renderer; GtkTreeViewColumn *col0 , *col1; renderer = gtk_cell_renderer_pixbuf_new(); col0 = gtk_tree_view_column_new(); gtk_tree_view_column_pack_start(col0, renderer , FALSE); gtk_tree_view_column_add_attribute(col0, renderer, "pixbuf", C_PIXBUF_COL); gtk_tree_view_append_column(GTK_TREE_VIEW(fxmany->selected), 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_add_attribute(col1, renderer, "text", C_NAME_COL); gtk_tree_view_append_column(GTK_TREE_VIEW(fxmany->selected), col1); gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (col1) , GTK_TREE_VIEW_COLUMN_FIXED); }
/* This used to get the column as an argument binded when the signal was * created, but it seems GTK now destroys and recreates them in some * circumstances. So bind the column description instead and search for the * column by its title. */ static gboolean col_onButtonPressed(GtkButton * button, GdkEventButton * event, trg_column_description *desc) { if (event->type == GDK_BUTTON_PRESS && event->button == 3) { GtkTreeView *gtv = GTK_TREE_VIEW(gtk_widget_get_parent(GTK_WIDGET(button))); GList *cols = gtk_tree_view_get_columns(gtv); GList *li; for (li = cols; li; li = g_list_next(li)) { GtkTreeViewColumn *col = GTK_TREE_VIEW_COLUMN(li->data); if (!g_strcmp0(desc->header, gtk_tree_view_column_get_title(col))) { view_popup_menu(button, event, col); break; } } g_list_free(cols); return TRUE; } return FALSE; }
void list_store_set_sort_column(GtkWidget *tview, int col) { GList *list, *ptr; list = gtk_tree_view_get_columns(GTK_TREE_VIEW(tview)); if (list == NULL) return; ptr = g_list_nth(list, col); if (ptr) { GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN(ptr->data); gtk_tree_view_column_set_sort_column_id(column, col); gtk_tree_view_column_set_clickable(column, TRUE); } gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(tview), TRUE); g_list_free(list); }
static void view_column_model_get_value (GtkTreeModel *tree_model, GtkTreeIter *iter, gint column, GValue *value) { ViewColumnModel *view_model = (ViewColumnModel *)tree_model; g_return_if_fail (column < 2); g_return_if_fail (view_model->stamp == iter->stamp); g_return_if_fail (iter->user_data != NULL); if (column == 0) { g_value_init (value, G_TYPE_STRING); g_value_set_string (value, gtk_tree_view_column_get_title (GTK_TREE_VIEW_COLUMN (((GList *)iter->user_data)->data))); } else { g_value_init (value, GTK_TYPE_TREE_VIEW_COLUMN); g_value_set_object (value, ((GList *)iter->user_data)->data); } }
/** initialize this module */ gboolean ui_setup_ledlist_init( ) { _ui = ui_builder("niftyconf-setup-ledlist.ui"); /* set selection mode for tree */ GtkTreeSelection *selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(UI("treeview"))); gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE); /* connect signal handler */ g_signal_connect(selection, "changed", G_CALLBACK(on_selection_changed), NULL); /* initialize setup treeview */ GtkTreeViewColumn *col = GTK_TREE_VIEW_COLUMN(UI("column_led")); GtkCellRenderer *renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(col, renderer, TRUE); gtk_tree_view_column_add_attribute(col, renderer, "text", C_CHAIN_LED); return TRUE; }
GuTemplate* template_init (GtkBuilder* builder) { g_return_val_if_fail (GTK_IS_BUILDER (builder), NULL); GuTemplate* t = g_new0 (GuTemplate, 1); t->templatewindow = GTK_WINDOW (gtk_builder_get_object (builder, "templatewindow")); t->templateview = GTK_TREE_VIEW (gtk_builder_get_object (builder, "template_treeview")); t->list_templates = GTK_LIST_STORE (gtk_builder_get_object (builder, "list_templates")); t->template_label = GTK_LABEL (gtk_builder_get_object (builder, "template_label")); t->template_add = GTK_WIDGET (gtk_builder_get_object (builder, "template_add")); t->template_remove = GTK_WIDGET (gtk_builder_get_object (builder, "template_remove")); t->template_open = GTK_WIDGET (gtk_builder_get_object (builder, "template_open")); t->template_render = GTK_CELL_RENDERER_TEXT ( gtk_builder_get_object (builder, "template_renderer")); t->template_col = GTK_TREE_VIEW_COLUMN ( gtk_builder_get_object (builder, "template_column")); gtk_tree_view_column_set_sort_column_id (t->template_col, 0); return t; }
void glade_gtk_treeview_add_child (GladeWidgetAdaptor * adaptor, GObject * container, GObject * child) { GtkTreeView *view = GTK_TREE_VIEW (container); GtkTreeViewColumn *column; GladeWidget *gcolumn; if (!GTK_IS_TREE_VIEW_COLUMN (child)) return; if (gtk_tree_view_get_fixed_height_mode (view)) { gcolumn = glade_widget_get_from_gobject (child); glade_widget_property_set (gcolumn, "sizing", GTK_TREE_VIEW_COLUMN_FIXED); glade_widget_property_set_sensitive (gcolumn, "sizing", FALSE, INSENSITIVE_COLUMN_SIZING_MSG); } column = GTK_TREE_VIEW_COLUMN (child); gtk_tree_view_append_column (view, column); glade_gtk_cell_layout_sync_attributes (G_OBJECT (column)); }
gboolean qtcTreeViewCellIsLeftOfExpanderColumn(GtkTreeView *treeView, GtkTreeViewColumn *column) { // check expander column GtkTreeViewColumn *expanderColumn = gtk_tree_view_get_expander_column(treeView); if (!expanderColumn || column == expanderColumn) { return false; } else { bool found = false; bool isLeft = false; // get all columns GList *columns = gtk_tree_view_get_columns(treeView); for (GList *child = columns;child;child = g_list_next(child)) { if (!GTK_IS_TREE_VIEW_COLUMN(child->data)) { continue; } GtkTreeViewColumn *childCol = GTK_TREE_VIEW_COLUMN(child->data); if (childCol == expanderColumn) { if (found) { isLeft = true; } } else if (found) { break; } else if (column == childCol) { found = true; } } if (columns) { g_list_free(columns); } return isLeft; } }
/* * Public API */ GtkWidget * addressbook_window_new (boost::shared_ptr<Ekiga::ContactCore> core) { AddressBookWindow *self = NULL; boost::signals::connection conn; GtkWidget *menu_bar = NULL; GtkWidget *frame = NULL; GtkWidget *vbox = NULL; GtkWidget *hpaned = NULL; GtkCellRenderer *cell = NULL; GtkTreeViewColumn *column = NULL; GtkTreeStore *store = NULL; self = (AddressBookWindow *) g_object_new (ADDRESSBOOK_WINDOW_TYPE, NULL); self->priv = new AddressBookWindowPrivate (core); gtk_window_set_title (GTK_WINDOW (self), _("Address Book")); gtk_window_set_position (GTK_WINDOW (self), GTK_WIN_POS_CENTER); gtk_window_set_icon_name (GTK_WINDOW (self), "x-office-address-book"); /* Start building the window */ vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2); /* The menu */ menu_bar = gtk_menu_bar_new (); self->priv->accel = gtk_accel_group_new (); gtk_window_add_accel_group (GTK_WINDOW (self), self->priv->accel); g_object_unref (self->priv->accel); self->priv->menu_item_core = gtk_menu_item_new_with_mnemonic (_("Address _Book")); gtk_menu_shell_append (GTK_MENU_SHELL (menu_bar), self->priv->menu_item_core); g_object_ref (self->priv->menu_item_core); conn = core->updated.connect (boost::bind (&on_core_updated, (gpointer) self)); self->priv->connections.add (conn); on_core_updated (self); // This will add static and dynamic actions self->priv->menu_item_view = gtk_menu_item_new_with_mnemonic (_("_Action")); gtk_widget_set_sensitive (self->priv->menu_item_view, FALSE); gtk_menu_shell_append (GTK_MENU_SHELL (menu_bar), self->priv->menu_item_view); g_object_ref (self->priv->menu_item_view); gtk_container_add (GTK_CONTAINER (vbox), menu_bar); gtk_box_set_child_packing (GTK_BOX (vbox), menu_bar, FALSE, FALSE, 2, GTK_PACK_START); gtk_container_add (GTK_CONTAINER (self), vbox); /* A hpaned to put the list of Books and their content */ hpaned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL); gtk_container_set_border_width (GTK_CONTAINER (hpaned), 6); gtk_container_add (GTK_CONTAINER (vbox), hpaned); gtk_box_set_child_packing (GTK_BOX (vbox), hpaned, TRUE, TRUE, 0, GTK_PACK_START); /* The store listing the Books */ frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); store = gtk_tree_store_new (NUM_COLUMNS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER, G_TYPE_OBJECT); self->priv->tree_view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store)); g_object_unref (store); gtk_container_add (GTK_CONTAINER (frame), self->priv->tree_view); gtk_widget_set_size_request (GTK_WIDGET (self->priv->tree_view), 185, -1); gtk_paned_pack1 (GTK_PANED (hpaned), frame, TRUE, TRUE); /* Several renderers for one column */ column = gtk_tree_view_column_new (); cell = gtk_cell_renderer_pixbuf_new (); gtk_tree_view_column_pack_start (column, cell, FALSE); gtk_tree_view_column_add_attribute (column, cell, "icon-name", COLUMN_PIXBUF); cell = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, cell, FALSE); gtk_tree_view_column_set_attributes (column, cell, "text", COLUMN_NAME, NULL); gtk_tree_view_column_set_title (column, _("Category")); gtk_tree_view_column_set_sort_column_id (column, COLUMN_NAME); gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (column), GTK_TREE_VIEW_COLUMN_AUTOSIZE); gtk_tree_view_column_set_resizable (GTK_TREE_VIEW_COLUMN (column), true); gtk_tree_view_append_column (GTK_TREE_VIEW (self->priv->tree_view), GTK_TREE_VIEW_COLUMN (column)); self->priv->selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (self->priv->tree_view)); gtk_tree_selection_set_mode (GTK_TREE_SELECTION (self->priv->selection), GTK_SELECTION_SINGLE); g_signal_connect (self->priv->selection, "changed", G_CALLBACK (on_book_selection_changed), self); g_signal_connect (self->priv->tree_view, "event-after", G_CALLBACK (on_book_clicked), self); /* The notebook containing the books */ self->priv->notebook = gtk_notebook_new (); gtk_notebook_set_show_tabs (GTK_NOTEBOOK (self->priv->notebook), FALSE); g_signal_connect (self->priv->notebook, "realize", G_CALLBACK (on_notebook_realize), self); gtk_paned_pack2 (GTK_PANED (hpaned), self->priv->notebook, TRUE, TRUE); conn = core->source_added.connect (boost::bind (&on_source_added, _1, (gpointer) self)); self->priv->connections.add (conn); conn = core->book_updated.connect (boost::bind (&on_book_updated, _1, _2, (gpointer) self)); self->priv->connections.add (conn); conn = core->book_added.connect (boost::bind (&on_book_added, _1, _2, (gpointer) self)); self->priv->connections.add (conn); conn = core->book_removed.connect (boost::bind (&on_book_removed, _1, _2, (gpointer) self)); self->priv->connections.add (conn); conn = core->questions.connect (boost::bind (&on_handle_questions, _1, (gpointer) self)); self->priv->connections.add (conn); core->visit_sources (boost::bind (on_visit_sources, _1, (gpointer) self)); return GTK_WIDGET (self); }
static void setup_view(GtkWidget* view) { GtkListStore* store = gtk_list_store_new (23, G_TYPE_STRING, /* 0 Country */ G_TYPE_STRING, /* 1 Good Name */ GDK_TYPE_PIXBUF, /* 2 NULL for Status handle / empty */ G_TYPE_STRING, /* 3 User Comments */ G_TYPE_STRING, /* 4 File Name */ G_TYPE_STRING, /* 5 MD5 Hash */ G_TYPE_STRING, /* 6 CRC1 */ G_TYPE_STRING, /* 7 CRC2 */ G_TYPE_STRING, /* 8 Internal Name */ G_TYPE_STRING, /* 9 Save Type */ G_TYPE_STRING, /* 10 Players */ G_TYPE_STRING, /* 11 Size */ G_TYPE_STRING, /* 12 Compression */ G_TYPE_STRING, /* 13 Image Type */ G_TYPE_STRING, /* 14 CIC Chip */ G_TYPE_STRING, /* 15 Rumble */ GDK_TYPE_PIXBUF, /* 16-20 Pixbufs for Status stars. */ GDK_TYPE_PIXBUF, GDK_TYPE_PIXBUF, GDK_TYPE_PIXBUF, GDK_TYPE_PIXBUF, GDK_TYPE_PIXBUF, /* 21 Flag */ G_TYPE_POINTER, /* 22 RCS Entry */ -1); GtkCellRenderer* renderer; GtkTreeViewColumn* column; GtkWidget* item; char buffer[128]; int i; unsigned char visible; /* Create country flag / string dual rendered cell. */ renderer = gtk_cell_renderer_pixbuf_new(); g_MainWindow.column[0] = gtk_tree_view_column_new(); column = g_MainWindow.column[0]; gtk_tree_view_column_set_title(column, g_MainWindow.column_names[0][0]); gtk_tree_view_column_pack_start(column, renderer, FALSE); gtk_tree_view_column_add_attribute(column, renderer, "pixbuf", 21); g_object_set(renderer, "xpad", 5, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(column, renderer, TRUE); gtk_tree_view_column_add_attribute(column, renderer, "text", 0); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_reorderable(column, TRUE); gtk_tree_view_column_set_sort_column_id(column, 0); gtk_tree_view_insert_column(GTK_TREE_VIEW (view), column, 0); g_signal_connect(column->button, "button-press-event", G_CALLBACK(callback_header_clicked), column); renderer = gtk_cell_renderer_text_new(); g_MainWindow.column[1] = gtk_tree_view_column_new_with_attributes(g_MainWindow.column_names[1][0], renderer, "text", 1, NULL); column = g_MainWindow.column[1]; gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_reorderable(column, TRUE); gtk_tree_view_column_set_sort_column_id(column, 1); gtk_tree_view_insert_column(GTK_TREE_VIEW (view), column, 1); g_signal_connect(column->button, "button-press-event", G_CALLBACK(callback_header_clicked), column); /* Status stars. */ g_MainWindow.column[2] = gtk_tree_view_column_new(); column = g_MainWindow.column[2]; gtk_tree_view_column_set_title(column, g_MainWindow.column_names[2][0]); renderer = gtk_cell_renderer_pixbuf_new(); g_object_set(renderer, "xpad", 2, NULL); gtk_tree_view_column_pack_start(column, renderer, FALSE); gtk_tree_view_column_add_attribute(column, renderer, "pixbuf", 2); for(i = 0; i < 5; ++i) { renderer = gtk_cell_renderer_pixbuf_new(); gtk_tree_view_column_pack_start(column, renderer, FALSE); gtk_tree_view_column_add_attribute(column, renderer, "pixbuf", 16+i); } renderer = gtk_cell_renderer_pixbuf_new(); g_object_set(renderer, "xpad", 2, NULL); gtk_tree_view_column_pack_start(column, renderer, FALSE); gtk_tree_view_column_add_attribute(column, renderer, "pixbuf", 2); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_reorderable(column, TRUE); gtk_tree_view_column_set_sort_column_id(column, 2); gtk_tree_view_insert_column(GTK_TREE_VIEW (view), column, 2); g_signal_connect(column->button, "button-press-event", G_CALLBACK(callback_header_clicked), column); for(i = 3; i < 16; ++i) { renderer = gtk_cell_renderer_text_new(); g_MainWindow.column[i] = gtk_tree_view_column_new_with_attributes(g_MainWindow.column_names[i][0], renderer, "text", i, NULL); column = g_MainWindow.column[i]; gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_reorderable(column, TRUE); gtk_tree_view_column_set_sort_column_id(column, i); gtk_tree_view_insert_column(GTK_TREE_VIEW (view), column, i); g_signal_connect(column->button, "button-press-event", G_CALLBACK(callback_header_clicked), column); } renderer = gtk_cell_renderer_text_new (); g_MainWindow.column[16] = gtk_tree_view_column_new(); column = g_MainWindow.column[16]; gtk_tree_view_column_set_visible(column, FALSE); gtk_tree_view_insert_column(GTK_TREE_VIEW(view), column, 2); g_signal_connect(column->button, "button-press-event", G_CALLBACK(callback_header_clicked), column); gtk_tree_view_set_model(GTK_TREE_VIEW(view), GTK_TREE_MODEL(store)); g_MainWindow.romHeaderMenu = gtk_menu_new(); /* Toggle column visibility from config file, make menu. */ for(i = 0; i < 16; ++i) { snprintf(buffer, sizeof(buffer), " %s", g_MainWindow.column_names[i][0]); item = gtk_check_menu_item_new_with_mnemonic(buffer); if((visible=config_get_bool(g_MainWindow.column_names[i][1], 2))==2) { visible = (i<5) ? TRUE: FALSE; config_put_bool(g_MainWindow.column_names[i][1], visible); } gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), visible); gtk_tree_view_column_set_visible(g_MainWindow.column[i], visible); gtk_menu_shell_append(GTK_MENU_SHELL(g_MainWindow.romHeaderMenu), item); g_signal_connect(item, "activate", G_CALLBACK(callback_column_visible), GUINT_TO_POINTER(i)); } gtk_tree_view_column_set_visible(g_MainWindow.column[16], FALSE); for(i = 0; i < 16; ++i) { if(gtk_tree_view_column_get_visible(GTK_TREE_VIEW_COLUMN(g_MainWindow.column[i]))) return; } gtk_tree_view_column_set_visible(g_MainWindow.column[16], TRUE); }