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 gboolean fm_folder_model_find_iter_by_req(FmFolderModel* model, GtkTreeIter* it, FmThumbnailRequest* req)
{
guint iter_age = (guint)fm_thumbnail_request_get_payload1(req);
FmFolderItem* item = (FmFolderItem*)fm_thumbnail_request_get_payload2(req);
if (iter_age && item && model->iter_age == iter_age && item == (FmFolderItem*)g_sequence_get(item->iter))
{
it->stamp = model->stamp;
it->user_data = item->iter;
return TRUE;
}
FmFileInfo* fi = fm_thumbnail_request_get_file_info(req);
GSequenceIter *item_it = g_sequence_get_begin_iter(model->items);
for( ; !g_sequence_iter_is_end(item_it); item_it = g_sequence_iter_next(item_it) )
{
FmFolderItem* item1 = (FmFolderItem*)g_sequence_get(item_it);
if (item1 == item && item1->inf == fi)
{
item1->iter = item_it;
item1->iter_age = model->iter_age;
it->stamp = model->stamp;
it->user_data = item_it;
return TRUE;
}
}
return FALSE;
}
guint
swfdec_text_buffer_get_unique (SwfdecTextBuffer *buffer,
gsize start, gsize length)
{
guint result = SWFDEC_TEXT_ATTRIBUTES_MASK;
SwfdecTextBufferFormat *format, *cur;
GSequenceIter *iter;
gsize end;
g_return_val_if_fail (SWFDEC_IS_TEXT_BUFFER (buffer), 0);
g_return_val_if_fail (start + length <= buffer->text->len, 0);
if (start == buffer->text->len)
return result;
end = start + length;
iter = swfdec_text_buffer_get_iter_for_pos (buffer, start);
format = g_sequence_get (iter);
for (iter = g_sequence_iter_next (iter); !g_sequence_iter_is_end (iter); iter = g_sequence_iter_next (iter)) {
cur = g_sequence_get (iter);
if (cur->start >= end)
break;
result &= ~swfdec_text_attributes_diff (&format->attr, &cur->attr);
}
return result;
}
void g_sequence_remove_sorted ( GSequence * seq, gpointer data, GCompareDataFunc cmp_func, gpointer cmp_data )
{
gpointer found;
GSequenceIter * sj, * si = g_sequence_lookup( seq, data, cmp_func, cmp_data );
if ( si == NULL )
return;
sj = si;
while ( !g_sequence_iter_is_end( sj ) )
{
found = g_sequence_get( sj );
if ( found == data )
return g_sequence_remove( sj );
else if ( cmp_func( found, data, cmp_data ) != 0 )
break;
sj = g_sequence_iter_next( sj );
}
sj = si;
while ( !g_sequence_iter_is_begin( sj ) )
{
sj = g_sequence_iter_prev( sj );
found = g_sequence_get( sj );
if ( found == data )
return g_sequence_remove( sj );
else if ( cmp_func( found, data, cmp_data ) != 0 )
break;
}
}
static GSequenceIter *
lookup_file (FMListModel *model, CajaFile *file,
CajaDirectory *directory)
{
FileEntry *file_entry;
GSequenceIter *ptr, *parent_ptr;
parent_ptr = NULL;
if (directory)
{
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
{
ptr = g_hash_table_lookup (model->details->top_reverse_map, file);
}
if (ptr)
{
g_assert (((FileEntry *)g_sequence_get (ptr))->file == file);
}
return ptr;
}
static inline void
_get_nearest_control_points2 (GstTimedValueControlSource * self,
GstClockTime ts, GstControlPoint ** cp1, GstControlPoint ** cp2,
GstClockTime * next_ts)
{
GSequenceIter *iter1, *iter2 = NULL;
*cp1 = *cp2 = NULL;
iter1 = gst_timed_value_control_source_find_control_point_iter (self, ts);
if (iter1) {
*cp1 = g_sequence_get (iter1);
iter2 = g_sequence_iter_next (iter1);
} else {
if (G_LIKELY (self->values)) {
/* all values in the control point list come after the given timestamp */
iter2 = g_sequence_get_begin_iter (self->values);
/* why this? if !cp1 we don't interpolate anyway
* if we can eliminate this, we can also use _get_nearest_control_points()
* here, is this just to set next_ts? */
} else {
/* no values */
iter2 = NULL;
}
}
if (iter2 && !g_sequence_iter_is_end (iter2)) {
*cp2 = g_sequence_get (iter2);
*next_ts = (*cp2)->timestamp;
} else {
*next_ts = GST_CLOCK_TIME_NONE;
}
}
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 reload_icons(FmFolderModel* model, enum ReloadFlags flags)
{
/* reload icons */
GSequenceIter* it = g_sequence_get_begin_iter(model->items);
GtkTreePath* tp = gtk_tree_path_new_from_indices(0, -1);
if(model->thumbnail_requests)
{
g_list_foreach(model->thumbnail_requests, (GFunc)fm_thumbnail_request_cancel, NULL);
g_list_free(model->thumbnail_requests);
model->thumbnail_requests = NULL;
}
for( ; !g_sequence_iter_is_end(it); it = g_sequence_iter_next(it) )
{
FmFolderItem* item = (FmFolderItem*)g_sequence_get(it);
if(item->icon)
{
GtkTreeIter tree_it = {0};
if((flags & RELOAD_ICONS && !item->is_thumbnail) ||
(flags & RELOAD_THUMBNAILS && item->is_thumbnail))
{
g_object_unref(item->icon);
item->icon = NULL;
item->is_thumbnail = FALSE;
item->thumbnail_loading = FALSE;
tree_it.stamp = model->stamp;
tree_it.user_data = it;
gtk_tree_model_row_changed(GTK_TREE_MODEL(model), tp, &tree_it);
}
}
gtk_tree_path_next(tp);
}
gtk_tree_path_free(tp);
it = g_sequence_get_begin_iter(model->hidden);
for( ; !g_sequence_iter_is_end(it); it = g_sequence_iter_next(it) )
{
FmFolderItem* item = (FmFolderItem*)g_sequence_get(it);
if(item->icon)
{
g_object_unref(item->icon);
item->icon = NULL;
item->is_thumbnail = FALSE;
item->thumbnail_loading = FALSE;
}
}
}
static gint _is_store_iter_n_children(GtkTreeModel *tree_model,
GtkTreeIter *iter)
{
IsStore *self;
IsStorePrivate *priv;
IsStoreEntry *entry;
gint n;
g_return_val_if_fail(IS_IS_STORE(tree_model), 0);
self = IS_STORE(tree_model);
priv = self->priv;
if (!iter) {
n = g_sequence_get_length(priv->entries);
goto out;
}
g_return_val_if_fail(iter->stamp == priv->stamp, 0);
g_assert(iter->user_data);
entry = (IsStoreEntry *)
g_sequence_get((GSequenceIter *)iter->user_data);
n = g_sequence_get_length(entry->entries);
out:
return n;
}
static gboolean
fm_list_model_iter_nth_child (GtkTreeModel *tree_model, GtkTreeIter *iter, GtkTreeIter *parent, int n)
{
FMListModel *model;
GSequenceIter *child;
GSequence *files;
FileEntry *file_entry;
model = (FMListModel *)tree_model;
if (parent != NULL)
{
file_entry = g_sequence_get (parent->user_data);
files = file_entry->files;
}
else
{
files = model->details->files;
}
child = g_sequence_get_iter_at_pos (files, n);
if (g_sequence_iter_is_end (child))
{
return FALSE;
}
iter->stamp = model->details->stamp;
iter->user_data = child;
return TRUE;
}
static gboolean _is_store_iter_parent(GtkTreeModel *tree_model,
GtkTreeIter *iter,
GtkTreeIter *child)
{
IsStore *self;
IsStorePrivate *priv;
IsStoreEntry *entry;
gboolean ret = FALSE;
g_return_val_if_fail(IS_IS_STORE(tree_model), FALSE);
g_return_val_if_fail(child != NULL, FALSE);
self = IS_STORE(tree_model);
priv = self->priv;
g_return_val_if_fail(child->stamp == priv->stamp, FALSE);
g_assert(child->user_data);
entry = (IsStoreEntry *)
g_sequence_get((GSequenceIter *)child->user_data);
if (entry->parent) {
iter->stamp = priv->stamp;
iter->user_data = entry->parent;
ret = TRUE;
}
return ret;
}
static gboolean
fm_list_model_get_iter (GtkTreeModel *tree_model, GtkTreeIter *iter, GtkTreePath *path)
{
FMListModel *model;
GSequence *files;
GSequenceIter *ptr;
FileEntry *file_entry;
int i, d;
model = (FMListModel *)tree_model;
ptr = NULL;
files = model->details->files;
for (d = 0; d < gtk_tree_path_get_depth (path); d++)
{
i = gtk_tree_path_get_indices (path)[d];
if (files == NULL || i >= g_sequence_get_length (files))
{
return FALSE;
}
ptr = g_sequence_get_iter_at_pos (files, i);
file_entry = g_sequence_get (ptr);
files = file_entry->files;
}
fm_list_model_ptr_to_iter (model, ptr, iter);
return TRUE;
}
static gboolean
fm_list_model_iter_children (GtkTreeModel *tree_model, GtkTreeIter *iter, GtkTreeIter *parent)
{
FMListModel *model;
GSequence *files;
FileEntry *file_entry;
model = (FMListModel *)tree_model;
if (parent == NULL)
{
files = model->details->files;
}
else
{
file_entry = g_sequence_get (parent->user_data);
files = file_entry->files;
}
if (files == NULL || g_sequence_get_length (files) == 0)
{
return FALSE;
}
iter->stamp = model->details->stamp;
iter->user_data = g_sequence_get_begin_iter (files);
return TRUE;
}
gboolean
is_store_set_label(IsStore *self,
GtkTreeIter *iter,
const gchar *label)
{
IsStorePrivate *priv;
IsStoreEntry *entry = NULL;
gboolean ret = FALSE;
g_return_val_if_fail(IS_IS_STORE(self), FALSE);
g_return_val_if_fail(iter != NULL, FALSE);
priv = self->priv;
g_return_val_if_fail(iter->stamp == priv->stamp, FALSE);
g_return_val_if_fail(iter->user_data, FALSE);
entry = (IsStoreEntry *)g_sequence_get(iter->user_data);
if (entry->sensor &&
g_strcmp0(is_sensor_get_label(entry->sensor), label) != 0) {
GtkTreePath *path;
is_sensor_set_label(entry->sensor, label);
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);
ret = TRUE;
}
return ret;
}
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
fm_ogl_model_remove (FMOGLModel *model, GSequenceIter *iter)
{
FileEntry *file_entry;
file_entry = g_sequence_get (iter);
g_sequence_remove (iter);
}
static gboolean _is_store_iter_has_child(GtkTreeModel *tree_model,
GtkTreeIter *iter)
{
IsStore *self;
IsStorePrivate *priv;
IsStoreEntry *entry;
gboolean ret = FALSE;
g_return_val_if_fail(IS_IS_STORE(tree_model), FALSE);
g_return_val_if_fail(iter != NULL, FALSE);
self = IS_STORE(tree_model);
priv = self->priv;
g_return_val_if_fail(iter->stamp == priv->stamp, FALSE);
g_assert(iter->user_data);
/* end iter is invalid and has no entry associated with it */
if (!g_sequence_iter_is_end((GSequenceIter *)iter->user_data)) {
entry = (IsStoreEntry *)
g_sequence_get((GSequenceIter *)iter->user_data);
ret = (g_sequence_get_length(entry->entries) > 0);
}
return ret;
}
static void service_state_changed(struct connman_service *service,
enum connman_service_state state)
{
GHashTableIter iter;
gpointer key, value;
DBG("service %p state %d", service, state);
g_hash_table_iter_init(&iter, session_hash);
while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
struct connman_session *session = value;
GSequenceIter *service_iter;
service_iter = g_hash_table_lookup(session->service_hash, service);
if (service_iter != NULL) {
struct service_entry *entry;
entry = g_sequence_get(service_iter);
entry->state = state;
}
session_changed(session,
CONNMAN_SESSION_TRIGGER_SERVICE);
}
}
static GVariant *
g_menu_exporter_menu_describe_item (GMenuExporterMenu *menu,
gint position)
{
GMenuAttributeIter *attr_iter;
GVariantBuilder builder;
GSequenceIter *iter;
GMenuExporterLink *link;
const char *name;
GVariant *value;
g_variant_builder_init (&builder, G_VARIANT_TYPE_VARDICT);
attr_iter = g_menu_model_iterate_item_attributes (menu->model, position);
while (g_menu_attribute_iter_get_next (attr_iter, &name, &value))
{
g_variant_builder_add (&builder, "{sv}", name, value);
g_variant_unref (value);
}
g_object_unref (attr_iter);
iter = g_sequence_get_iter_at_pos (menu->item_links, position);
for (link = g_sequence_get (iter); link; link = link->next)
g_variant_builder_add (&builder, "{sv}", link->name,
g_variant_new ("(uu)", g_menu_exporter_group_get_id (link->menu->group), link->menu->id));
return g_variant_builder_end (&builder);
}
static void populate_service_list(struct connman_session *session)
{
struct service_entry *entry;
GSequenceIter *iter;
session->service_hash =
g_hash_table_new_full(g_direct_hash, g_direct_equal,
NULL, NULL);
session->service_list = __connman_service_get_list(session,
service_match,
create_service_entry,
destroy_service_entry);
g_sequence_sort(session->service_list, sort_services, session);
iter = g_sequence_get_begin_iter(session->service_list);
while (g_sequence_iter_is_end(iter) == FALSE) {
entry = g_sequence_get(iter);
DBG("service %p type %s name %s", entry->service,
service2bearer(connman_service_get_type(entry->service)),
entry->name);
g_hash_table_replace(session->service_hash,
entry->service, iter);
iter = g_sequence_iter_next(iter);
}
}
static void select_and_connect(struct connman_session *session,
enum connman_session_reason reason)
{
struct session_info *info = session->info;
struct service_entry *entry = NULL;
GSequenceIter *iter;
DBG("session %p reason %s", session, reason2string(reason));
info->reason = reason;
iter = g_sequence_get_begin_iter(session->service_list);
while (g_sequence_iter_is_end(iter) == FALSE) {
entry = g_sequence_get(iter);
switch (entry->state) {
case CONNMAN_SERVICE_STATE_ASSOCIATION:
case CONNMAN_SERVICE_STATE_CONFIGURATION:
case CONNMAN_SERVICE_STATE_READY:
case CONNMAN_SERVICE_STATE_ONLINE:
case CONNMAN_SERVICE_STATE_IDLE:
case CONNMAN_SERVICE_STATE_DISCONNECT:
select_service(info, entry);
return;
case CONNMAN_SERVICE_STATE_UNKNOWN:
case CONNMAN_SERVICE_STATE_FAILURE:
break;
}
iter = g_sequence_iter_next(iter);
}
}
gboolean
is_store_set_enabled(IsStore *self,
GtkTreeIter *iter,
gboolean enabled)
{
IsStorePrivate *priv;
IsStoreEntry *entry = NULL;
gboolean ret = FALSE;
g_return_val_if_fail(IS_IS_STORE(self), FALSE);
g_return_val_if_fail(iter != NULL, FALSE);
priv = self->priv;
g_return_val_if_fail(iter->stamp == priv->stamp, FALSE);
g_return_val_if_fail(iter->user_data, FALSE);
entry = (IsStoreEntry *)g_sequence_get(iter->user_data);
if (entry->sensor && entry->enabled != enabled) {
GtkTreePath *path;
entry->enabled = enabled;
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);
ret = TRUE;
}
return ret;
}
/**
* @brief Send message to each expired alarm.
*/
static void
notify_alarms(void)
{
time_t now;
bool fired = false;
now = reference_time();
GSequenceIter *iter = g_sequence_get_begin_iter(gAlarmQueue->alarms);
while (!g_sequence_iter_is_end(iter))
{
_Alarm *alarm = (_Alarm *)g_sequence_get(iter);
GSequenceIter *next = g_sequence_iter_next(iter);
if (alarm && alarm->expiry <= now)
{
fire_alarm(alarm);
g_sequence_remove(iter);
fired = true;
}
iter = next;
}
if (fired)
{
alarm_write_db();
}
}
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;
}
/**
* @brief Adjusts the alarm when a time set occurs and the wall clock
* and rtc clock diverge.
*
* This should also be called on init, in case of a crash before we
* were able to adjust the alarms successfully.
*
*/
void
recalculate_alarms(time_t delta)
{
if (delta)
{
/* Adjust each fixed time alarm by the delta.
* i.e. 5 seconds in the future + delta = T + 5 + delta
*/
GSequenceIter *iter = g_sequence_get_begin_iter(gAlarmQueue->alarms);
while (!g_sequence_iter_is_end(iter))
{
_Alarm *alarm = (_Alarm *)g_sequence_get(iter);
GSequenceIter *next = g_sequence_iter_next(iter);
if (alarm && !alarm->calendar)
{
alarm->expiry += delta;
}
iter = next;
}
/* resort */
g_sequence_sort(gAlarmQueue->alarms,
(GCompareDataFunc)alarm_cmp_func, NULL);
/* persist */
alarm_write_db();
}
return;
}
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);
}
}
}
static IdeProjectItem *
ide_project_files_find_child (IdeProjectItem *item,
const gchar *child)
{
GSequence *children;
GSequenceIter *iter;
g_assert (IDE_IS_PROJECT_ITEM (item));
g_assert (child);
children = ide_project_item_get_children (item);
if (!children)
return NULL;
for (iter = g_sequence_get_begin_iter (children);
!g_sequence_iter_is_end (iter);
iter = g_sequence_iter_next (iter))
{
IdeProjectItem *item = g_sequence_get (iter);
if (IDE_IS_PROJECT_FILE (item))
{
IdeProjectFile *file = IDE_PROJECT_FILE (item);
const gchar *name = ide_project_file_get_name (file);
if (g_strcmp0 (name, child) == 0)
return item;
}
}
return NULL;
}
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);
}
guint event_queue_execute(event_queue *equeue, guint time)
{
GSequence *queue = equeue->queue;
GSequenceIter *first_iter = g_sequence_get_begin_iter(queue);
GSequenceIter *current_iter = first_iter;
event_queue_entry *entry = NULL;
while(g_sequence_iter_is_end(current_iter) == FALSE) {
entry = (event_queue_entry *) g_sequence_get(current_iter);
if(entry->time > time) {
break;
}
current_iter = g_sequence_iter_next(current_iter);
if(entry->func != NULL) {
entry->func(time, entry->data);
}
}
g_sequence_remove_range(first_iter, current_iter);
if(g_sequence_get_length(queue) == 0) {
return G_MAXUINT;
}
return entry->time;
}
static gpointer
photos_base_manager_get_item (GListModel *list, guint position)
{
PhotosBaseManager *self = PHOTOS_BASE_MANAGER (list);
PhotosBaseManagerPrivate *priv;
GSequenceIter *iter = NULL;
gpointer ret_val = NULL;
priv = photos_base_manager_get_instance_private (self);
if (priv->last_position != G_MAXUINT)
{
if (priv->last_position == position + 1)
iter = g_sequence_iter_prev (priv->last_iter);
else if (priv->last_position == position - 1)
iter = g_sequence_iter_next (priv->last_iter);
else if (priv->last_position == position)
iter = priv->last_iter;
}
if (iter == NULL)
iter = g_sequence_get_iter_at_pos (priv->sequence, position);
priv->last_iter = iter;
priv->last_position = position;
if (g_sequence_iter_is_end (iter))
goto out;
ret_val = g_object_ref (g_sequence_get (iter));
out:
return ret_val;
}