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

static gbooleancell_renderer_activatable_activate (GtkCellRenderer      *cell,                                    GdkEvent *event,                                    GtkWidget *widget,                                    const gchar *path_string,                                    const GdkRectangle *background_area,                                    const GdkRectangle *cell_area,                                    GtkCellRendererState  flags){    EmpathyCellRendererActivatable *activatable;    gint ex, ey, bx, by, bw, bh;    activatable = EMPATHY_CELL_RENDERER_ACTIVATABLE (cell);    if (!GTK_IS_TREE_VIEW (widget) || event == NULL ||            event->type != GDK_BUTTON_PRESS) {        return FALSE;    }    ex  = (gint) ((GdkEventButton *) event)->x;    ey  = (gint) ((GdkEventButton *) event)->y;    bx = background_area->x;    by = background_area->y;    bw = background_area->width;    bh = background_area->height;    if (ex < bx || ex > (bx+bw) || ey < by || ey > (by+bh)) {        /* Click wasn't on the icon */        return FALSE;    }    g_signal_emit (activatable, signals[PATH_ACTIVATED], 0, path_string);    return TRUE;}

/** * gwy_grain_value_tree_view_select: * @treeview: A tree view with grain values. * @gvalue: The grain value to select. * * Selects a particular grain value in a grain value tree view. * * If the @gvalue group is currently unexpanded, it will be expanded to * show it, and the tree view may scroll to make it visible. * * Since: 2.8 **/voidgwy_grain_value_tree_view_select(GtkTreeView *treeview,                                 GwyGrainValue *gvalue){    GtkTreeSelection *selection;    GtkTreeModel *model;    GtkTreePath *path;    GtkTreeIter iter;    g_return_if_fail(GTK_IS_TREE_VIEW(treeview));    g_return_if_fail(GWY_IS_GRAIN_VALUE(gvalue));    g_return_if_fail(priv_quark                     && g_object_get_qdata(G_OBJECT(treeview), priv_quark));    model = gtk_tree_view_get_model(treeview);    if (!find_grain_value(model, gvalue, &iter)) {        g_warning("Grain value not in tree model.");        return;    }    path = gtk_tree_model_get_path(model, &iter);    gtk_tree_view_expand_to_path(treeview, path);    gtk_tree_view_scroll_to_cell(treeview, path, NULL, FALSE, 0.0, 0.0);    gtk_tree_path_free(path);    selection = gtk_tree_view_get_selection(treeview);    gtk_tree_selection_select_iter(selection, &iter);}

voidsetup(GtkWidget *widget){    GtkWidgetProps props(widget);    if (widget && GTK_IS_SCROLLED_WINDOW(widget) &&        !props->scrolledWindowHacked) {        GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(widget);        GtkWidget *child;        if ((child = gtk_scrolled_window_get_hscrollbar(scrolledWindow))) {            setupConnections(child, widget);        }        if ((child = gtk_scrolled_window_get_vscrollbar(scrolledWindow))) {            setupConnections(child, widget);        }        if ((child = gtk_bin_get_child(GTK_BIN(widget)))) {            if (GTK_IS_TREE_VIEW(child) || GTK_IS_TEXT_VIEW(child) ||                GTK_IS_ICON_VIEW(child)) {                setupConnections(child, widget);            } else if (oneOf(gTypeName(child), "ExoIconView",                             "FMIconContainer")) {                setupConnections(child, widget);            }        }        props->scrolledWindowHacked = true;    }}

static voidon_name_field_changed (GtkEditable *editable,		       gpointer     user_data){	GtkTreeIter   iter;	g_return_if_fail(GTK_IS_TREE_VIEW(bookmark_list_widget));	g_return_if_fail(GTK_IS_ENTRY(name_field));	if (!get_selection_exists())		return;	/* Update text displayed in list instantly. Also remember that 	 * user has changed text so we update real bookmark later. 	 */	gtk_tree_selection_get_selected (bookmark_selection,					 NULL,					 &iter);		gtk_list_store_set (bookmark_list_store, 			    &iter, BOOKMARK_LIST_COLUMN_NAME, 			    gtk_entry_get_text (GTK_ENTRY (name_field)),			    -1);	text_changed = TRUE;	name_text_changed = TRUE;}

