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