void
nemo_list_model_file_changed (NemoListModel *model, NemoFile *file,
NemoDirectory *directory)
{
FileEntry *parent_file_entry;
GtkTreeIter iter;
GtkTreePath *path, *parent_path;
GSequenceIter *ptr;
int pos_before, pos_after, length, i, old;
int *new_order;
gboolean has_iter;
GSequence *files;
ptr = lookup_file (model, file, directory);
if (!ptr) {
return;
}
pos_before = g_sequence_iter_get_position (ptr);
g_sequence_sort_changed (ptr, nemo_list_model_file_entry_compare_func, model);
pos_after = g_sequence_iter_get_position (ptr);
if (pos_before != pos_after) {
/* The file moved, we need to send rows_reordered */
parent_file_entry = ((FileEntry *)g_sequence_get (ptr))->parent;
if (parent_file_entry == NULL) {
has_iter = FALSE;
parent_path = gtk_tree_path_new ();
files = model->details->files;
} else {
has_iter = TRUE;
nemo_list_model_ptr_to_iter (model, parent_file_entry->ptr, &iter);
parent_path = gtk_tree_model_get_path (GTK_TREE_MODEL (model), &iter);
files = parent_file_entry->files;
}
length = g_sequence_get_length (files);
new_order = g_new (int, length);
/* Note: new_order[newpos] = oldpos */
for (i = 0, old = 0; i < length; ++i) {
if (i == pos_after) {
new_order[i] = pos_before;
} else {
if (old == pos_before)
old++;
new_order[i] = old++;
}
}
gtk_tree_model_rows_reordered (GTK_TREE_MODEL (model),
parent_path, has_iter ? &iter : NULL, new_order);
gtk_tree_path_free (parent_path);
g_free (new_order);
}
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;
}
}
}
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
on_sequence_pattern_usage_changed (BtSequence * sequence, BtPattern * pattern,
gpointer user_data)
{
BtPatternListModel *model = BT_PATTERN_LIST_MODEL (user_data);
BtMachine *machine;
g_object_get (pattern, "machine", &machine, NULL);
if (machine) {
if (machine == model->priv->machine) {
GSequence *seq = model->priv->seq;
GtkTreeIter iter;
GtkTreePath *path;
// find the item by pattern
iter.stamp = model->priv->stamp;
iter.user_data = g_sequence_lookup (seq, pattern, model_item_cmp, NULL);
path = gtk_tree_path_new ();
gtk_tree_path_append_index (path,
g_sequence_iter_get_position (iter.user_data));
gtk_tree_model_row_changed (GTK_TREE_MODEL (model), path, &iter);
gtk_tree_path_free (path);
}
g_object_unref (machine);
}
}
gboolean
egg_sorted_hash_insert (EggSortedHash *hash,
gpointer key,
gpointer value,
guint *position)
{
GSequenceIter *it;
if (g_hash_table_contains (hash->iters, key))
{
if (hash->key_free_func)
hash->key_free_func (key);
if (hash->value_free_func)
hash->value_free_func (value);
return FALSE;
}
if (hash->sort_func)
it = g_sequence_insert_sorted (hash->items, value, hash->sort_func, hash->sort_func_data);
else
it = g_sequence_append (hash->items, value);
g_hash_table_insert (hash->iters, key, it);
if (position)
*position = g_sequence_iter_get_position (it);
return TRUE;
}
static void
nemo_list_model_sort_file_entries (NemoListModel *model, GSequence *files, GtkTreePath *path)
{
GSequenceIter **old_order;
GtkTreeIter iter;
int *new_order;
int length;
int i;
FileEntry *file_entry;
gboolean has_iter;
length = g_sequence_get_length (files);
if (length <= 1) {
return;
}
/* generate old order of GSequenceIter's */
old_order = g_new (GSequenceIter *, length);
for (i = 0; i < length; ++i) {
GSequenceIter *ptr = g_sequence_get_iter_at_pos (files, i);
file_entry = g_sequence_get (ptr);
if (file_entry->files != NULL) {
gtk_tree_path_append_index (path, i);
nemo_list_model_sort_file_entries (model, file_entry->files, path);
gtk_tree_path_up (path);
}
old_order[i] = ptr;
}
/* sort */
g_sequence_sort (files, nemo_list_model_file_entry_compare_func, model);
/* generate new order */
new_order = g_new (int, length);
/* Note: new_order[newpos] = oldpos */
for (i = 0; i < length; ++i) {
new_order[g_sequence_iter_get_position (old_order[i])] = i;
}
/* Let the world know about our new order */
g_assert (new_order != NULL);
has_iter = FALSE;
if (gtk_tree_path_get_depth (path) != 0) {
gboolean get_iter_result;
has_iter = TRUE;
get_iter_result = gtk_tree_model_get_iter (GTK_TREE_MODEL (model), &iter, path);
g_assert (get_iter_result);
}
gtk_tree_model_rows_reordered (GTK_TREE_MODEL (model),
path, has_iter ? &iter : NULL, new_order);
g_free (old_order);
g_free (new_order);
}
static void
photos_base_manager_default_add_object (PhotosBaseManager *self, GObject *object)
{
PhotosBaseManagerPrivate *priv;
GObject *old_object;
GSequenceIter *iter;
PhotosBaseManagerObjectData *object_data;
const gchar *id;
guint position;
priv = photos_base_manager_get_instance_private (self);
id = photos_filterable_get_id (PHOTOS_FILTERABLE (object));
old_object = photos_base_manager_get_object_by_id (self, id);
if (old_object != NULL)
return;
if (priv->sort_func == NULL)
{
position = photos_base_manager_get_objects_count (self);
iter = g_sequence_append (priv->sequence, g_object_ref (object));
}
else
{
iter = g_sequence_insert_sorted (priv->sequence, g_object_ref (object), priv->sort_func, priv->sort_data);
position = g_sequence_iter_get_position (iter);
}
object_data = photos_base_manager_object_data_new (object, iter);
g_hash_table_insert (priv->objects, g_strdup (id), object_data);
photos_base_manager_objects_changed (self, position, 0, 1);
g_signal_emit (self, signals[OBJECT_ADDED], 0, object);
}
static GtkTreePath *
nemo_list_model_get_path (GtkTreeModel *tree_model, GtkTreeIter *iter)
{
GtkTreePath *path;
NemoListModel *model;
GSequenceIter *ptr;
FileEntry *file_entry;
model = (NemoListModel *)tree_model;
g_return_val_if_fail (iter->stamp == model->details->stamp, NULL);
if (g_sequence_iter_is_end (iter->user_data)) {
/* FIXME is this right? */
return NULL;
}
path = gtk_tree_path_new ();
ptr = iter->user_data;
while (ptr != NULL) {
gtk_tree_path_prepend_index (path, g_sequence_iter_get_position (ptr));
file_entry = g_sequence_get (ptr);
if (file_entry->parent != NULL) {
ptr = file_entry->parent->ptr;
} else {
ptr = NULL;
}
}
return path;
}
static void
photos_base_manager_default_remove_object_by_id (PhotosBaseManager *self, const gchar *id)
{
PhotosBaseManagerPrivate *priv;
GObject *object;
PhotosBaseManagerObjectData *object_data;
guint position;
priv = photos_base_manager_get_instance_private (self);
object_data = g_hash_table_lookup (priv->objects, id);
if (object_data == NULL)
return;
position = g_sequence_iter_get_position (object_data->iter);
g_sequence_remove (object_data->iter);
object = g_object_ref (object_data->object);
g_hash_table_remove (priv->objects, id);
photos_base_manager_objects_changed (self, position, 1, 0);
g_signal_emit (self, signals[OBJECT_REMOVED], 0, object);
g_object_unref (object);
}
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
ide_recent_projects_added (IdeRecentProjects *self,
IdeProjectInfo *project_info)
{
g_autofree gchar *uri = NULL;
GFile *file;
g_assert (IDE_IS_RECENT_PROJECTS (self));
g_assert (IDE_IS_PROJECT_INFO (project_info));
file = ide_project_info_get_file (project_info);
uri = g_file_get_uri (file);
if (!g_hash_table_contains (self->recent_uris, uri))
{
GSequenceIter *iter;
gint position;
iter = g_sequence_insert_sorted (self->projects,
g_object_ref (project_info),
(GCompareDataFunc)ide_project_info_compare,
NULL);
position = g_sequence_iter_get_position (iter);
g_list_model_items_changed (G_LIST_MODEL (self), position, 0, 1);
}
}
static GtkTreePath *_is_store_get_path(GtkTreeModel *tree_model,
GtkTreeIter *iter)
{
IsStore *self;
IsStorePrivate *priv;
GtkTreePath *path;
GSequenceIter *entry_iter;
g_return_val_if_fail(IS_IS_STORE(tree_model), NULL);
g_return_val_if_fail(iter != NULL, NULL);
self = IS_STORE(tree_model);
priv = self->priv;
g_return_val_if_fail(iter->stamp == priv->stamp, NULL);
g_assert(iter->user_data);
path = gtk_tree_path_new();
entry_iter = (GSequenceIter *)iter->user_data;
while (entry_iter != NULL) {
IsStoreEntry *entry;
gtk_tree_path_prepend_index(path,
g_sequence_iter_get_position(entry_iter));
entry = (IsStoreEntry *)g_sequence_get(entry_iter);
entry_iter = entry->parent;
}
return path;
}
static void
bt_pattern_list_model_tree_model_get_value (GtkTreeModel * tree_model,
GtkTreeIter * iter, gint column, GValue * value)
{
BtPatternListModel *model = BT_PATTERN_LIST_MODEL (tree_model);
BtPattern *pattern;
g_return_if_fail (column < N_COLUMNS);
g_value_init (value, model->priv->param_types[column]);
if ((pattern = g_sequence_get (iter->user_data))) {
switch (column) {
case BT_PATTERN_LIST_MODEL_LABEL:
g_object_get_property ((GObject *) pattern, "name", value);
break;
case BT_PATTERN_LIST_MODEL_IS_USED:{
gboolean is_used = FALSE;
if (!model->priv->skip_internal) {
/* treat internal patterns as always used */
is_used = !BT_IS_PATTERN (pattern);
}
if (!is_used && model->priv->sequence) {
is_used =
bt_sequence_is_pattern_used (model->priv->sequence, pattern);
}
g_value_set_boolean (value, is_used);
break;
}
case BT_PATTERN_LIST_MODEL_IS_UNUSED:{
gboolean is_used = FALSE;
if (!model->priv->skip_internal) {
/* treat internal patterns as always used */
is_used = !BT_IS_PATTERN (pattern);
}
if (!is_used && model->priv->sequence) {
is_used =
bt_sequence_is_pattern_used (model->priv->sequence, pattern);
}
g_value_set_boolean (value, !is_used);
break;
}
case BT_PATTERN_LIST_MODEL_SHORTCUT:{
gchar key[2] = { 0, };
gint index;
index = g_sequence_iter_get_position (iter->user_data);
key[0] = (index < 64) ? model->priv->pattern_keys[index] : ' ';
g_value_set_string (value, key);
break;
}
}
}
}
void fm_folder_model_sort(FmFolderModel* model)
{
GHashTable* old_order;
gint *new_order;
GSequenceIter *items_it;
GtkTreePath *path;
/* if there is only one item */
if( model->items == NULL || g_sequence_get_length(model->items) <= 1 )
return;
old_order = g_hash_table_new(g_direct_hash, g_direct_equal);
/* save old order */
items_it = g_sequence_get_begin_iter(model->items);
while( !g_sequence_iter_is_end(items_it) )
{
int i = g_sequence_iter_get_position(items_it);
g_hash_table_insert( old_order, items_it, GINT_TO_POINTER(i) );
items_it = g_sequence_iter_next(items_it);
}
/* sort the list */
g_sequence_sort(model->items, fm_folder_model_compare, model);
/* save new order */
new_order = g_new( int, g_sequence_get_length(model->items) );
items_it = g_sequence_get_begin_iter(model->items);
while( !g_sequence_iter_is_end(items_it) )
{
int i = g_sequence_iter_get_position(items_it);
new_order[i] = (guint)g_hash_table_lookup(old_order, items_it);
items_it = g_sequence_iter_next(items_it);
}
g_hash_table_destroy(old_order);
path = gtk_tree_path_new();
gtk_tree_model_rows_reordered(GTK_TREE_MODEL(model),
path, NULL, new_order);
gtk_tree_path_free(path);
g_free(new_order);
}
GtkTreePath *fm_folder_model_get_path(GtkTreeModel *tree_model,
GtkTreeIter *iter)
{
GtkTreePath* path;
GSequenceIter* items_it;
FmFolderModel* model = FM_FOLDER_MODEL(tree_model);
g_return_val_if_fail(model, NULL);
g_return_val_if_fail(iter->stamp == model->stamp, NULL);
g_return_val_if_fail(iter != NULL, NULL);
g_return_val_if_fail(iter->user_data != NULL, NULL);
items_it = (GSequenceIter*)iter->user_data;
path = gtk_tree_path_new();
gtk_tree_path_append_index( path, g_sequence_iter_get_position(items_it) );
return path;
}
static GtkTreePath *
bt_pattern_list_model_tree_model_get_path (GtkTreeModel * tree_model,
GtkTreeIter * iter)
{
BtPatternListModel *model = BT_PATTERN_LIST_MODEL (tree_model);
GtkTreePath *path;
g_return_val_if_fail (iter->stamp == model->priv->stamp, NULL);
if (g_sequence_iter_is_end (iter->user_data))
return NULL;
path = gtk_tree_path_new ();
gtk_tree_path_append_index (path,
g_sequence_iter_get_position (iter->user_data));
return 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);
}
}
gboolean
egg_sorted_hash_remove (EggSortedHash *hash,
gpointer key,
guint *position)
{
GSequenceIter *it;
it = g_hash_table_lookup (hash->iters, key);
if (it)
{
if (position)
*position = g_sequence_iter_get_position (it);
g_sequence_remove (it);
g_hash_table_remove (hash->iters, key);
return TRUE;
}
return FALSE;
}
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);
}
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);
}
void fm_folder_model_file_changed(FmFolderModel* model, FmFileInfo* file)
{
FmFolderItem* item;
GSequenceIter* items_it;
GtkTreeIter it;
GtkTreePath* path;
if( !model->show_hidden && fm_file_info_is_hidden(file) )
return;
items_it = g_sequence_get_begin_iter(model->items);
/* FIXME: write a GCompareDataFunc for this */
while( !g_sequence_iter_is_end(items_it) )
{
item = (FmFolderItem*)g_sequence_get(items_it);
if( item->inf == file )
break;
items_it = g_sequence_iter_next(items_it);
}
if( items_it == g_sequence_get_end_iter(model->items) )
return;
/* update the icon */
if( item->icon )
{
g_object_unref(item->icon);
item->icon = NULL;
}
it.stamp = model->stamp;
it.user_data = items_it;
path = gtk_tree_path_new_from_indices(g_sequence_iter_get_position(items_it), -1);
gtk_tree_model_row_changed(GTK_TREE_MODEL(model), path, &it);
gtk_tree_path_free(path);
}