static gbooleantree_view_button_press(GtkWidget *widget, GdkEventButton *event, gpointer data){  UIMCandWinVerticalGtk *vertical_cwin;  UIMCandWinGtk *cwin;  GtkTreePath *path;  gboolean exist, retval = FALSE;  gint *indicies;  g_return_val_if_fail(GTK_IS_TREE_VIEW(widget), FALSE);  g_return_val_if_fail(UIM_CAND_WIN_VERTICAL_GTK(data), FALSE);  vertical_cwin = UIM_CAND_WIN_VERTICAL_GTK(data);  cwin = UIM_CAND_WIN_GTK(vertical_cwin);  exist = gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(widget),					event->x, event->y,					&path, NULL, NULL, NULL);  if (!exist)    return FALSE;  indicies = gtk_tree_path_get_indices(path);  /* don't relay button press event to empty row */  if (cwin->display_limit * cwin->page_index + *indicies >= cwin->nr_candidates)    retval = TRUE;  gtk_tree_path_free(path);  return retval;}

static gbooleanqtcTreeViewLeave(GtkWidget *widget, GdkEventMotion *event, void *data){    QTC_UNUSED(event);    QTC_UNUSED(data);    if (GTK_IS_TREE_VIEW(widget)) {        QtCTreeView *tv = qtcTreeViewLookupHash(widget, false);        if (tv) {            GtkTreeView *treeView = GTK_TREE_VIEW(widget);            QtcRect rect = {0, 0, -1, -1 };            QtcRect alloc = qtcWidgetGetAllocation(widget);            if (tv->path && tv->column) {                gtk_tree_view_get_background_area(                    treeView, tv->path, tv->column, (GdkRectangle*)&rect);            }            if (tv->fullWidth) {                rect.x = 0;                rect.width = alloc.width;            }            if (tv->path) {                gtk_tree_path_free(tv->path);            }            tv->path = NULL;            tv->column = NULL;            gtk_tree_view_convert_bin_window_to_widget_coords(                treeView, rect.x, rect.y, &rect.x, &rect.y);            gtk_widget_queue_draw_area(                widget, rect.x, rect.y, rect.width, rect.height);        }    }    return false;}

/* Get a new thumbnail region of GtkTreeView widget in which eventfalls.  It is an error to call this function if !in_thumbnail(widget, event).  */static GdkRegion *thumbnail_region (GtkWidget *widget, GdkEventMotion *event){    g_assert (GTK_IS_TREE_VIEW (widget));    g_assert (in_thumbnail (widget, event));    GtkTreePath *tp = thumbnail_path (widget, event);    g_assert (tp != NULL);    /* Rectangle of region to be returned.  */    GdkRectangle tn_rect;    /* If over the input image thumbnail, return the input thumbnail region, */    GtkTreeViewColumn *tc = NULL;	/* Thumbnail column we are over.  */    if ( in_input_thumbnail (widget, event) ) {        tc = input_thumbnail_column (widget, event);    }    gtk_tree_view_get_cell_area (GTK_TREE_VIEW (widget), tp, tc, &tn_rect);    /* Here we depend on the fact that the thumbnails are packed at the    beginning of the cell horizontally, and centered in the cell    vertically (FIXME: find a way to verify this with assertions).  */    GdkRectangle itn_rect;		/* Image thumbnail rectangle.  */    /* FIXME: fix this border hackery to be precise somehow.  */    itn_rect.x = tn_rect.x + 1;	/* There is probably a small border so +1.  */    itn_rect.y = tn_rect.y + 1;    itn_rect.width = THUMB_SIZE;    itn_rect.height = THUMB_SIZE;    return gdk_region_rectangle (&itn_rect);}

static voidset_role_for_button (AtkObject *accessible,                     GtkWidget *button){  GtkWidget *parent;  AtkRole role;  parent = gtk_widget_get_parent (button);  if (GTK_IS_TREE_VIEW (parent))    {      role = ATK_ROLE_TABLE_COLUMN_HEADER;      /*       * Even though the accessible parent of the column header will       * be reported as the table because the parent widget of the       * GtkTreeViewColumn's button is the GtkTreeView we set       * the accessible parent for column header to be the table       * to ensure that atk_object_get_index_in_parent() returns       * the correct value; see gail_widget_get_index_in_parent().       */      atk_object_set_parent (accessible, gtk_widget_get_accessible (parent));    }  else    role = ATK_ROLE_PUSH_BUTTON;  accessible->role =  role;}

