void fm_folder_model_file_deleted(FmFolderModel* model, FmFileInfo* file) { GSequenceIter *seq_it; /* not required for hidden files */ gboolean update_view; #if 0 /* If there is no file info, that means the dir itself was deleted. */ if( G_UNLIKELY(!file) ) { /* Clear the whole list */ GSequenceIter *items_it = g_sequence_get_begin_iter(model->items); path = gtk_tree_path_new_from_indices(0, -1); while( !g_sequence_iter_is_end(items_it) ) { gtk_tree_model_row_deleted(GTK_TREE_MODEL(model), path); file = (VFSFileInfo*)g_sequence_get(items_it); items_it = g_sequence_iter_next(it); vfs_file_info_unref(file); } for( l = model->items; l; l = model->items ) { gtk_tree_model_row_deleted(GTK_TREE_MODEL(model), path); file = (VFSFileInfo*)l->data; model->items = g_list_delete_link(model->items, l); vfs_file_info_unref(file); } g_sequence_remove_range( g_sequence_get_begin_iter(model->items), g_sequence_get_end_iter(model->items) ); gtk_tree_path_free(path); return; } #endif if( !model->show_hidden && fm_file_info_is_hidden(file) ) /* if this is a hidden file */ { update_view = FALSE; seq_it = g_sequence_get_begin_iter(model->hidden); } else { update_view = TRUE; seq_it = g_sequence_get_begin_iter(model->items); } while( !g_sequence_iter_is_end(seq_it) ) { FmFolderItem* item = (FmFolderItem*)g_sequence_get(seq_it); if( item->inf == file ) break; seq_it = g_sequence_iter_next(seq_it); } if( update_view ) { GtkTreePath* path = gtk_tree_path_new_from_indices(g_sequence_iter_get_position(seq_it), -1); gtk_tree_model_row_deleted(GTK_TREE_MODEL(model), path); gtk_tree_path_free(path); } model->iter_age++; g_sequence_remove(seq_it); }
static void destroy_node (FMTreeModel *model, TreeNode *node) { TreeNode *parent; gboolean parent_had_dummy_child; GtkTreePath *path; parent = node->parent; parent_had_dummy_child = tree_node_has_dummy_child (parent); path = get_node_path (model, node); /* Report row_deleted before actually deleting */ gtk_tree_model_row_deleted (GTK_TREE_MODEL (model), path); gtk_tree_path_free (path); destroy_node_without_reporting (model, node); if (tree_node_has_dummy_child (parent)) { if (!parent_had_dummy_child) { report_dummy_row_inserted (model, parent); } } else { g_assert (!parent_had_dummy_child); } }
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 remove_entry(IsStore *self, IsStoreEntry *entry) { IsStorePrivate *priv; GtkTreeIter iter; GtkTreePath *path; GSequenceIter *parent_iter; priv = self->priv; parent_iter = entry->parent; iter.stamp = priv->stamp; iter.user_data = entry->iter; path = gtk_tree_model_get_path(GTK_TREE_MODEL(self), &iter); g_sequence_remove(entry->iter); gtk_tree_model_row_deleted(GTK_TREE_MODEL(self), path); gtk_tree_path_free(path); /* remove parent if it has no children now */ if (parent_iter) { IsStoreEntry *parent = g_sequence_get(parent_iter); if (g_sequence_get_length(parent->entries) == 0) { remove_entry(self, parent); } } }
/** * xfae_model_remove: * @model : a #XfaeModel. * @iter : the #GtkTreeIter referring to the item that should be removed. * @error : return location for errors or %NULL. * * Tries to remove the item referred to by @iter from @model. * * Return value: %TRUE if the removal was successful. **/ gboolean xfae_model_remove (XfaeModel *model, GtkTreeIter *iter, GError **error) { GtkTreePath *path; XfaeItem *item; GList *lp; gint index_; g_return_val_if_fail (XFAE_IS_MODEL (model), FALSE); g_return_val_if_fail (iter->stamp == model->stamp, FALSE); g_return_val_if_fail (error == NULL || *error == NULL, FALSE); lp = iter->user_data; item = lp->data; /* try to unlink the item from disk */ if (!xfae_item_remove (item, error)) return FALSE; /* unlink the item from the list */ index_ = g_list_position (model->items, lp); model->items = g_list_delete_link (model->items, lp); xfae_item_free (item); /* tell the view that we have just removed one item */ path = gtk_tree_path_new_from_indices (index_, -1); gtk_tree_model_row_deleted (GTK_TREE_MODEL (model), path); gtk_tree_path_free (path); return TRUE; }
static void _object_remove(DiagramData *dia, Layer *layer, DiaObject *obj, DiagramTreeModel *dtm) { GtkTreePath *path; GtkTreeIter _iter; GtkTreeIter *iter = &_iter; gboolean last_child = layer_object_count (layer) == 0; g_return_if_fail (DIA_DIAGRAM(dia) != NULL); NODE_DIAGRAM(iter) = dia; NODE_LAYER(iter) = layer; NODE_OBJECT(iter) = obj; path = _dtm_get_path (GTK_TREE_MODEL (dtm), iter); gtk_tree_model_row_deleted (GTK_TREE_MODEL (dtm), path); gtk_tree_path_free (path); /* enforce update - but the arrow on layer does not vanish */ if (last_child) { NODE_OBJECT(iter) = NULL; path = _dtm_get_path (GTK_TREE_MODEL (dtm), iter); gtk_tree_model_row_has_child_toggled (GTK_TREE_MODEL (dtm), path, iter); gtk_tree_path_free (path); } }
static void row_deleted (EDateTimeList *date_time_list, gint n) { GtkTreePath *path; path = gtk_tree_path_new (); gtk_tree_path_append_index (path, n); gtk_tree_model_row_deleted (GTK_TREE_MODEL (date_time_list), path); gtk_tree_path_free (path); }
void ptk_file_list_file_deleted( VFSDir* dir, VFSFileInfo* file, PtkFileList* list ) { GList* l; GtkTreePath* path; /* If there is no file info, that means the dir itself was deleted. */ if( G_UNLIKELY( ! file ) ) { /* Clear the whole list */ path = gtk_tree_path_new_from_indices(0, -1); for( l = list->files; l; l = list->files ) { gtk_tree_model_row_deleted( GTK_TREE_MODEL(list), path ); file = (VFSFileInfo*)l->data; list->files = g_list_delete_link( list->files, l ); vfs_file_info_unref( file ); --list->n_files; } gtk_tree_path_free( path ); return; } if( ! list->show_hidden && vfs_file_info_get_name(file)[0] == '.' ) return; l = g_list_find( list->files, file ); if( ! l ) return; path = gtk_tree_path_new_from_indices( g_list_index(list->files, l->data), -1 ); gtk_tree_model_row_deleted( GTK_TREE_MODEL(list), path ); gtk_tree_path_free( path ); list->files = g_list_delete_link( list->files, l ); vfs_file_info_unref( file ); --list->n_files; }
void gbase_list_delete_record(GBaseList *self, GtkTreeIter *iter) { g_return_if_fail(GBASE_IS_LIST(self)); GtkTreePath *path = gbase_list_get_path(GTK_TREE_MODEL(self), iter); base_entry_t *entry = base_iter_value(USER_DATA_2_BASE_ITER(iter->user_data)); if (entry && base_entry_remove(self->base_ctx, entry)) { gtk_tree_model_row_deleted(GTK_TREE_MODEL(self), path); } gtk_tree_path_free(path); }
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 report_dummy_row_deleted (FMTreeModel *model, TreeNode *parent) { GtkTreeIter iter; GtkTreePath *path; if (parent->inserted) { make_iter_for_node (parent, &iter, model->details->stamp); path = gtk_tree_model_get_path (GTK_TREE_MODEL (model), &iter); gtk_tree_path_append_index (path, 0); gtk_tree_model_row_deleted (GTK_TREE_MODEL (model), path); gtk_tree_path_free (path); } abandon_dummy_row_ref_count (model, parent); }
void fm_tree_model_remove_root_uri (FMTreeModel *model, const char *uri) { TreeNode *node; GtkTreePath *path; FMTreeModelRoot *root; NemoFile *file; file = nemo_file_get_by_uri (uri); for (node = model->details->root_node; node != NULL; node = node->next) { if (file == node->file) { break; } } nemo_file_unref (file); if (node) { /* remove the node */ if (node->mount) { g_object_unref (node->mount); node->mount = NULL; } nemo_file_monitor_remove (node->file, model); path = get_node_path (model, node); /* Report row_deleted before actually deleting */ gtk_tree_model_row_deleted (GTK_TREE_MODEL (model), path); gtk_tree_path_free (path); if (node->prev) { node->prev->next = node->next; } if (node->next) { node->next->prev = node->prev; } if (node == model->details->root_node) { model->details->root_node = node->next; } /* destroy the root identifier */ root = node->root; destroy_node_without_reporting (model, node); g_hash_table_destroy (root->file_to_node_map); g_free (root); } }
void GtkCatalogModel_remove_record(GtkCatalogModel * custom_list, gint recordIndex) { if (CatalogDB_getRecordCount(custom_list->catalogDB) > 0) { GtkTreePath *path; g_return_if_fail (GTKCATALOGMODEL_IS_LIST(custom_list)); g_return_if_fail (recordIndex < CatalogDB_getRecordCount(custom_list->catalogDB)); CatalogDB_removeRecord(custom_list->catalogDB, recordIndex); path = gtk_tree_path_new(); gtk_tree_path_append_index(path, recordIndex); gtk_tree_model_row_deleted(GTK_TREE_MODEL(custom_list), path); 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); } }
/* Remove the header, and emit the "row-deleted" signal. */ static void hide_header (GtkSourceCompletionModel *model, GList *provider_node) { ProviderInfo *provider_info = provider_node->data; ProposalInfo *proposal_info = g_queue_pop_head (provider_info->proposals); g_assert (provider_info->proposals->length > 0); g_assert (is_header (proposal_info)); proposal_info_free (proposal_info); if (provider_info->visible) { GtkTreePath *path = get_proposal_path (model, provider_info->proposals->head); gtk_tree_model_row_deleted (GTK_TREE_MODEL (model), path); gtk_tree_path_free (path); } }
static void all_rows_deleted (EDateTimeList *date_time_list) { GtkTreePath *path; gint i; if (!date_time_list->priv->list) return; path = gtk_tree_path_new (); i = g_list_length (date_time_list->priv->list); gtk_tree_path_append_index (path, i); for (; i >= 0; i--) { gtk_tree_model_row_deleted (GTK_TREE_MODEL (date_time_list), path); gtk_tree_path_prev (path); } gtk_tree_path_free (path); }
/***************************************************************************************** * ... * * ****************************************************************************************/ void fm_dir_tree_model_remove_item (FmDirTreeModel *dir_tree_model, GList *item_list) { GtkTreePath *tree_path = fm_dir_tree_model_item_to_tree_path (dir_tree_model, item_list); FmDirTreeItem *dir_tree_item = (FmDirTreeItem*)item_list->data; FmDirTreeItem *parent_item = (FmDirTreeItem*)dir_tree_item->parent ? dir_tree_item->parent->data : NULL; fm_dir_tree_item_free_l (item_list); if (parent_item) parent_item->children = g_list_delete_link (parent_item->children, item_list); char *tmp_path = gtk_tree_path_to_string (tree_path); //TREEVIEW_DEBUG ("TREEVIEW_DEBUG: fm_dir_tree_model_remove_item %s\n", tmp_path); g_free (tmp_path); // signal the view that we removed the placeholder item. gtk_tree_model_row_deleted (GTK_TREE_MODEL (dir_tree_model), tree_path); gtk_tree_path_free (tree_path); }
static void _object_remove(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; path = _dtm_get_path (GTK_TREE_MODEL (dtm), iter); gtk_tree_model_row_deleted (GTK_TREE_MODEL (dtm), path); gtk_tree_path_free (path); }
void custom_list_clear (CustomList * custom_list) { int i, max = custom_list->num_rows - 1; GtkTreePath *path; for (i = max; i >= 0; i--) { path = gtk_tree_path_new (); gtk_tree_path_append_index (path, custom_list->rows[i]->pos); gtk_tree_model_row_deleted (GTK_TREE_MODEL (custom_list), path); gtk_tree_path_free (path); } custom_list->num_rows = 0; custom_list->num_alloc = 0; g_free (custom_list->rows); custom_list->rows = NULL; }
static void _diagram_remove (DiaApplication *app, Diagram *dia, DiagramTreeModel *dtm) { GtkTreePath *path; GtkTreeIter _iter = {0,}; GtkTreeIter *iter = &_iter; NODE_DIAGRAM(iter) = DIA_DIAGRAM_DATA(dia); NODE_LAYER(iter) = NULL; NODE_OBJECT(iter) = NULL; path = _dtm_get_path (GTK_TREE_MODEL (dtm), iter); gtk_tree_model_row_deleted (GTK_TREE_MODEL (dtm), path); gtk_tree_path_free (path); /* stop listening on this diagram */ g_signal_handlers_disconnect_by_func (dia, _object_add, dtm); g_signal_handlers_disconnect_by_func (dia, _object_remove, dtm); }
static void fm_dir_tree_model_remove_all_children (FmDirTreeModel *dir_tree_model, GList *item_list, GtkTreePath *tree_path) { FmDirTreeItem *dir_tree_item = (FmDirTreeItem*)item_list->data; if (G_UNLIKELY (!dir_tree_item->children)) return; gtk_tree_path_append_index (tree_path, 0); while (dir_tree_item->children) { fm_dir_tree_item_free_l (dir_tree_item->children); dir_tree_item->children = g_list_delete_link (dir_tree_item->children, dir_tree_item->children); char *tmp_path = gtk_tree_path_to_string (tree_path); //TREEVIEW_DEBUG ("TREEVIEW_DEBUG: fm_dir_tree_model_remove_all_children %s\n", tmp_path); g_free (tmp_path); // signal the view that we removed the placeholder item. // everytime we remove the first item, its next item became the // first item, so there is no need to update tree_path. gtk_tree_model_row_deleted (GTK_TREE_MODEL (dir_tree_model), tree_path); } if (dir_tree_item->hidden_children) { g_list_foreach (dir_tree_item->hidden_children, (GFunc)fm_dir_tree_item_free, NULL); g_list_free (dir_tree_item->hidden_children); dir_tree_item->hidden_children = NULL; } gtk_tree_path_up (tree_path); GtkTreeIter it; gtk_tree_model_row_has_child_toggled (GTK_TREE_MODEL (dir_tree_model), tree_path, &it); // ??? //~ gtk_tree_model_row_changed ((GtkTreeModel*) dir_tree_model, tree_path, &it); }
static void bt_pattern_list_model_rem (BtPatternListModel * model, BtPattern * pattern) { GSequence *seq = model->priv->seq; GtkTreePath *path; GSequenceIter *iter; gint position; GST_INFO ("removing pattern from model"); // remove entry iter = g_sequence_lookup (seq, pattern, model_item_cmp, NULL); position = g_sequence_iter_get_position (iter); g_sequence_remove (iter); // signal to the view/app path = gtk_tree_path_new (); gtk_tree_path_append_index (path, position); gtk_tree_model_row_deleted (GTK_TREE_MODEL (model), path); gtk_tree_path_free (path); GST_INFO ("removed pattern from model at pos %d ", position); }
static void reparent_node (FMTreeModel *model, TreeNode *node) { GtkTreePath *path; TreeNode *new_parent; new_parent = get_parent_node_from_file (node->root, node->file); if (new_parent == NULL || new_parent->directory == NULL) { destroy_node (model, node); return; } path = get_node_path (model, node); /* Report row_deleted before actually deleting */ gtk_tree_model_row_deleted (GTK_TREE_MODEL (model), path); gtk_tree_path_free (path); abandon_node_ref_count (model, node); tree_node_unparent (model, node); insert_node (model, new_parent, node); }
static VALUE rg_row_deleted(VALUE self, VALUE path) { gtk_tree_model_row_deleted(_SELF(self), RVAL2GTKTREEPATH(path)); return self; }
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); }
/** 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; }