RemminaFTPTask* remmina_ftp_client_get_waiting_task(RemminaFTPClient *client) { RemminaFTPClientPriv *priv = (RemminaFTPClientPriv*) client->priv; GtkTreePath *path; GtkTreeIter iter; RemminaFTPTask task; if (!gtk_tree_model_get_iter_first(priv->task_list_model, &iter)) return NULL; while (1) { gtk_tree_model_get(priv->task_list_model, &iter, REMMINA_FTP_TASK_COLUMN_TYPE, &task.type, REMMINA_FTP_TASK_COLUMN_NAME, &task.name, REMMINA_FTP_TASK_COLUMN_SIZE, &task.size, REMMINA_FTP_TASK_COLUMN_TASKID, &task.taskid, REMMINA_FTP_TASK_COLUMN_TASKTYPE, &task.tasktype, REMMINA_FTP_TASK_COLUMN_REMOTEDIR, &task.remotedir, REMMINA_FTP_TASK_COLUMN_LOCALDIR, &task.localdir, REMMINA_FTP_TASK_COLUMN_STATUS, &task.status, REMMINA_FTP_TASK_COLUMN_DONESIZE, &task.donesize, REMMINA_FTP_TASK_COLUMN_TOOLTIP, &task.tooltip, -1); if (task.status == REMMINA_FTP_TASK_STATUS_WAIT) { path = gtk_tree_model_get_path(priv->task_list_model, &iter); task.rowref = gtk_tree_row_reference_new(priv->task_list_model, path); gtk_tree_path_free(path); return (RemminaFTPTask*) g_memdup(&task, sizeof(RemminaFTPTask)); } if (!gtk_tree_model_iter_next(priv->task_list_model, &iter)) break; } return NULL; }
GtkTreePath * gbf_project_model_get_project_root (GbfProjectModel *model) { GtkTreePath *path = NULL; g_return_val_if_fail (GBF_IS_PROJECT_MODEL (model), NULL); if (model->priv->root == NULL) { GtkTreeIter iter; gboolean valid; /* Search root group */ for (valid = gtk_tree_model_iter_children (GTK_TREE_MODEL (model), &iter, NULL); valid; valid = gtk_tree_model_iter_next (GTK_TREE_MODEL (model), &iter)) { GbfTreeData *data; gtk_tree_model_get (GTK_TREE_MODEL (model), &iter, GBF_PROJECT_MODEL_COLUMN_DATA, &data, -1); if (data->type == GBF_TREE_NODE_ROOT) { path = gtk_tree_model_get_path (GTK_TREE_MODEL (model), &iter); model->priv->root = gtk_tree_row_reference_new (GTK_TREE_MODEL (model), path); } } } else { path = gtk_tree_row_reference_get_path (model->priv->root); } return path; }
/* * add empty row */ static void add_empty_row(void) { GtkTreeIter empty; GtkTreePath *path; if (empty_row) gtk_tree_row_reference_free(empty_row); gtk_tree_store_prepend (store, &empty, NULL); gtk_tree_store_set (store, &empty, W_NAME, "", W_VALUE, "", W_TYPE, "", W_LAST_VISIBLE, "", W_INTERNAL, "", W_EXPRESSION, "", W_STUB, 0, W_CHANGED, 0, W_VT, VT_NONE, -1); /* save reference */ path = gtk_tree_model_get_path(GTK_TREE_MODEL(store), &empty); empty_row = gtk_tree_row_reference_new(GTK_TREE_MODEL(store), path); gtk_tree_path_free(path); }
static VALUE treerowref_initialize(int argc, VALUE *argv, VALUE self) { VALUE proxy, model, path; GtkTreeRowReference* ref; if (argc == 3){ rb_scan_args(argc, argv, "3", &proxy, &model, &path); G_CHILD_SET(self, id_proxy, proxy); ref = gtk_tree_row_reference_new_proxy(RVAL2GOBJ(proxy), GTK_TREE_MODEL(RVAL2GOBJ(model)), RVAL2GTKTREEPATH(path)); } else { rb_scan_args(argc, argv, "2", &model, &path); ref = gtk_tree_row_reference_new(GTK_TREE_MODEL(RVAL2GOBJ(model)), RVAL2GTKTREEPATH(path)); } if (ref == NULL) rb_raise(rb_eArgError, "Invalid arguments were passed."); G_CHILD_SET(self, id_model, model); G_CHILD_SET(self, id_path, path); G_INITIALIZE(self, ref); return Qnil; }
static DmaVariablePacket * dma_variable_packet_new(GtkTreeModel *model, GtkTreeIter *iter, DmaDebuggerQueue *debugger, DmaVariableData *data, guint from) { GtkTreePath *path; g_return_val_if_fail (model, NULL); g_return_val_if_fail (iter, NULL); DmaVariablePacket *pack = g_new (DmaVariablePacket, 1); pack->data = data; pack->from = from; pack->model = GTK_TREE_MODEL (model); path = gtk_tree_model_get_path(model, iter); pack->reference = gtk_tree_row_reference_new (model, path); gtk_tree_path_free (path); pack->debugger = debugger; pack->next = data->packet; data->packet = pack; return pack; }
gboolean gtk_cell_view_get_size_of_row (GtkCellView *cell_view, GtkTreePath *path, GtkRequisition *requisition) { GtkTreeRowReference *tmp; GtkRequisition req; g_return_val_if_fail (GTK_IS_CELL_VIEW (cell_view), FALSE); g_return_val_if_fail (path != NULL, FALSE); g_return_val_if_fail (requisition != NULL, FALSE); tmp = cell_view->priv->displayed_row; cell_view->priv->displayed_row = gtk_tree_row_reference_new (cell_view->priv->model, path); gtk_cell_view_size_request (GTK_WIDGET (cell_view), requisition); gtk_tree_row_reference_free (cell_view->priv->displayed_row); cell_view->priv->displayed_row = tmp; /* restore actual size info */ gtk_cell_view_size_request (GTK_WIDGET (cell_view), &req); return TRUE; }
/** * gtk_cell_view_get_size_of_row: * @cell_view: a #GtkCellView * @path: a #GtkTreePath * @requisition: (out): return location for the size * * Sets @requisition to the size needed by @cell_view to display * the model row pointed to by @path. * * Return value: %TRUE * * Since: 2.6 * * Deprecated: 3.0: Combo box formerly used this to calculate the * sizes for cellviews, now you can achieve this by either using * the #GtkCellView:fit-model property or by setting the currently * displayed row of the #GtkCellView and using gtk_widget_get_preferred_size(). */ gboolean gtk_cell_view_get_size_of_row (GtkCellView *cell_view, GtkTreePath *path, GtkRequisition *requisition) { GtkTreeRowReference *tmp; GtkRequisition req; g_return_val_if_fail (GTK_IS_CELL_VIEW (cell_view), FALSE); g_return_val_if_fail (path != NULL, FALSE); tmp = cell_view->priv->displayed_row; cell_view->priv->displayed_row = gtk_tree_row_reference_new (cell_view->priv->model, path); gtk_widget_get_preferred_width (GTK_WIDGET (cell_view), &req.width, NULL); gtk_widget_get_preferred_height_for_width (GTK_WIDGET (cell_view), req.width, &req.height, NULL); gtk_tree_row_reference_free (cell_view->priv->displayed_row); cell_view->priv->displayed_row = tmp; if (requisition) *requisition = req; return TRUE; }
static void wp_props_load_wallpaper (gchar *key, MateWPItem *item, AppearanceData *data) { GtkTreeIter iter; GtkTreePath *path; GdkPixbuf *pixbuf; if (item->deleted == TRUE) return; gtk_list_store_append (GTK_LIST_STORE (data->wp_model), &iter); pixbuf = mate_wp_item_get_thumbnail (item, data->thumb_factory, data->thumb_width, data->thumb_height); mate_wp_item_update_description (item); gtk_list_store_set (GTK_LIST_STORE (data->wp_model), &iter, 0, pixbuf, 1, item, -1); if (pixbuf != NULL) g_object_unref (pixbuf); path = gtk_tree_model_get_path (data->wp_model, &iter); item->rowref = gtk_tree_row_reference_new (data->wp_model, path); g_signal_connect (item->bg, "changed", G_CALLBACK (on_item_changed), data); gtk_tree_path_free (path); }
static void gimp_scale_combo_box_mru_add (GimpScaleComboBox *combo_box, GtkTreeIter *iter) { GtkTreeModel *model = gtk_combo_box_get_model (GTK_COMBO_BOX (combo_box)); GtkTreePath *path = gtk_tree_model_get_path (model, iter); GList *list; gboolean found; for (list = combo_box->mru, found = FALSE; list && !found; list = list->next) { GtkTreePath *this = gtk_tree_row_reference_get_path (list->data); if (gtk_tree_path_compare (this, path) == 0) { if (list->prev) { combo_box->mru = g_list_remove_link (combo_box->mru, list); combo_box->mru = g_list_concat (list, combo_box->mru); } found = TRUE; } gtk_tree_path_free (this); } if (! found) combo_box->mru = g_list_prepend (combo_box->mru, gtk_tree_row_reference_new (model, path)); gtk_tree_path_free (path); }
static void remove_button_clicked(GtkButton *button, XmiMsimGuiLayerDialog *dialog) { GtkTreeModel *model; GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(dialog->compositionTreeView)); GList *selected_rows = gtk_tree_selection_get_selected_rows(selection, &model); gint n_selected_rows = gtk_tree_selection_count_selected_rows(selection); GtkTreeRowReference **refs = (GtkTreeRowReference**) g_malloc(sizeof(GtkTreeRowReference*)*n_selected_rows); int i; // the following really needs two for loops!!! // paths change while rows are being added or removed, while references never change for (i = 0 ; i < n_selected_rows ; i++) { refs[i] = gtk_tree_row_reference_new(model, (GtkTreePath *) g_list_nth_data(selected_rows, i)); } for (i = 0 ; i < n_selected_rows ; i++) { GtkTreePath *path = gtk_tree_row_reference_get_path(refs[i]); GtkTreeIter iter; gtk_tree_model_get_iter(model, &iter, path); //delete row happens here gtk_list_store_remove(GTK_LIST_STORE(model), &iter); gtk_tree_path_free(path); gtk_tree_row_reference_free(refs[i]); } g_list_free_full(selected_rows, (GDestroyNotify) gtk_tree_path_free); g_free(refs); //the sum needs to be updated update_sum(dialog); return; }
/* folder_new */ Folder * folder_new(AccountFolder * folder, FolderType type, char const * name, GtkTreeStore * store, GtkTreeIter * iter) { Folder * ret; GtkTreePath * path; #ifdef DEBUG fprintf(stderr, "DEBUG: %s(\"%s\")\n", __func__, name); #endif if((ret = object_new(sizeof(*ret))) == NULL) return NULL; name = _get_local_name(type, name); ret->name = string_new(name); ret->store = store; path = gtk_tree_model_get_path(GTK_TREE_MODEL(store), iter); ret->row = gtk_tree_row_reference_new(GTK_TREE_MODEL(store), path); gtk_tree_path_free(path); gtk_tree_store_set(store, iter, MFC_FOLDER, ret, MFC_NAME, name, -1); folder_set_type(ret, type); ret->messages = gtk_tree_store_new(MHC_COUNT, G_TYPE_POINTER, G_TYPE_POINTER, G_TYPE_POINTER, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_UINT, G_TYPE_STRING, G_TYPE_BOOLEAN, G_TYPE_UINT); gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(ret->messages), MHC_DATE, GTK_SORT_DESCENDING); ret->data = folder; if(ret->name == NULL) { folder_delete(ret); return NULL; } return ret; }
/* ForEach function. Adds corresponding GtkTreeRowReference to a GList for a GtkTreePath */ void path_to_row_reference(GtkTreePath *path, GList **reference) { *reference = g_list_append(*reference, gtk_tree_row_reference_new(GTK_TREE_MODEL(account_list_store), path)); }
void CExpressDlg::foreach_sel_files(GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer userdata) { GList **list = ((GList**)userdata); GtkTreeRowReference *rowref = gtk_tree_row_reference_new(model, path); *list = g_list_append(*list, rowref); }
void notes_note_delete_selected(Notes * notes) { GtkTreeSelection * treesel; GList * selected; GtkTreeModel * model = GTK_TREE_MODEL(notes->store); GtkTreeRowReference * reference; GList * s; GtkTreePath * path; if((treesel = gtk_tree_view_get_selection(GTK_TREE_VIEW(notes->view))) == NULL) return; if((selected = gtk_tree_selection_get_selected_rows(treesel, NULL)) == NULL) return; if(_notes_confirm(notes->window, _("Are you sure you want to delete the" " selected note(s)?")) != 0) return; for(s = g_list_first(selected); s != NULL; s = g_list_next(s)) { if((path = s->data) == NULL) continue; reference = gtk_tree_row_reference_new(model, path); s->data = reference; gtk_tree_path_free(path); } g_list_foreach(selected, (GFunc)_note_delete_selected_foreach, notes); g_list_free(selected); }
static void configure_combo_box_add (GtkComboBox *combo_box, const gchar *item, const gchar *value) { GtkTreeRowReference *reference; GtkTreeModel *model; GtkTreePath *path; GHashTable *index; GtkTreeIter iter; model = gtk_combo_box_get_model (combo_box); gtk_list_store_append (GTK_LIST_STORE (model), &iter); gtk_list_store_set ( GTK_LIST_STORE (model), &iter, COLUMN_ITEM, item, COLUMN_VALUE, value, -1); index = g_object_get_data (G_OBJECT (combo_box), "index"); g_return_if_fail (index != NULL); /* Add an entry to the tree model index. */ path = gtk_tree_model_get_path (model, &iter); reference = gtk_tree_row_reference_new (model, path); g_return_if_fail (reference != NULL); g_hash_table_insert (index, g_strdup (value), reference); gtk_tree_path_free (path); }
void wp_add(GtkWidget *cat_tree) { GtkTreePath *path = NULL; GtkListStore *pl3_tree = (GtkListStore *)gtk_tree_view_get_model(GTK_TREE_VIEW(cat_tree)); GtkTreeIter iter; if(!cfg_get_single_value_as_int_with_default(config, "wp-plugin", "enable", 0)) return; gtk_list_store_append(pl3_tree, &iter); gtk_list_store_set(pl3_tree, &iter, PL3_CAT_TYPE, plugin.id, PL3_CAT_TITLE, _("Wikipedia Lookup"), PL3_CAT_ICON_ID, "wikipedia", -1); if (wiki_ref) { gtk_tree_row_reference_free(wiki_ref); wiki_ref = NULL; } path = gtk_tree_model_get_path(GTK_TREE_MODEL(playlist3_get_category_tree_store()), &iter); if (path) { wiki_ref = gtk_tree_row_reference_new(GTK_TREE_MODEL(playlist3_get_category_tree_store()), path); gtk_tree_path_free(path); } }
static void on_remove_autorun_choice_clicked(GtkButton *button, GtkTreeView *view) { GtkTreeSelection *tree_sel = gtk_tree_view_get_selection(view); GtkTreeModel *model; GList *rows = gtk_tree_selection_get_selected_rows(tree_sel, &model), *l; GtkTreeIter it; /* convert paths to references */ for (l = rows; l; l = l->next) { GtkTreePath *tp = l->data; l->data = gtk_tree_row_reference_new(model, tp); gtk_tree_path_free(tp); } /* remove rows from model */ for (l = rows; l; l = l->next) { if (gtk_tree_model_get_iter(model, &it, gtk_tree_row_reference_get_path(l->data))) { char *type; gtk_tree_model_get(model, &it, 2, &type, -1); if (type) g_hash_table_remove(app_config->autorun_choices, type); g_free(type); gtk_list_store_remove(GTK_LIST_STORE(model), &it); } else g_critical("autorun_choice not found in model"); gtk_tree_row_reference_free(l->data); } g_list_free(rows); }
static void remove_events(GtkButton *remove, GtkTreeView *treeview) { GtkTreeSelection *selection; GtkTreeRowReference *ref; GtkTreeModel *model; GList *rows, *ptr, *references = NULL; selection = gtk_tree_view_get_selection(treeview); model = gtk_tree_view_get_model(treeview); rows = gtk_tree_selection_get_selected_rows(selection, &model); ptr = rows; while (ptr != NULL) { ref = gtk_tree_row_reference_new(model, (GtkTreePath*)ptr->data); references = g_list_prepend(references, gtk_tree_row_reference_copy(ref)); gtk_tree_row_reference_free(ref); ptr = ptr->next; } g_list_foreach(references, (GFunc)remove_row, model); g_list_foreach(references, (GFunc)gtk_tree_row_reference_free, NULL); g_list_foreach(rows, (GFunc)gtk_tree_path_free, NULL); g_list_free(references); g_list_free(rows); }
static void add_one_category (GncExampleAccount *acc, hierarchy_data *data) { GtkTreeView *view; GtkListStore *store; GtkTreeIter iter; GtkTreePath* path; gboolean use_defaults; g_return_if_fail(acc != NULL); g_return_if_fail(data != NULL); view = data->categories_tree; store = GTK_LIST_STORE(gtk_tree_view_get_model(view)); use_defaults = data->use_defaults && acc->start_selected; gtk_list_store_append(store, &iter); gtk_list_store_set(store, &iter, COL_CHECKED, use_defaults, COL_TITLE, acc->title, COL_SHORT_DESCRIPTION, acc->short_description, COL_LONG_DESCRIPTION, acc->long_description, COL_ACCOUNT, acc, -1); if (use_defaults) { data->category_set_changed = TRUE; path = gtk_tree_model_get_path(GTK_TREE_MODEL(store), &iter); data->initial_category = gtk_tree_row_reference_new(GTK_TREE_MODEL(store), path); gtk_tree_path_free(path); } }
void cb_auth_cell_edited(GtkCellRendererText *cell, const gchar *path_string, const gchar *new_text, gpointer data) { GtkTreeModel *model = (GtkTreeModel *) data; GtkTreePath *path = gtk_tree_path_new_from_string(path_string); GtkTreeIter iter; GSList *iterator; GtkTreeRowReference *cur_iter; gboolean in = FALSE; cur_iter = gtk_tree_row_reference_new(model, path); gint column = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(cell), "column")); gtk_tree_model_get_iter(model, &iter, path); gtk_list_store_set(GTK_LIST_STORE(model), &iter, column, new_text, -1); for (iterator = upt_list; iterator; iterator = iterator->next) { if (cur_iter == iterator->data) { in = TRUE; break; } } if(!in) { upt_list = g_slist_append(upt_list, cur_iter); } gtk_tree_path_free(path); }
void on_tabu_playlist_row_activated_event ( GtkTreeView *view ) { GList *selected; GtkTreeModel *store; GtkTreeIter iter; gchar *uri; GtkTreeSelection *selection = gtk_tree_view_get_selection ( view ); selected = gtk_tree_selection_get_selected_rows ( selection, &store ); if (gtk_tree_model_get_iter (GTK_TREE_MODEL (store), &iter, selected->data)) { gtk_tree_model_get (GTK_TREE_MODEL (store), &iter, 2, &uri, -1); tabu_playlist_set_song (tabu_get_playlist(), FALSE); TABU_PLAYLIST (tabu_get_playlist())->reference = gtk_tree_row_reference_new (store, selected->data); tabu_playlist_set_song (tabu_get_playlist(), TRUE); tabu_backend_play_uri (uri); } g_list_foreach (selected, (GFunc) gtk_tree_path_free, NULL); g_list_free (selected); }
static GList * gnac_profiles_mgr_get_selected_rows(void) { GtkTreeModel *model = GTK_TREE_MODEL( gnac_profiles_mgr_get_object("liststore")); GtkTreeView *view = GTK_TREE_VIEW( gnac_profiles_mgr_get_widget("profile_treeview")); GtkTreeSelection *selection = gtk_tree_view_get_selection(view); /* Convert path to GtkTreeRowReference */ GList *next = gtk_tree_selection_get_selected_rows(selection, &model); GList *next_temp = next; GList *row_references = NULL; while (next) { row_references = g_list_prepend(row_references, gtk_tree_row_reference_new(model, next->data)); next = g_list_next(next); } row_references = g_list_reverse(row_references); g_list_free_full(next_temp, (GDestroyNotify) gtk_tree_path_free); return row_references; }
static void key_store_row_add (CryptUIKeyStore *ckstore, const gchar *key, GtkTreeIter *iter) { GtkTreePath *path; GtkTreeRowReference *ref; /* Do we already have a row for this key? */ ref = (GtkTreeRowReference*)g_hash_table_lookup (ckstore->priv->rows, key); if (ref != NULL) { /* If so return the previous reference */ path = gtk_tree_row_reference_get_path (ref); if (path != NULL) { gtk_tree_model_get_iter (GTK_TREE_MODEL (ckstore->priv->store), iter, path); return; } } gtk_tree_store_append (GTK_TREE_STORE (ckstore->priv->store), iter, NULL); path = gtk_tree_model_get_path (GTK_TREE_MODEL (ckstore->priv->store), iter); ref = gtk_tree_row_reference_new (GTK_TREE_MODEL (ckstore->priv->store), path); gtk_tree_path_free (path); g_hash_table_replace (ckstore->priv->rows, (gchar*)key, ref); gtk_tree_store_set (GTK_TREE_STORE (ckstore->priv->store), iter, CRYPTUI_KEY_STORE_KEY, key, -1); }
void list_remove_selection(void) { GList *rows = gtk_tree_selection_get_selected_rows(gui.treeselection, &gui.treemodel); for (GList *i = rows; i != NULL; i = i->next) { GtkTreePath *path = i->data; GtkTreeRowReference *ref = gtk_tree_row_reference_new(gui.treemodel, i->data); i->data = ref; gtk_tree_path_free(path); } for (GList *i = rows; i != NULL; i = i->next) { GtkTreeRowReference *ref = i->data; GtkTreePath *path = gtk_tree_row_reference_get_path(ref); GtkTreeIter iter; if (gtk_tree_model_get_iter(gui.treemodel, &iter, path)) gtk_list_store_remove(gui.liststore, &iter); gtk_tree_path_free(path); gtk_tree_row_reference_free(ref); } g_list_free(rows); if (list_count_rows() == 0) { gtk_widget_set_sensitive(GTK_WIDGET(gui.toolbutton_clear), false); gtk_widget_set_sensitive(GTK_WIDGET(gui.menuitem_treeview_clear), false); gtk_widget_set_sensitive(GTK_WIDGET(gui.button_hash), false); } }
static inline GtkTreeRowReference * do_add_root_symbol_to_view (SymbolDBViewLocals *dbvl, const GdkPixbuf *pixbuf, const gchar* symbol_name, gint symbol_id) { SymbolDBViewLocalsPriv *priv; GtkTreeStore *store; GtkTreeIter child_iter; GtkTreePath *path; GtkTreeRowReference *row_ref; g_return_val_if_fail (dbvl != NULL, NULL); priv = dbvl->priv; store = GTK_TREE_STORE (gtk_tree_view_get_model (GTK_TREE_VIEW (dbvl))); if (store == NULL) return NULL; gtk_tree_store_append (store, &child_iter, NULL); gtk_tree_store_set (store, &child_iter, COLUMN_PIXBUF, pixbuf, COLUMN_NAME, symbol_name, COLUMN_SYMBOL_ID, symbol_id, -1); path = gtk_tree_model_get_path (gtk_tree_view_get_model (GTK_TREE_VIEW (dbvl)), &child_iter); row_ref = gtk_tree_row_reference_new ( gtk_tree_view_get_model (GTK_TREE_VIEW (dbvl)), path); gtk_tree_path_free (path); return row_ref; }
static void remote_editor_tree_selection_get_branches (GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, GList **branches) { *branches = g_list_prepend (*branches, gtk_tree_row_reference_new (model, path)); }
static gboolean foreach_all_files(GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer userdata) { GList **list = ((GList**)userdata); GtkTreeRowReference *rowref = gtk_tree_row_reference_new(model, path); *list = g_list_append(*list, rowref); return FALSE; }
/** @brief create a tree row reference for @a iter in @a store @param store pointer to treestore @param iter pointer to treeiter to be referenced @return the reference */ GtkTreeRowReference *e2_tree_iter_to_ref (GtkTreeStore *store, GtkTreeIter *iter) { GtkTreePath *path = gtk_tree_model_get_path (GTK_TREE_MODEL (store), iter); GtkTreeRowReference *ref = gtk_tree_row_reference_new (GTK_TREE_MODEL (store), path); gtk_tree_path_free (path); return ref; }
/* Delete button was clicked on selection */ void _nojs_preferences_on_delete_selection(NoJSPreferences *self, GtkButton *inButton) { NoJSPreferencesPrivate *priv=self->priv; GList *rows, *row, *refs=NULL; GtkTreeRowReference *ref; GtkTreeModel *model=GTK_TREE_MODEL(priv->listStore); GtkTreeIter iter; GtkTreePath *path; gchar *domain; gchar *sql; gint success; gchar *error; /* Get selected rows in list and create a row reference because * we will modify the model while iterating through selected rows */ rows=gtk_tree_selection_get_selected_rows(priv->listSelection, &model); for(row=rows; row; row=row->next) { ref=gtk_tree_row_reference_new(model, (GtkTreePath*)row->data); refs=g_list_prepend(refs, ref); } g_list_foreach(rows,(GFunc)gtk_tree_path_free, NULL); g_list_free(rows); /* Delete each selected row by its reference */ for(row=refs; row; row=row->next) { /* Get domain from selected row */ path=gtk_tree_row_reference_get_path((GtkTreeRowReference*)row->data); gtk_tree_model_get_iter(model, &iter, path); gtk_tree_model_get(model, &iter, DOMAIN_COLUMN, &domain, -1); /* Delete domain from database */ sql=sqlite3_mprintf("DELETE FROM policies WHERE site='%q';", domain); success=sqlite3_exec(priv->database, sql, NULL, NULL, &error); if(success!=SQLITE_OK || error) { if(error) { g_critical(_("Failed to execute database statement: %s"), error); sqlite3_free(error); } else g_critical(_("Failed to execute database statement: %s"), sqlite3_errmsg(priv->database)); } sqlite3_free(sql); /* Delete row from model */ gtk_list_store_remove(priv->listStore, &iter); } g_list_foreach(refs,(GFunc)gtk_tree_row_reference_free, NULL); g_list_free(refs); }
void UzblTreeTab::RebuildTree() { int i = 0; for(GList* l = uzblinstances; l != NULL; l = g_list_next(l)) { UzblInstance* cuz = (UzblInstance*)l->data; cuz->SetNum(i); cuz->SetPNum(-1); cuz->ClearChildren(); cuz->SetRowRef(NULL); i++; } for(GList* l = uzblinstances; l != NULL; l = g_list_next(l)) { UzblInstance* cuz = (UzblInstance*)l->data; if (cuz->GetParent() != NULL) { cuz->SetPNum(cuz->GetParent()->GetNum()); cuz->GetParent()->AddChild(cuz); } } totaltabs = i; if (currenttab >= totaltabs) currenttab = totaltabs-1; if (currenttab < 0) currenttab = 0; gtk_tree_store_clear(tabmodel); for(GList* l = uzblinstances; l != NULL; l = g_list_next(l)) { UzblInstance* iuz = ((UzblInstance*)l->data); GtkTreeIter iter; if (iuz->GetParent() != NULL) { GtkTreeIter piter; GtkTreeRowReference* pr = iuz->GetParent()->GetRowRef(); GtkTreePath* pp = gtk_tree_row_reference_get_path(pr); gtk_tree_model_get_iter(GTK_TREE_MODEL(tabmodel), &piter, pp); gtk_tree_store_append(tabmodel, &iter, &piter); } else { gtk_tree_store_append(tabmodel, &iter, NULL); } GtkTreePath* p = gtk_tree_model_get_path(GTK_TREE_MODEL(tabmodel), &iter); GtkTreeRowReference* ref = gtk_tree_row_reference_new(GTK_TREE_MODEL(tabmodel), p); iuz->SetRowRef(ref); } gtk_tree_view_expand_all(tabtree); GtkTreeIter siter; UzblInstance* suz = (UzblInstance*)g_list_nth(uzblinstances, currenttab)->data; GtkTreeRowReference* sr = suz->GetRowRef(); GtkTreePath* sp = gtk_tree_row_reference_get_path(sr); gtk_tree_model_get_iter(GTK_TREE_MODEL(tabmodel), &siter, sp); GtkTreeSelection* sel = gtk_tree_view_get_selection(tabtree); gtk_tree_selection_select_iter(sel, &siter); }