static void gmpc_meta_data_widgets_similar_songs_tree_row_activated (GmpcMetaDataWidgetsSimilarSongs* self, GtkWidget* tree, GtkTreePath* path, GtkTreeViewColumn* column) {	GtkWidget* _tmp0_;	GtkTreeModel* _tmp1_ = NULL;	GtkTreeModel* _tmp2_;	GtkTreeModel* model;	GtkTreeIter iter = {0};	GtkTreeIter _tmp3_ = {0};	gboolean _tmp4_;	g_return_if_fail (self != NULL);	g_return_if_fail (tree != NULL);	g_return_if_fail (path != NULL);	g_return_if_fail (column != NULL);	_tmp0_ = tree;	_tmp1_ = gtk_tree_view_get_model (GTK_IS_TREE_VIEW (_tmp0_) ? ((GtkTreeView*) _tmp0_) : NULL);	_tmp2_ = _g_object_ref0 (_tmp1_);	model = _tmp2_;	_tmp4_ = gtk_tree_model_get_iter (model, &_tmp3_, path);	iter = _tmp3_;	if (_tmp4_) {		const mpd_Song* song;		song = NULL;		gtk_tree_model_get (model, &iter, 0, &song, -1, -1);		if (song != NULL) {			play_path (song->file);		}	}	_g_object_unref0 (model);}

voidbastile_gkr_item_properties_show (BastileGkrItem *git, GtkWindow *parent){    BastileObject *object = BASTILE_OBJECT (git);    BastileWidget *swidget = NULL;    GtkWidget *widget;    swidget = bastile_object_widget_new ("gkr-item-properties", parent, object);        /* This happens if the window is already open */    if (swidget == NULL)        return;    bastile_object_refresh (object);    widget = GTK_WIDGET (bastile_widget_get_widget (swidget, swidget->name));    g_signal_connect (widget, "response", G_CALLBACK (properties_response), swidget);    /*      * The signals don't need to keep getting connected. Everytime a key changes the     * do_* functions get called. Therefore, seperate functions connect the signals     * have been created     */    setup_main (swidget);    setup_details (swidget);    setup_application (swidget);        widget = bastile_widget_get_widget (swidget, "application-list");    g_return_if_fail (GTK_IS_TREE_VIEW (widget));        g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (widget)), "changed",                       G_CALLBACK (application_selection_changed), swidget);}

static gbooleanempathy_cell_renderer_expander_activate (GtkCellRenderer      *cell,					GdkEvent             *event,					GtkWidget            *widget,					const gchar          *path_string,					const GdkRectangle   *background_area,					const GdkRectangle   *cell_area,					GtkCellRendererState  flags){	EmpathyCellRendererExpanderPriv *priv;	GtkTreePath                    *path;	priv = GET_PRIV (cell);	if (!GTK_IS_TREE_VIEW (widget) || !priv->activatable)		return FALSE;	path = gtk_tree_path_new_from_string (path_string);	if (gtk_tree_path_get_depth (path) > 1) {		gtk_tree_path_free (path);		return TRUE;	}	if (gtk_tree_view_row_expanded (GTK_TREE_VIEW (widget), path)) {		gtk_tree_view_collapse_row (GTK_TREE_VIEW (widget), path);	} else {		gtk_tree_view_expand_row (GTK_TREE_VIEW (widget), path, FALSE);	}	gtk_tree_path_free (path);	return TRUE;}

GObject *seahorse_key_manager_store_get_selected_object (GtkTreeView *view){	SeahorseKeyManagerStore* skstore;	GObject *obj = NULL;	GList *paths = NULL;	GtkTreeSelection *selection;	g_return_val_if_fail (GTK_IS_TREE_VIEW (view), NULL);	skstore = SEAHORSE_KEY_MANAGER_STORE (gtk_tree_view_get_model (view));	g_return_val_if_fail (SEAHORSE_IS_KEY_MANAGER_STORE (skstore), NULL);	selection = gtk_tree_view_get_selection (view);	paths = gtk_tree_selection_get_selected_rows (selection, NULL);	/* choose first object */	if (paths != NULL) {		obj = seahorse_key_manager_store_get_object_from_path (view, paths->data);		/* free selected paths */		g_list_foreach (paths, (GFunc)gtk_tree_path_free, NULL);		g_list_free (paths);	}	return obj;}

