void GtkCatalogModel_insert_record(GtkCatalogModel * custom_list, gint recordIndex) { GtkTreeIter iter; GtkTreePath *path; CatalogRecord record; g_return_if_fail (GTKCATALOGMODEL_IS_LIST(custom_list)); g_return_if_fail (recordIndex <= CatalogDB_getRecordCount(custom_list->catalogDB)); CatalogRecord_init(&record); if (CatalogRecord_edit(&record)) { CatalogDB_insertRecord(custom_list->catalogDB, recordIndex, &record); /* inform the tree view and other interested objects * (e.g. tree row references) that we have inserted * a new row, and where it was inserted */ path = gtk_tree_path_new(); gtk_tree_path_append_index(path, recordIndex); GtkCatalogModel_get_iter(GTK_TREE_MODEL(custom_list), &iter, path); gtk_tree_model_row_inserted(GTK_TREE_MODEL(custom_list), path, &iter); gtk_tree_path_free(path); } CatalogRecord_finalize(&record); }
void moose_list_model_append_record(MooseListModel *self, const gchar *name, guint year_born) { GtkTreeIter iter; GtkTreePath *path; gulong newsize; guint pos; MooseListModelRecord *newrecord; g_return_if_fail(MOOSE_IS_LIST_MODEL(self)); g_return_if_fail(name != NULL); pos = self->priv->num_rows++; newsize = self->priv->num_rows * sizeof(MooseListModelRecord *); self->priv->rows = g_realloc(self->priv->rows, newsize); newrecord = g_new0(MooseListModelRecord, 1); newrecord->name = g_strdup(name); newrecord->year_born = year_born; self->priv->rows[pos] = newrecord; newrecord->pos = pos; /* inform the tree view and other interested objects * (e.g. tree row references) that we have inserted * a new row, and where it was inserted */ path = gtk_tree_path_new_from_indices(newrecord->pos, -1); moose_list_model_get_iter(GTK_TREE_MODEL(self), &iter, path); gtk_tree_model_row_inserted(GTK_TREE_MODEL(self), path, &iter); gtk_tree_path_free(path); }
void fm_dir_tree_model_add_root (FmDirTreeModel *dir_tree_model, FmFileInfo *root, GtkTreeIter *iter, gboolean can_expand) { FmDirTreeItem *dir_tree_item = fm_dir_tree_item_new (dir_tree_model, NULL, root); dir_tree_model->root_list = g_list_append (dir_tree_model->root_list, dir_tree_item); GList *item_list = g_list_last (dir_tree_model->root_list); // TODO_axl : add a can_expand flag in the file info with fm_file_info_set_can_expand () accessor... if (can_expand) fm_dir_tree_model_add_place_holder_child_item (dir_tree_model, item_list, NULL, FALSE); // Convert the new item to an iterator... GtkTreeIter it; fm_dir_tree_model_item_to_tree_iter (dir_tree_model, item_list, &it); GtkTreePath *tree_path = fm_dir_tree_model_item_to_tree_path (dir_tree_model, item_list); // Emit row-inserted signal for the new root item... gtk_tree_model_row_inserted (GTK_TREE_MODEL (dir_tree_model), tree_path, &it); // Output the iterator... if (iter) *iter = it; gtk_tree_path_free (tree_path); }
void custom_list_append (CustomList * custom_list, chanlistrow * newrecord) { GtkTreeIter iter; GtkTreePath *path; gulong newsize; guint pos; if (custom_list->num_rows >= custom_list->num_alloc) { custom_list->num_alloc += 64; newsize = custom_list->num_alloc * sizeof (chanlistrow *); custom_list->rows = g_realloc (custom_list->rows, newsize); } /* TODO: Binary search insert? */ pos = custom_list->num_rows; custom_list->rows[pos] = newrecord; custom_list->num_rows++; newrecord->pos = pos; /* inform the tree view and other interested objects * (e.g. tree row references) that we have inserted * a new row, and where it was inserted */ path = gtk_tree_path_new (); gtk_tree_path_append_index (path, newrecord->pos); /* custom_list_get_iter(GTK_TREE_MODEL(custom_list), &iter, path);*/ iter.user_data = newrecord; gtk_tree_model_row_inserted (GTK_TREE_MODEL (custom_list), path, &iter); gtk_tree_path_free (path); }
static void update_length (BtSequenceGridModel * model, gulong old_length, gulong new_length) { GtkTreePath *path; glong i; GST_INFO ("resize length : %lu -> %lu", old_length, new_length); if (old_length < new_length) { GtkTreeIter iter; // trigger row-inserted iter.stamp = model->priv->stamp; for (i = old_length; i < new_length; i++) { iter.user_data = GUINT_TO_POINTER (i); path = gtk_tree_path_new (); gtk_tree_path_append_index (path, i); gtk_tree_model_row_inserted (GTK_TREE_MODEL (model), path, &iter); gtk_tree_path_free (path); } } else if (old_length > new_length) { // trigger row-deleted for (i = old_length - 1; i >= new_length; i--) { path = gtk_tree_path_new (); gtk_tree_path_append_index (path, i); gtk_tree_model_row_deleted (GTK_TREE_MODEL (model), path); gtk_tree_path_free (path); } } }
static void bt_pattern_list_model_add (BtPatternListModel * model, BtCmdPattern * pattern) { GSequence *seq = model->priv->seq; GtkTreePath *path; GtkTreeIter iter; gint position; // check if pattern is internal if (model->priv->skip_internal) { if (!BT_IS_PATTERN (pattern)) { GST_INFO ("not adding internal pattern to model"); return; } } GST_INFO ("add pattern to model"); // insert new entry iter.stamp = model->priv->stamp; iter.user_data = g_sequence_insert_sorted (seq, pattern, model_item_cmp, NULL); position = g_sequence_iter_get_position (iter.user_data); g_signal_connect_object (pattern, "notify::name", G_CALLBACK (on_pattern_name_changed), (gpointer) model, 0); // signal to the view/app path = gtk_tree_path_new (); gtk_tree_path_append_index (path, position); gtk_tree_model_row_inserted (GTK_TREE_MODEL (model), path, &iter); gtk_tree_path_free (path); GST_DEBUG ("inserted pattern %p at position %d", pattern, position); }
static void fm_dir_tree_model_add_place_holder_child_item (FmDirTreeModel *dir_tree_model, GList *parent_node, GtkTreePath *tree_path, gboolean emit_signal) { FmDirTreeItem *parent_item = (FmDirTreeItem*) parent_node->data; // Check if the parent node can expand... FmFileInfo *file_info = parent_item->file_info; FmPath *path = fm_file_info_get_path (file_info); TREEVIEW_DEBUG ("TREEVIEW_DEBUG: fm_dir_tree_model_add_place_holder_child_item: file = %s\t emit_signal = %d\n", fm_file_info_get_name (file_info), emit_signal); // don't expand the trash can... // TODO_axl: add a can_expand flag into the file_info if (fm_path_is_trash (path) && fm_path_is_root (path)) return; TREEVIEW_DEBUG ("TREEVIEW_DEBUG: fm_dir_tree_model_add_place_holder_child_item: create place holder\n\n"); FmDirTreeItem *dir_tree_item = fm_dir_tree_item_new (dir_tree_model, parent_node, NULL); parent_item->children = g_list_prepend (parent_item->children, dir_tree_item); if (!emit_signal) return; GtkTreeIter it; fm_dir_tree_model_item_to_tree_iter (dir_tree_model, parent_item->children, &it); gtk_tree_path_append_index (tree_path, 0); gtk_tree_model_row_inserted (GTK_TREE_MODEL (dir_tree_model), tree_path, &it); gtk_tree_path_up (tree_path); }
/* listen on the diagram for object add/remove */ static void _object_add (DiagramData *dia, Layer *layer, DiaObject *obj, DiagramTreeModel *dtm) { GtkTreePath *path; GtkTreeIter _iter; GtkTreeIter *iter = &_iter; /* a bit backward: the first child is in the diagram, but not the tree yet */ gboolean had_child = layer_object_count (layer) > 1; g_return_if_fail (DIA_DIAGRAM(dia) != NULL); NODE_DIAGRAM(iter) = dia; NODE_LAYER(iter) = layer; NODE_OBJECT(iter) = obj; /* FIXME: this may get called before the layer is added to the tree */ path = _dtm_get_path (GTK_TREE_MODEL (dtm), iter); if (path) { gtk_tree_model_row_inserted (GTK_TREE_MODEL (dtm), path, iter); /* enforce update */ if (!had_child && gtk_tree_path_up (path)) gtk_tree_model_row_has_child_toggled (GTK_TREE_MODEL (dtm), path, &_iter); gtk_tree_path_free (path); } }
static void report_row_inserted (FMTreeModel *model, GtkTreeIter *iter) { GtkTreePath *path; path = gtk_tree_model_get_path (GTK_TREE_MODEL (model), iter); gtk_tree_model_row_inserted (GTK_TREE_MODEL (model), path, iter); gtk_tree_path_free (path); }
static void gbase_list_row_prepended(GBaseList *self) { GtkTreePath *path = gtk_tree_path_new(); gtk_tree_path_append_index(path, 0); // base_prepend() inserts at head => position 0 GtkTreeIter iter; gbase_list_get_iter(GTK_TREE_MODEL(self), &iter, path); gtk_tree_model_row_inserted(GTK_TREE_MODEL(self), path, &iter); gtk_tree_path_free(path); }
static void emit_row_inserted_for_tree_cb (gpointer item, gpointer user_data) { g_autoptr(GtkTreePath) path = NULL; DspyIntrospectionModel *self = user_data; GtkTreeIter iter = { .user_data = item, }; path = gtk_tree_model_get_path (GTK_TREE_MODEL (self), &iter); gtk_tree_model_row_inserted (GTK_TREE_MODEL (self), path, &iter); }
void fm_folder_model_set_show_hidden(FmFolderModel* model, gboolean show_hidden) { FmFolderItem* item; GList *l, *next; GSequenceIter *items_it; g_return_if_fail(model != NULL); if( model->show_hidden == show_hidden ) return; model->show_hidden = show_hidden; if( show_hidden ) /* add previously hidden items back to the list */ { GSequenceIter *hidden_it = g_sequence_get_begin_iter(model->hidden); while( !g_sequence_iter_is_end(hidden_it) ) { GtkTreeIter it; GSequenceIter *next_hidden_it; GSequenceIter *insert_item_it = g_sequence_search(model->items, g_sequence_get(hidden_it), fm_folder_model_compare, model); next_hidden_it = g_sequence_iter_next(hidden_it); item = (FmFolderItem*)g_sequence_get(hidden_it); it.stamp = model->stamp; it.user_data = hidden_it; g_sequence_move(hidden_it, insert_item_it); GtkTreePath *path = gtk_tree_path_new_from_indices(g_sequence_iter_get_position(hidden_it), -1); gtk_tree_model_row_inserted(GTK_TREE_MODEL(model), path, &it); gtk_tree_path_free(path); hidden_it = next_hidden_it; } } else /* move invisible items to hidden list */ { GSequenceIter *items_it = g_sequence_get_begin_iter(model->items); while( !g_sequence_iter_is_end(items_it) ) { GtkTreePath* tp; GSequenceIter *next_item_it = g_sequence_iter_next(items_it); item = (FmFolderItem*)g_sequence_get(items_it); if( fm_file_info_is_hidden(item->inf) ) { gint delete_pos = g_sequence_iter_get_position(items_it); g_sequence_move( items_it, g_sequence_get_begin_iter(model->hidden) ); tp = gtk_tree_path_new_from_indices(delete_pos, -1); /* tell everybody that we removed an item */ gtk_tree_model_row_deleted(GTK_TREE_MODEL(model), tp); gtk_tree_path_free(tp); } items_it = next_item_it; } } }
static void row_added (EDateTimeList *date_time_list, gint n) { GtkTreePath *path; GtkTreeIter iter; path = gtk_tree_path_new (); gtk_tree_path_append_index (path, n); if (gtk_tree_model_get_iter (GTK_TREE_MODEL (date_time_list), &iter, path)) gtk_tree_model_row_inserted (GTK_TREE_MODEL (date_time_list), path, &iter); gtk_tree_path_free (path); }
void replay_message_tree_append_child(ReplayMessageTree *self, GtkTreeIter *parent, const gchar *name, GtkTreeIter *child_iter) { ReplayMessageTreeEntry *parent_event = NULL; ReplayMessageTreePrivate *priv; ReplayMessageTreeEntry *entry; GtkTreeIter iter; g_return_if_fail(REPLAY_IS_MESSAGE_TREE(self)); g_return_if_fail(name != NULL); priv = self->priv; /* if parent is non-null, otherwise append as a root node */ if (parent) { g_return_if_fail(parent->stamp == priv->stamp); g_return_if_fail(parent->user_data != NULL); parent_event = (ReplayMessageTreeEntry *)parent->user_data; } entry = g_malloc0(sizeof(*entry)); entry->name = g_strdup(name); entry->parent = parent_event; insert_event_with_parent(self, entry, parent_event); g_hash_table_insert(priv->name_table, entry->name, entry); gtk_tree_model_get_iter(GTK_TREE_MODEL(self), &iter, entry->tree_path); /* give back an iter to this newly added entry */ if (child_iter) { child_iter->user_data = iter.user_data; child_iter->user_data2 = iter.user_data2; child_iter->user_data3 = iter.user_data3; child_iter->stamp = iter.stamp; } /* emit signals that we've added a row */ gtk_tree_model_row_inserted(GTK_TREE_MODEL(self), entry->tree_path, &iter); }
static void add_dummy_row (FMListModel *model, FileEntry *parent_entry) { FileEntry *dummy_file_entry; GtkTreeIter iter; GtkTreePath *path; dummy_file_entry = g_new0 (FileEntry, 1); dummy_file_entry->parent = parent_entry; dummy_file_entry->ptr = g_sequence_insert_sorted (parent_entry->files, dummy_file_entry, fm_list_model_file_entry_compare_func, model); iter.stamp = model->details->stamp; iter.user_data = dummy_file_entry->ptr; path = gtk_tree_model_get_path (GTK_TREE_MODEL (model), &iter); gtk_tree_model_row_inserted (GTK_TREE_MODEL (model), path, &iter); gtk_tree_path_free (path); }
void custom_list_append_record (CustomList *custom_list, const gchar *name, guint year_born) { GtkTreeIter iter; GtkTreePath *path; CustomRecord *newrecord; gulong newsize; guint pos; g_return_if_fail (CUSTOM_IS_LIST(custom_list)); g_return_if_fail (name != NULL); pos = custom_list->num_rows; custom_list->num_rows++; newsize = custom_list->num_rows * sizeof(CustomRecord*); custom_list->rows = g_realloc(custom_list->rows, newsize); newrecord = g_new0(CustomRecord, 1); newrecord->name = g_strdup(name); newrecord->name_collate_key = g_utf8_collate_key(name,-1); /* for fast sorting, used later */ newrecord->year_born = year_born; custom_list->rows[pos] = newrecord; newrecord->pos = pos; /* inform the tree view and other interested objects * (e.g. tree row references) that we have inserted * a new row, and where it was inserted */ path = gtk_tree_path_new(); gtk_tree_path_append_index(path, newrecord->pos); custom_list_get_iter(GTK_TREE_MODEL(custom_list), &iter, path); gtk_tree_model_row_inserted(GTK_TREE_MODEL(custom_list), path, &iter); gtk_tree_path_free(path); }
void trace_view_store_append_record (TraceViewStore *trace_view_store, const gchar *name, guint year_born) { GtkTreeIter iter; GtkTreePath *path; TraceViewRecord *newrecord; gulong newsize; guint pos; g_return_if_fail (TRACE_VIEW_IS_LIST(trace_view_store)); g_return_if_fail (name != NULL); pos = trace_view_store->num_rows; trace_view_store->num_rows++; newsize = trace_view_store->num_rows * sizeof(TraceViewRecord*); trace_view_store->rows = g_realloc(trace_view_store->rows, newsize); newrecord = g_new0(TraceViewRecord, 1); newrecord->name = g_strdup(name); newrecord->name_collate_key = g_utf8_collate_key(name,-1); /* for fast sorting, used later */ newrecord->year_born = year_born; trace_view_store->rows[pos] = newrecord; newrecord->pos = pos; /* inform the tree view and other interested objects * (e.g. tree row references) that we have inserted * a new row, and where it was inserted */ path = gtk_tree_path_new(); gtk_tree_path_append_index(path, newrecord->pos); trace_view_store_get_iter(GTK_TREE_MODEL(trace_view_store), &iter, path); gtk_tree_model_row_inserted(GTK_TREE_MODEL(trace_view_store), path, &iter); gtk_tree_path_free(path); }
void ptk_file_list_file_created( VFSDir* dir, VFSFileInfo* file, PtkFileList* list ) { GList* l; GtkTreeIter it; GtkTreePath* path; VFSFileInfo* file2; if( ! list->show_hidden && vfs_file_info_get_name(file)[0] == '.' ) return; for( l = list->files; l; l = l->next ) { file2 = (VFSFileInfo*)l->data; if( G_UNLIKELY( file == file2 || ptk_file_list_compare( file2, file, list ) == 0 ) ) { /* The file is already in the list */ return; } if( ptk_file_list_compare( file2, file, list ) > 0 ) { break; } } list->files = g_list_insert_before( list->files, l, vfs_file_info_ref( file ) ); ++list->n_files; if( l ) l = l->prev; else l = g_list_last( list->files ); it.stamp = list->stamp; it.user_data = l; it.user_data2 = file; path = gtk_tree_path_new_from_indices( g_list_index(list->files, l->data), -1 ); gtk_tree_model_row_inserted( GTK_TREE_MODEL(list), path, &it ); gtk_tree_path_free( path ); }
static void on_pattern_name_changed (BtPattern * pattern, GParamSpec * arg, gpointer user_data) { BtPatternListModel *model = BT_PATTERN_LIST_MODEL (user_data); GSequence *seq = model->priv->seq; GtkTreePath *path; GtkTreeIter iter; gint pos1, pos2 = -1, len; // find the item by pattern (cannot use model_item_cmp, as id has changed) iter.stamp = model->priv->stamp; len = g_sequence_get_length (seq); for (pos1 = 0; pos1 < len; pos1++) { iter.user_data = g_sequence_get_iter_at_pos (seq, pos1); if (g_sequence_get (iter.user_data) == pattern) { g_sequence_sort_changed (iter.user_data, model_item_cmp, NULL); pos2 = g_sequence_iter_get_position (iter.user_data); break; } } if (G_UNLIKELY (pos2 == -1)) return; GST_DEBUG ("pos %d -> %d", pos1, pos2); // signal updates if (pos1 != pos2) { path = gtk_tree_path_new (); gtk_tree_path_append_index (path, pos1); gtk_tree_model_row_deleted (GTK_TREE_MODEL (model), path); gtk_tree_path_free (path); path = gtk_tree_path_new (); gtk_tree_path_append_index (path, pos2); gtk_tree_model_row_inserted (GTK_TREE_MODEL (model), path, &iter); gtk_tree_path_free (path); } else { path = gtk_tree_path_new (); gtk_tree_path_append_index (path, pos2); gtk_tree_model_row_changed (GTK_TREE_MODEL (model), path, &iter); gtk_tree_path_free (path); } }
/* Add the header, and emit the "row-inserted" signal. */ static void show_header (GtkSourceCompletionModel *model, GList *provider_node) { ProviderInfo *provider_info = provider_node->data; add_header (provider_node); if (provider_info->visible) { GtkTreePath *path = get_proposal_path (model, provider_info->proposals->head); GtkTreeIter iter; iter.user_data = provider_info->proposals->head; gtk_tree_model_row_inserted (GTK_TREE_MODEL (model), path, &iter); gtk_tree_path_free (path); } }
/* * MODELCHANGES * * No matter if we are wrapped in the SortModel change signals are always * sent to this model. In the sortable case the GtkTreeModelSort translates * them to the right coordinates for the tree view. */ static gboolean _recurse_row_inserted (GtkTreeModel *model, GtkTreeIter *parent) { GtkTreeIter iter; int n = 0; while (_dtm_iter_nth_child (model, &iter, parent, n)) { GtkTreePath *path = _dtm_get_path (model, &iter); gtk_tree_model_row_inserted (model, path, &iter); /* gtk_tree_model_row_has_child_toggled * ... emitted when a row has gotten the first child row ... * So no need to do it here. Or maybe not for the sorted model? */ if (_recurse_row_inserted (model, &iter)) gtk_tree_model_row_has_child_toggled (model, path, &iter); gtk_tree_path_free (path); ++n; } return (n > 0); }
void _fm_folder_model_insert_item(FmFolder* dir, FmFolderItem* new_item, FmFolderModel* model) { GList* l; GtkTreeIter it; GtkTreePath* path; FmFolderItem* item; FmFileInfo* file = new_item->inf; GSequenceIter *item_it = g_sequence_insert_sorted(model->items, new_item, fm_folder_model_compare, model); new_item->iter = item_it; new_item->iter_age = model->iter_age; it.stamp = model->stamp; it.user_data = item_it; path = gtk_tree_path_new_from_indices(g_sequence_iter_get_position(item_it), -1); gtk_tree_model_row_inserted(GTK_TREE_MODEL(model), path, &it); gtk_tree_path_free(path); }
/* listen to diagram creation */ static void _diagram_add (DiaApplication *app, Diagram *dia, DiagramTreeModel *dtm) { GtkTreePath *path; GtkTreeIter _iter = {0,}; /* all null is our root */ GtkTreeIter *iter = &_iter; NODE_DIAGRAM(iter) = DIA_DIAGRAM_DATA (dia); path = _dtm_get_path (GTK_TREE_MODEL (dtm), iter); /* we always get a path, but it may not be a valid one */ if (path) { /* gtk_tree_model_row_changed is not 'strong' enough, lets try to re-add the root */ gtk_tree_model_row_inserted (GTK_TREE_MODEL (dtm), path, iter); /* looks like the GtkTreeView is somewhat out of service */ if (_recurse_row_inserted (GTK_TREE_MODEL (dtm), iter)) gtk_tree_model_row_has_child_toggled (GTK_TREE_MODEL (dtm), path, iter); gtk_tree_path_free (path); } _dtm_listen_on_diagram (dtm, dia); }
/* listen on the diagram for object add/remove */ static void _object_add (DiagramData *dia, Layer *layer, DiaObject *obj, DiagramTreeModel *dtm) { GtkTreePath *path; GtkTreeIter _iter; GtkTreeIter *iter = &_iter; g_return_if_fail (DIA_DIAGRAM(dia) != NULL); NODE_DIAGRAM(iter) = dia; NODE_LAYER(iter) = layer; NODE_OBJECT(iter) = obj; /* FIXME: this may get called before the layer is added to the tree */ path = _dtm_get_path (GTK_TREE_MODEL (dtm), iter); if (path) { gtk_tree_model_row_inserted (GTK_TREE_MODEL (dtm), path, iter); gtk_tree_path_free (path); } }
static void update_columns (GtkTreeView *view, ViewColumnModel *view_model) { GList *old_columns = view_model->columns; gint old_length, length; GList *a, *b; view_model->columns = gtk_tree_view_get_columns (view_model->view); /* As the view tells us one change at a time, we can do this hack. */ length = g_list_length (view_model->columns); old_length = g_list_length (old_columns); if (length != old_length) { GtkTreePath *path; gint i = 0; /* where are they different */ for (a = old_columns, b = view_model->columns; a && b; a = a->next, b = b->next) { if (a->data != b->data) break; i++; } path = gtk_tree_path_new (); gtk_tree_path_append_index (path, i); if (length < old_length) { view_model->stamp++; gtk_tree_model_row_deleted (GTK_TREE_MODEL (view_model), path); } else { GtkTreeIter iter; iter.stamp = view_model->stamp; iter.user_data = b; gtk_tree_model_row_inserted (GTK_TREE_MODEL (view_model), path, &iter); } gtk_tree_path_free (path); } else { gint i; gint m = 0, n = 1; gint *new_order; GtkTreePath *path; new_order = g_new (int, length); a = old_columns; b = view_model->columns; while (a->data == b->data) { a = a->next; b = b->next; if (a == NULL) return; m++; } if (a->next->data == b->data) { b = b->next; while (b->data != a->data) { b = b->next; n++; } for (i = 0; i < m; i++) new_order[i] = i; for (i = m; i < m+n; i++) new_order[i] = i+1; new_order[i] = m; for (i = m + n +1; i < length; i++) new_order[i] = i; } else { a = a->next; while (a->data != b->data) { a = a->next; n++; } for (i = 0; i < m; i++) new_order[i] = i; new_order[m] = m+n; for (i = m+1; i < m + n+ 1; i++) new_order[i] = i - 1; for (i = m + n + 1; i < length; i++) new_order[i] = i; } path = gtk_tree_path_new (); gtk_tree_model_rows_reordered (GTK_TREE_MODEL (view_model), path, NULL, new_order); gtk_tree_path_free (path); g_free (new_order); } if (old_columns) g_list_free (old_columns); }
gboolean is_store_add_sensor(IsStore *self, IsSensor *sensor, GtkTreeIter *iter) { IsStorePrivate *priv; GSequence *entries; IsStoreEntry *entry = NULL; GSequenceIter *parent = NULL; gchar **names = NULL; int i; GtkTreePath *path; GtkTreeIter _iter; gboolean ret = FALSE; g_return_val_if_fail(IS_IS_STORE(self), FALSE); g_return_val_if_fail(IS_IS_SENSOR(sensor), FALSE); priv = self->priv; entry = find_entry(self, is_sensor_get_path(sensor)); if (entry) { is_warning("store", "sensor %s already exists in store, not adding duplicate", is_sensor_get_path(sensor)); goto out; } entries = priv->entries; names = g_strsplit(is_sensor_get_path(sensor), "/", 0); /* otherwise iterate through to create the entry */ for (i = 0; names[i] != NULL; i++) { GSequenceIter *seq_iter; gchar *name = names[i]; entry = NULL; for (seq_iter = g_sequence_get_begin_iter(entries); !g_sequence_iter_is_end(seq_iter); seq_iter = g_sequence_iter_next(seq_iter)) { entry = (IsStoreEntry *)g_sequence_get(seq_iter); if (g_strcmp0(entry->name, name) == 0) { entries = entry->entries; parent = seq_iter; break; } entry = NULL; } if (!entry) { /* create entry for this name component */ entry = entry_new(name); entry->iter = g_sequence_append(entries, entry); entry->parent = parent; entries = entry->entries; _iter.stamp = priv->stamp; _iter.user_data = entry->iter; path = gtk_tree_model_get_path(GTK_TREE_MODEL(self), &_iter); gtk_tree_model_row_inserted(GTK_TREE_MODEL(self), path, &_iter); gtk_tree_path_free(path); /* parent of the next entry we create will be this * entry */ parent = entry->iter; } } g_strfreev(names); g_assert(entry); g_assert(find_entry(self, is_sensor_get_path(sensor)) == entry); is_debug("store", "inserted sensor %s with label %s", is_sensor_get_path(sensor), is_sensor_get_label(sensor)); entry->sensor = g_object_ref(sensor); _iter.stamp = priv->stamp; _iter.user_data = entry->iter; path = gtk_tree_model_get_path(GTK_TREE_MODEL(self), &_iter); gtk_tree_model_row_changed(GTK_TREE_MODEL(self), path, &_iter); gtk_tree_path_free(path); /* return a copy of iter */ if (iter != NULL) { iter->stamp = priv->stamp; iter->user_data = entry->iter; } ret = TRUE; out: return ret; }
static VALUE rg_row_inserted(VALUE self, VALUE path, VALUE iter) { gtk_tree_model_row_inserted(_SELF(self), RVAL2GTKTREEPATH(path), RVAL2GTKTREEITER(iter)); return self; }
void ptk_file_list_file_created( VFSDir* dir, VFSFileInfo* file, PtkFileList* list ) { GList* l, *ll = NULL; GtkTreeIter it; GtkTreePath* path; VFSFileInfo* file2; if( ! list->show_hidden && vfs_file_info_get_name(file)[0] == '.' ) return; gboolean is_desktop = vfs_file_info_is_desktop_entry( file ); //sfm gboolean is_desktop2; for( l = list->files; l; l = l->next ) { file2 = (VFSFileInfo*)l->data; if( G_UNLIKELY( file == file2 ) ) { /* The file is already in the list */ return; } is_desktop2 = vfs_file_info_is_desktop_entry( file2 ); if ( is_desktop || is_desktop2 ) { // at least one is a desktop file, need to compare filenames if ( file->name && file2->name ) { if ( !strcmp( file->name, file2->name ) ) return; } } else if ( ptk_file_list_compare( file2, file, list ) == 0 ) { // disp_name matches ? // ptk_file_list_compare may return 0 on differing display names // if case-insensitive - need to compare filenames if ( list->sort_natural && list->sort_case ) return; else if ( !strcmp( file->name, file2->name ) ) return; } if ( !ll && ptk_file_list_compare( file2, file, list ) > 0 ) { if ( !is_desktop && !is_desktop2 ) break; else ll = l; // store insertion location based on disp_name } } if ( ll ) l = ll; list->files = g_list_insert_before( list->files, l, vfs_file_info_ref( file ) ); ++list->n_files; if( l ) l = l->prev; else l = g_list_last( list->files ); it.stamp = list->stamp; it.user_data = l; it.user_data2 = file; path = gtk_tree_path_new_from_indices( g_list_index(list->files, l->data), -1 ); gtk_tree_model_row_inserted( GTK_TREE_MODEL(list), path, &it ); gtk_tree_path_free( path ); }
/** This function is the handler for all event messages from the * engine. Its purpose is to update the owner tree model any time * an owner is added to the engine or deleted from the engine. * This change to the model is then propagated to any/all overlying * filters and views. This function listens to the ADD, REMOVE, and * DESTROY events. * * @internal * * @warning There is a "Catch 22" situation here. * gtk_tree_model_row_deleted() can't be called until after the item * has been deleted from the real model (which is the engine's * owner tree for us), but once the owner has been deleted from * the engine we have no way to determine the path to pass to * row_deleted(). This is a PITA, but the only other choice is to * have this model mirror the engine's owners instead of * referencing them directly. * * @param entity The guid of the affected item. * * @param type The type of the affected item. This function only * cares about items of type "owner". * * @param event type The type of the event. This function only cares * about items of type ADD, REMOVE, MODIFY, and DESTROY. * * @param user_data A pointer to the owner tree model. */ static void gnc_tree_model_owner_event_handler (QofInstance *entity, QofEventId event_type, GncTreeModelOwner *model, GncEventData *ed) { GncTreeModelOwnerPrivate *priv; GtkTreePath *path = NULL; GtkTreeIter iter; GncOwner owner; g_return_if_fail(model); /* Required */ if (!GNC_IS_OWNER(entity)) return; ENTER("entity %p of type %d, model %p, event_data %p", entity, event_type, model, ed); priv = GNC_TREE_MODEL_OWNER_GET_PRIVATE(model); qofOwnerSetEntity (&owner, entity); if (gncOwnerGetType(&owner) != priv->owner_type) { LEAVE("model type and owner type differ"); return; } if (qof_instance_get_book (entity) != priv->book) { LEAVE("not in this book"); return; } /* What to do, that to do. */ switch (event_type) { case QOF_EVENT_ADD: /* Tell the filters/views where the new owner was added. */ DEBUG("add owner %p (%s)", &owner, gncOwnerGetName(&owner)); /* First update our copy of the owner list. This isn't done automatically */ priv->owner_list = gncBusinessGetOwnerList (priv->book, gncOwnerTypeToQofIdType(priv->owner_type), TRUE); increment_stamp(model); if (!gnc_tree_model_owner_get_iter_from_owner (model, &owner, &iter)) { LEAVE("can't generate iter"); break; } path = gnc_tree_model_owner_get_path(GTK_TREE_MODEL(model), &iter); if (!path) { DEBUG("can't generate path"); break; } gtk_tree_model_row_inserted (GTK_TREE_MODEL(model), path, &iter); break; case QOF_EVENT_REMOVE: if (!ed) /* Required for a remove. */ break; DEBUG("remove owner %d (%s) from owner_list %p", ed->idx, gncOwnerGetName(&owner), priv->owner_list); path = gtk_tree_path_new(); if (!path) { DEBUG("can't generate path"); break; } increment_stamp(model); gtk_tree_path_append_index (path, ed->idx); gtk_tree_model_row_deleted (GTK_TREE_MODEL(model), path); break; case QOF_EVENT_MODIFY: DEBUG("modify owner %p (%s)", &owner, gncOwnerGetName(&owner)); if (!gnc_tree_model_owner_get_iter_from_owner (model, &owner, &iter)) { LEAVE("can't generate iter"); return; } path = gnc_tree_model_owner_get_path(GTK_TREE_MODEL(model), &iter); if (!path) { DEBUG("can't generate path"); break; } gtk_tree_model_row_changed(GTK_TREE_MODEL(model), path, &iter); break; default: LEAVE("unknown event type"); return; } if (path) gtk_tree_path_free(path); LEAVE(" "); return; }
gboolean fm_list_model_add_file (FMListModel *model, CajaFile *file, CajaDirectory *directory) { GtkTreeIter iter; GtkTreePath *path; FileEntry *file_entry; GSequenceIter *ptr, *parent_ptr; GSequence *files; gboolean replace_dummy; GHashTable *parent_hash; parent_ptr = g_hash_table_lookup (model->details->directory_reverse_map, directory); if (parent_ptr) { file_entry = g_sequence_get (parent_ptr); ptr = g_hash_table_lookup (file_entry->reverse_map, file); } else { file_entry = NULL; ptr = g_hash_table_lookup (model->details->top_reverse_map, file); } if (ptr != NULL) { g_warning ("file already in tree (parent_ptr: %p)!!!\n", parent_ptr); return FALSE; } file_entry = g_new0 (FileEntry, 1); file_entry->file = caja_file_ref (file); file_entry->parent = NULL; file_entry->subdirectory = NULL; file_entry->files = NULL; files = model->details->files; parent_hash = model->details->top_reverse_map; replace_dummy = FALSE; if (parent_ptr != NULL) { file_entry->parent = g_sequence_get (parent_ptr); /* At this point we set loaded. Either we saw * "done" and ignored it waiting for this, or we do this * earlier, but then we replace the dummy row anyway, * so it doesn't matter */ file_entry->parent->loaded = 1; parent_hash = file_entry->parent->reverse_map; files = file_entry->parent->files; if (g_sequence_get_length (files) == 1) { GSequenceIter *dummy_ptr = g_sequence_get_iter_at_pos (files, 0); FileEntry *dummy_entry = g_sequence_get (dummy_ptr); if (dummy_entry->file == NULL) { /* replace the dummy loading entry */ model->details->stamp++; g_sequence_remove (dummy_ptr); replace_dummy = TRUE; } } } file_entry->ptr = g_sequence_insert_sorted (files, file_entry, fm_list_model_file_entry_compare_func, model); g_hash_table_insert (parent_hash, file, file_entry->ptr); iter.stamp = model->details->stamp; iter.user_data = file_entry->ptr; path = gtk_tree_model_get_path (GTK_TREE_MODEL (model), &iter); if (replace_dummy) { gtk_tree_model_row_changed (GTK_TREE_MODEL (model), path, &iter); } else { gtk_tree_model_row_inserted (GTK_TREE_MODEL (model), path, &iter); } if (caja_file_is_directory (file)) { file_entry->files = g_sequence_new ((GDestroyNotify)file_entry_free); add_dummy_row (model, file_entry); gtk_tree_model_row_has_child_toggled (GTK_TREE_MODEL (model), path, &iter); } gtk_tree_path_free (path); return TRUE; }