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