voidseahorse_key_manager_store_set_selected_objects (GtkTreeView *view, GList* objects){	SeahorseKeyManagerStore* skstore;	GtkTreeSelection* selection;	gboolean first = TRUE;	GtkTreePath *path;	GList *l;	GtkTreeIter iter;	g_return_if_fail (GTK_IS_TREE_VIEW (view));	selection = gtk_tree_view_get_selection (view);	gtk_tree_selection_unselect_all (selection);	skstore = SEAHORSE_KEY_MANAGER_STORE (gtk_tree_view_get_model (view));	g_return_if_fail (SEAHORSE_IS_KEY_MANAGER_STORE (skstore));	for (l = objects; l; l = g_list_next (l)) {		if (gcr_collection_model_iter_for_object (GCR_COLLECTION_MODEL (skstore),		                                          l->data, &iter)) {			gtk_tree_selection_select_iter (selection, &iter);			/* Scroll the first row selected into view */			if (first) {				path = gtk_tree_model_get_path (gtk_tree_view_get_model (view), &iter);				gtk_tree_view_scroll_to_cell (view, path, NULL, FALSE, 0.0, 0.0);				gtk_tree_path_free (path);				first = FALSE;			}		}	}}

/** * cact_providers_list_init_view: * @window: the parent #BaseWindow which embeds the view. * @treeview: the #GtkTreeView. * * Connects signals at runtime initialization of the widget, and setup * current default values. */voidcact_providers_list_init_view( BaseWindow *window, GtkTreeView *treeview ){	static const gchar *thisfn = "cact_providers_list_init_view";	ProvidersListData *data;	CactApplication *application;	NAUpdater *updater;	g_return_if_fail( BASE_IS_WINDOW( window ));	g_return_if_fail( GTK_IS_TREE_VIEW( treeview ));	g_debug( "%s: treeview=%p, window=%p", thisfn, ( void * ) treeview, ( void * ) window );	g_object_set_data( G_OBJECT( window ), PROVIDERS_LIST_TREEVIEW, treeview );	data = get_providers_list_data( treeview );	data->window = window;	application = CACT_APPLICATION( base_window_get_application( window ));	updater = cact_application_get_updater( application );	data->preferences_locked = na_updater_are_preferences_locked( updater );	init_view_setup_providers( treeview, window );	init_view_connect_signals( treeview, window );	init_view_select_first_row( treeview );}

voidbaobab_treeview_show_allocated_size (GtkWidget *tv,				     gboolean show_allocated){	gint sort_id;	gint new_sort_id;	GtkSortType order;	GtkTreeViewColumn *size_col;	g_return_if_fail (GTK_IS_TREE_VIEW (tv));	gtk_tree_sortable_get_sort_column_id (GTK_TREE_SORTABLE (baobab.model),					      &sort_id, &order);	/* set the sort id for the size column */	size_col = g_object_get_data (G_OBJECT (tv), "baobab_size_col");	new_sort_id = show_allocated ? COL_H_ALLOCSIZE : COL_H_SIZE;	gtk_tree_view_column_set_sort_column_id (size_col, new_sort_id);	/* if we are currently sorted on size or allocated size,	 * then trigger a resort (with the same order) */	if (sort_id == COL_H_SIZE || sort_id == COL_H_ALLOCSIZE) {		gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (baobab.model),						      new_sort_id, order);	}}

/** * rb_tree_dnd_add_drag_source_support: * @tree_view: a #GtkTreeView that wants to be a drag source * @start_button_mask: a mask describing modifier keys to handle when dragging * @targets: an array of #GtkTargetEntry structures describing drag data types * @n_targets: the number of elements in @targets * @actions: a mask describing drag actions that are allowed from this source * * Adds event handlers to perform multi-row drag and drop operations from the * specified #GtkTreeView widget.  The model backing the #GtkTreeView must * implement the #RbTreeDragSource interface.  This should be called immediately * after the tree view is created. */voidrb_tree_dnd_add_drag_source_support (GtkTreeView *tree_view,				     GdkModifierType start_button_mask,				     const GtkTargetEntry *targets,				     gint n_targets,				     GdkDragAction actions){	RbTreeDndData *priv_data = NULL; 	g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));	priv_data = init_rb_tree_dnd_data (GTK_WIDGET(tree_view));	if (!priv_data->button_press_event_handler) {		priv_data->source_target_list = gtk_target_list_new (targets, n_targets);		priv_data->source_actions = actions;		priv_data->start_button_mask = start_button_mask;		priv_data->button_press_event_handler = g_signal_connect (G_OBJECT (tree_view),							"button_press_event",							G_CALLBACK (rb_tree_dnd_button_press_event_cb),							NULL);		priv_data->drag_data_get_handler = g_signal_connect (G_OBJECT (tree_view),								     "drag_data_get",								     G_CALLBACK (rb_tree_dnd_drag_data_get_cb),								     NULL);		priv_data->drag_data_delete_handler = g_signal_connect (G_OBJECT (tree_view),									"drag_data_delete",									G_CALLBACK (rb_tree_dnd_drag_data_delete_cb),									NULL);	}}

