自学教程：C++ GTK_TREE_VIEW_COLUMN函数代码示例

static voidpreferences_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);}

voidglade_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 changedstatic voidbind_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 voidrefresh_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 changedstatic voidbind_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);}

voidlist_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);}

voidskin_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 voidpreferences_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 voidcontact_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 voidreset_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 gbooleancol_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;}

voidlist_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 voidview_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);    }}

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;}

voidglade_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));}

gbooleanqtcTreeViewCellIsLeftOfExpanderColumn(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));//.........这里部分代码省略.........

//.........这里部分代码省略.........    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);}