/* Set tree of the tree-store. This includes getting the folder tree and * storing it */static void foldercheck_set_tree(SpecificFolderArrayEntry *entry){  Folder *folder;  GList *list;  for(list = folder_get_list(); list != NULL; list = list->next) {    folder = FOLDER(list->data);    if(folder == NULL) {      debug_print("Notification plugin::foldercheck_set_tree(): Found a NULL folder./n");      continue;    }    /* Only regard built-in folders, because folders from plugins (such as RSS, calendar,     * or plugin-provided mailbox storage systems like Maildir or MBox) may vanish     * without letting us know. */    switch(folder->klass->type) {    case F_MH:    case F_IMAP:    case F_NEWS:      foldercheck_insert_gnode_in_store(entry->tree_store, folder->node, NULL);      break;    default:      break;    }  }  gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(entry->tree_store),				       FOLDERCHECK_FOLDERNAME,				       GTK_SORT_ASCENDING);  if(GTK_IS_TREE_VIEW(entry->treeview))    gtk_tree_view_expand_all(GTK_TREE_VIEW(entry->treeview));}

/** * gel_ui_tree_view_get_selected_indices: * @tv: A #GtkTreeView * * Returns a %NULL terminated array of gint with the indices of selected * rows, only works with a #GtkTreeView holding a #GtkListModel * * Returns: (allow-none) (transfer full): The selected indices, each index and the value *                           it self must be freeed with g_free */gint *gel_ui_tree_view_get_selected_indices(GtkTreeView *tv){	g_return_val_if_fail(GTK_IS_TREE_VIEW(tv), NULL);	g_return_val_if_fail(GTK_IS_LIST_STORE(gtk_tree_view_get_model(tv)), NULL);	GtkTreeSelection *selection = gtk_tree_view_get_selection(tv);	GtkTreeModel     *model     = gtk_tree_view_get_model(tv);	GList *l, *iter; // iter over selected treepaths	gint  *indices;  // hold treepath's indices	gint i = 0;      // index	l = iter = gtk_tree_selection_get_selected_rows(selection, &model);	gint *ret = g_new0(gint, g_list_length(l) + 1);	while (iter)	{		indices = gtk_tree_path_get_indices((GtkTreePath *) iter->data);		if (!indices || !indices[0] || !indices[1] || (indices[1] != -1))		{			g_warning(_("Invalid GtkTreePath in selection, use %s only with ListModels"), __FUNCTION__);			continue;		}		ret[i++] = indices[0];		l = l->next;	}	g_list_foreach(l, (GFunc) gtk_tree_path_free, NULL);	g_list_free(l);	return ret;}

static gbooleanin_input_thumbnail (GtkWidget *widget, GdkEventMotion *event){    g_assert (GTK_IS_TREE_VIEW (widget));    gboolean result = FALSE;	/* Result to be returned. */    GtkTreePath *tp = thumbnail_path (widget, event);    if ( tp == NULL ) {        return FALSE;		/* Pointer is not over a filled in row.  */    }    /* Check if we are over the input image thumbnail.  */    GtkTreeViewColumn *itc = input_thumbnail_column (widget, event);    GdkRectangle itnc_rect;	/* Input thumbnail cell rectangle.  */    gtk_tree_view_get_cell_area (GTK_TREE_VIEW (widget), tp, itc, &itnc_rect);    /* Here we depend on the fact that the input thumbnail is packed at    the beginning of the cell horizontally, and centered in the cell    vertically (FIXME: find a way to verify this with assertions).  */    GdkRectangle itn_rect;	/* Input thumbnail rectangle.  */    /* FIXME: fix this border hackery to be precise somehow.  */    itn_rect.x = itnc_rect.x + 1;	/* There is probably a small border so +1.  */    itn_rect.y = itnc_rect.y + 1;    itn_rect.width = THUMB_SIZE;    itn_rect.height = THUMB_SIZE;    GdkRegion *itn_region = gdk_region_rectangle (&itn_rect);    if ( gdk_region_point_in (itn_region, (int) event->x, (int) event->y) ) {        result = TRUE;        //    g_message ("Over input thumbnail!");    }    gdk_region_destroy (itn_region);    return result;}

static gbooleangm_cell_renderer_expander_activate (GtkCellRenderer                    *cell,			            G_GNUC_UNUSED GdkEvent             *event,                                    GtkWidget                          *widget,                                    const gchar                        *path_string,                                    G_GNUC_UNUSED const GdkRectangle   *background_area,                                    G_GNUC_UNUSED const GdkRectangle   *cell_area,                                    G_GNUC_UNUSED GtkCellRendererState flags){	GmCellRendererExpander     *expander;	GmCellRendererExpanderPriv *priv;	GtkTreePath                     *path;	expander = (GmCellRendererExpander *) cell;	priv = expander->priv;	if (!GTK_IS_TREE_VIEW (widget) || !priv->activatable)		return FALSE;	path = gtk_tree_path_new_from_string (path_string);	if (gtk_tree_view_row_expanded (GTK_TREE_VIEW (widget), path)) {		gtk_tree_view_collapse_row (GTK_TREE_VIEW (widget), path);	} else {		gtk_tree_view_expand_row (GTK_TREE_VIEW (widget), path, FALSE);	}	gtk_tree_path_free (path);	return TRUE;}

/** * cryptui_key_store_have_selected_keys: * @ckstore: a libcryptui key store * @view: a GtkTreeView * * Determines whether keys are selected or not. * * Returns: TRUE if keys have been selected, FALSE otherwise */gbooleancryptui_key_store_have_selected_keys (CryptUIKeyStore *ckstore, GtkTreeView *view){    GtkTreeSelection *selection;    g_return_val_if_fail (CRYPTUI_IS_KEY_STORE (ckstore), FALSE);    g_return_val_if_fail (GTK_IS_TREE_VIEW (view), FALSE);    if (ckstore->priv->use_checks) {        GtkTreeModel* model = GTK_TREE_MODEL (ckstore->priv->store);        GtkTreeIter iter;        gboolean check;        if (gtk_tree_model_get_iter_first (model, &iter)) {            do {                check = FALSE;                gtk_tree_model_get (model, &iter, CRYPTUI_KEY_STORE_CHECK, &check, -1);                if (check)                    return TRUE;            } while (gtk_tree_model_iter_next (model, &iter));        }    } else {        /* Fall back if none checked, or not using checks */        selection = gtk_tree_view_get_selection (view);        if (gtk_tree_selection_count_selected_rows (selection))            return TRUE;    }    return FALSE;}

static voidedited_callback (GtkCellRendererText *renderer,		 const gchar   *path_string,		 const gchar   *new_text,		 GtkTreeView  *tree_view){  GtkTreeModel *model = NULL;  GtkTreeModelSort *sort_model = NULL;  GtkTreePath *path;  GtkTreeIter iter;  guint value = atoi (new_text);    g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));  model = gtk_tree_view_get_model (tree_view);    if (GTK_IS_TREE_MODEL_SORT (model))    {      sort_model = GTK_TREE_MODEL_SORT (model);      model = gtk_tree_model_sort_get_model (sort_model);    }  if (model == NULL)    return;  if (sort_model)    {      g_warning ("FIXME implement conversion from TreeModelSort iter to child model iter");      return;    }        path = gtk_tree_path_new_from_string (path_string);  if (!gtk_tree_model_get_iter (model,                                &iter, path))    {      g_warning ("%s: bad path?", G_STRLOC);      return;    }  gtk_tree_path_free (path);  if (GTK_IS_LIST_STORE (model))    {      gtk_list_store_set (GTK_LIST_STORE (model),                          &iter,                          4,                          value,                          -1);    }  else if (GTK_IS_TREE_STORE (model))    {      gtk_tree_store_set (GTK_TREE_STORE (model),                          &iter,                          4,                          value,                          -1);    }  else    g_warning ("don't know how to actually toggle value for model type %s",               g_type_name (G_TYPE_FROM_INSTANCE (model)));}

static voidbookmarks_delete_bookmark (void){	GtkTreeIter iter;	GtkTreePath *path;	gint *indices, row, rows;	g_assert (GTK_IS_TREE_VIEW (bookmark_list_widget));		if (!gtk_tree_selection_get_selected (bookmark_selection, NULL, &iter))		return;	/* Remove the selected item from the list store. on_row_deleted() will	   remove it from the bookmark list. */	path = gtk_tree_model_get_path (GTK_TREE_MODEL (bookmark_list_store),					&iter);	indices = gtk_tree_path_get_indices (path);	row = indices[0];	gtk_tree_path_free (path);	gtk_list_store_remove (bookmark_list_store, &iter);	/* Try to select the same row, or the last one in the list. */	rows = gtk_tree_model_iter_n_children (GTK_TREE_MODEL (bookmark_list_store), NULL);	if (row >= rows)		row = rows - 1;	if (row < 0) {		bookmarks_set_empty (TRUE);	} else {		gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (bookmark_list_store),					       &iter, NULL, row);		gtk_tree_selection_select_iter (bookmark_selection, &iter);	}}

void qtcScrolledWindowSetup(GtkWidget *widget){    if (widget && GTK_IS_SCROLLED_WINDOW(widget) && !g_object_get_data(G_OBJECT(widget), "QTC_SCROLLED_WINDOW_SET"))    {        GtkScrolledWindow *scrolledWindow=GTK_SCROLLED_WINDOW(widget);        GtkWidget         *child;        if((child=gtk_scrolled_window_get_hscrollbar(scrolledWindow)))            qtcScrolledWindowSetupConnections(child, widget);        if((child=gtk_scrolled_window_get_vscrollbar(scrolledWindow)))            qtcScrolledWindowSetupConnections(child, widget);        if((child=gtk_bin_get_child(GTK_BIN(widget))))        {            if(GTK_IS_TREE_VIEW(child) || GTK_IS_TEXT_VIEW(child) || GTK_IS_ICON_VIEW(child))                qtcScrolledWindowSetupConnections(child, widget);            else            {                const gchar *type=g_type_name(qtcWidgetType(child));                if(type && (0==strcmp(type, "ExoIconView") || 0==strcmp(type, "FMIconContainer")))                    qtcScrolledWindowSetupConnections(child, widget);            }        }        g_object_set_data(G_OBJECT(widget), "QTC_SCROLLED_WINDOW_SET", (gpointer)1);    }}

/** * gwy_grain_value_tree_view_get_expanded_groups: * @treeview: A tree view with grain values. * * Obtains the group expansion state of a grain value tree view. * * Returns: The expansion state, see *          gwy_grain_value_tree_view_set_expanded_groups() for details. * * Since: 2.8 **/guintgwy_grain_value_tree_view_get_expanded_groups(GtkTreeView *treeview){    GtkTreeModel *model;    GtkTreeIter siter;    guint expanded_bits = 0;    g_return_val_if_fail(GTK_IS_TREE_VIEW(treeview), 0);    g_return_val_if_fail(priv_quark                         && g_object_get_qdata(G_OBJECT(treeview), priv_quark),                         0);    model = gtk_tree_view_get_model(treeview);    if (!gtk_tree_model_get_iter_first(model, &siter)) {        g_warning("Grain value tree view is empty?!");        return 0;    }    do {        GwyGrainValueGroup group;        GtkTreePath *path;        gtk_tree_model_get(model, &siter,                           GWY_GRAIN_VALUE_STORE_COLUMN_GROUP, &group,                           -1);        path = gtk_tree_model_get_path(model, &siter);        if (gtk_tree_view_row_expanded(treeview, path))            expanded_bits |= (1 << group);        gtk_tree_path_free(path);    } while (gtk_tree_model_iter_next(model, &siter));    return expanded_bits;}

/* copied from uim-cand-win-gtk.c */static gbooleantree_view_button_press(GtkWidget *widget, GdkEventButton *event, gpointer data){  GtkTreePath *path;  gboolean exist, retval = FALSE;  gint *indicies;  fprintf(stderr, "tree_view_button_press/n");  g_return_val_if_fail(GTK_IS_TREE_VIEW(widget), FALSE);  g_return_val_if_fail(UIM_CANDIDATE_WINDOW(data), FALSE);  /* cwin = UIM_CANDIDATE_WINDOW(data); */  exist = gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(widget),					event->x, event->y,					&path, NULL, NULL, NULL);  if (!exist)    return FALSE;  indicies = gtk_tree_path_get_indices(path);  /* don't relay button press event to empty row */  if (cwin->display_limit * cwin->page_index + *indicies >= cwin->nr_candidates)    retval = TRUE;  gtk_tree_path_free(path);  return retval;}

/**************************************************************************  Mouse button press handler for the message window treeview. We only  care about right clicks on a row; this action centers on the tile  associated with the event at that row (if applicable).**************************************************************************/static gboolean meswin_button_press_callback(GtkWidget *widget,                                             GdkEventButton *ev,                                             gpointer data){  GtkTreePath *path = NULL;  GtkTreeModel *model;  GtkTreeIter iter;  gint row;  g_return_val_if_fail(GTK_IS_TREE_VIEW(widget), FALSE);  if (ev->type != GDK_BUTTON_PRESS || ev->button != 3) {    return FALSE;  }  if (!gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(widget),                                     (gint) ev->x, (gint) ev->y,                                     &path, NULL, NULL, NULL)) {    return TRUE;  }  model = gtk_tree_view_get_model(GTK_TREE_VIEW(widget));  if (gtk_tree_model_get_iter(model, &iter, path)) {    gtk_tree_model_get(model, &iter, 2, &row, -1);    meswin_goto(row);  }  gtk_tree_path_free(path);  return TRUE;}

/**************************************************************************  Convenience function to add a column to a GtkTreeView. Returns the added  column, or NULL if an error occurred.**************************************************************************/GtkTreeViewColumn *add_treeview_column(GtkWidget *view, const char *title,                                       GType gtype, int model_index){  GtkTreeViewColumn *col;  GtkCellRenderer *rend;  const char *attr;  fc_assert_ret_val(view != NULL, NULL);  fc_assert_ret_val(GTK_IS_TREE_VIEW(view), NULL);  fc_assert_ret_val(title != NULL, NULL);  if (gtype == G_TYPE_BOOLEAN) {    rend = gtk_cell_renderer_toggle_new();    attr = "active";  } else if (gtype == GDK_TYPE_PIXBUF) {    rend = gtk_cell_renderer_pixbuf_new();    attr = "pixbuf";  } else {    rend = gtk_cell_renderer_text_new();    attr = "text";  }  col = gtk_tree_view_column_new_with_attributes(title, rend, attr,                                                 model_index, NULL);  gtk_tree_view_append_column(GTK_TREE_VIEW(view), col);  return col;}

static voidgtk_button_accessible_initialize (AtkObject *obj,                                  gpointer   data){  GtkWidget *parent;  ATK_OBJECT_CLASS (gtk_button_accessible_parent_class)->initialize (obj, data);  g_signal_connect (data, "state-flags-changed", G_CALLBACK (state_changed_cb), NULL);  parent = gtk_widget_get_parent (gtk_accessible_get_widget (GTK_ACCESSIBLE (obj)));  if (GTK_IS_TREE_VIEW (parent))    {      /* Even though the accessible parent of the column header will       * be reported as the table because the parent widget of the       * GtkTreeViewColumn's button is the GtkTreeView we set       * the accessible parent for column header to be the table       * to ensure that atk_object_get_index_in_parent() returns       * the correct value; see gail_widget_get_index_in_parent().       */      atk_object_set_parent (obj, gtk_widget_get_accessible (parent));      obj->role = ATK_ROLE_TABLE_COLUMN_HEADER;    }  else    obj->role = ATK_ROLE_PUSH_BUTTON;}

voiduim_cand_win_gtk_layout(UIMCandWinGtk *cwin,                        gint topwin_x, gint topwin_y,                        gint topwin_width, gint topwin_height){    GtkRequisition req;    int  x, y;    int  cursor_x, cursor_y;    int  sc_he, cw_he; /*screen height, candidate window height*/    int  sc_wi, cw_wi;    g_return_if_fail(UIM_IS_CAND_WIN_GTK(cwin));#if GTK_CHECK_VERSION(3, 0, 0)    gtk_widget_get_preferred_size(GTK_WIDGET(cwin), &req, NULL);#else    gtk_widget_size_request(GTK_WIDGET(cwin), &req);#endif    cw_wi = req.width;    cw_he = req.height;    sc_he = gdk_screen_get_height(gdk_screen_get_default ());    sc_wi = gdk_screen_get_width (gdk_screen_get_default ());    /* FIXME */    switch (cwin->position) {    case UIM_CAND_WIN_POS_LEFT:        cursor_x = 0;        break;    case UIM_CAND_WIN_POS_RIGHT:        cursor_x = topwin_width - cw_wi;        break;    default:        cursor_x = cwin->cursor.x;        break;    }    cursor_y = cwin->cursor.y;    if (sc_wi <  topwin_x + cursor_x + cw_wi) {        /* x = topwin_x + cursor_x - cw_wi; */        x = sc_wi - cw_wi;    } else {        x = topwin_x + cursor_x;    }    if (sc_he <  topwin_y + cursor_y +  cwin->cursor.height + cw_he) {        y = topwin_y + cursor_y - cw_he;    } else {        y = topwin_y + cursor_y +  cwin->cursor.height;    }    gtk_window_move(GTK_WINDOW(cwin), x, y);#if GTK_CHECK_VERSION(3, 7, 8)    if (gtk_widget_get_mapped(cwin->view) && GTK_IS_TREE_VIEW(cwin->view))        gtk_widget_queue_resize_no_redraw(cwin->view);#endif    uim_cand_win_gtk_layout_sub_window(cwin);}