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);
}
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 free_segment(struct segment* s) {
GSequenceIter *begin = g_sequence_get_begin_iter(s->chunks);
GSequenceIter *end = g_sequence_get_end_iter(s->chunks);
for(; begin != end; begin = g_sequence_get_begin_iter(s->chunks)){
free_chunk(g_sequence_get(begin));
g_sequence_remove(begin);
}
g_sequence_free(s->chunks);
if (s->features)
g_hash_table_destroy(s->features);
free(s);
}
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;
}
}
}
gboolean fm_folder_model_iter_children(GtkTreeModel *tree_model,
GtkTreeIter *iter,
GtkTreeIter *parent)
{
FmFolderModel* model;
GSequenceIter* items_it;
g_return_val_if_fail(parent == NULL || parent->user_data != NULL, FALSE);
/* this is a list, nodes have no children */
if( parent )
return FALSE;
/* parent == NULL is a special case; we need to return the first top-level row */
g_return_val_if_fail(FM_IS_FOLDER_MODEL(tree_model), FALSE);
model = FM_FOLDER_MODEL(tree_model);
/* No rows => no first row */
// if ( model->dir->n_items == 0 )
// return FALSE;
/* Set iter to first item in list */
g_sequence_get_begin_iter(model->items);
iter->stamp = model->stamp;
iter->user_data = items_it;
return TRUE;
}
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;
}
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;
}
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;
}
void rclib_lyric_clean(guint index)
{
RCLibLyricParsedData *parsed_data;
RCLibLyricPrivate *priv;
GSequenceIter *begin_iter, *end_iter;
if(lyric_instance==NULL) return;
priv = RCLIB_LYRIC(lyric_instance)->priv;
if(priv==NULL) return;
if(index==1)
parsed_data = &(priv->parsed_data2);
else
parsed_data = &(priv->parsed_data1);
g_free(parsed_data->title);
parsed_data->title = NULL;
g_free(parsed_data->artist);
parsed_data->artist = NULL;
g_free(parsed_data->album);
parsed_data->album = NULL;
g_free(parsed_data->author);
parsed_data->author = NULL;
g_free(parsed_data->filename);
parsed_data->filename = NULL;
parsed_data->offset = 0;
if(parsed_data->seq==NULL) return;
begin_iter = g_sequence_get_begin_iter(parsed_data->seq);
end_iter = g_sequence_get_end_iter(parsed_data->seq);
if(begin_iter==NULL || end_iter==NULL) return;
g_sequence_remove_range(begin_iter, end_iter);
}
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;
}
}
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 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;
}
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);
}
}
/**
* @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;
}
/**
* @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 inline void
update_gaps (GESTrack * track)
{
Gap *gap;
GList *gaps;
GSequenceIter *it;
GESTrackElement *trackelement;
GstClockTime start, end, duration = 0, timeline_duration;
GESTrackPrivate *priv = track->priv;
if (priv->create_element_for_gaps == NULL) {
GST_INFO ("Not filling the gaps as no create_element_for_gaps vmethod"
" provided");
return;
}
gaps = priv->gaps;
priv->gaps = NULL;
/* 1- And recalculate gaps */
for (it = g_sequence_get_begin_iter (priv->trackelements_by_start);
g_sequence_iter_is_end (it) == FALSE; it = g_sequence_iter_next (it)) {
trackelement = g_sequence_get (it);
start = _START (trackelement);
end = start + _DURATION (trackelement);
if (start > duration) {
/* 2- Fill gap */
gap = gap_new (track, duration, start - duration);
if (G_LIKELY (gap != NULL))
priv->gaps = g_list_prepend (priv->gaps, gap);
}
duration = MAX (duration, end);
}
/* 4- Add a gap at the end of the timeline if needed */
if (priv->timeline) {
g_object_get (priv->timeline, "duration", &timeline_duration, NULL);
if (duration < timeline_duration) {
gap = gap_new (track, duration, timeline_duration - duration);
if (G_LIKELY (gap != NULL)) {
priv->gaps = g_list_prepend (priv->gaps, gap);
}
priv->duration = timeline_duration;
}
}
/* 4- Remove old gaps */
g_list_free_full (gaps, (GDestroyNotify) free_gap);
}
static void
byzanz_recorder_dispose (GObject *object)
{
ByzanzRecorder *recorder = BYZANZ_RECORDER (object);
g_sequence_remove_range (g_sequence_get_begin_iter (recorder->layers),
g_sequence_get_end_iter (recorder->layers));
G_OBJECT_CLASS (byzanz_recorder_parent_class)->dispose (object);
}
static void
fm_ogl_model_clear_directory (FMOGLModel *model, GSequence *files)
{
GSequenceIter *iter = g_sequence_get_begin_iter(files);
while( iter != g_sequence_get_end_iter(files)){
GSequenceIter *iter_next = g_sequence_iter_next(iter);
fm_ogl_model_remove(model, iter);
iter = iter_next;
}
}
/**
* @brief Obtain the next alarm that will fire.
*
*/
_Alarm *
alarm_queue_get_first(void)
{
GSequenceIter *seq =
g_sequence_get_begin_iter(gAlarmQueue->alarms);
if (g_sequence_iter_is_end(seq))
return NULL;
_Alarm *alarm = (_Alarm*)g_sequence_get(seq);
return alarm;
}
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);
}
static cairo_surface_t *
byzanz_recorder_create_snapshot (ByzanzRecorder *recorder, const cairo_region_t *invalid)
{
cairo_rectangle_int_t extents;
cairo_surface_t *surface;
cairo_t *cr;
GSequenceIter *iter;
int i, num_rects;
cairo_region_get_extents (invalid, &extents);
cr = gdk_cairo_create (recorder->window);
surface = cairo_surface_create_similar (cairo_get_target (cr), CAIRO_CONTENT_COLOR,
extents.width, extents.height);
cairo_destroy (cr);
cairo_surface_set_device_offset (surface, -extents.x, -extents.y);
cr = cairo_create (surface);
num_rects = cairo_region_num_rectangles (invalid);
for (i = 0; i < num_rects; i++) {
cairo_rectangle_int_t rect;
cairo_region_get_rectangle (invalid, i, &rect);
cairo_rectangle (cr, rect.x, rect.y,
rect.width, rect.height);
}
cairo_clip (cr);
for (iter = g_sequence_get_begin_iter (recorder->layers);
!g_sequence_iter_is_end (iter);
iter = g_sequence_iter_next (iter)) {
ByzanzLayer *layer = g_sequence_get (iter);
ByzanzLayerClass *klass = BYZANZ_LAYER_GET_CLASS (layer);
cairo_save (cr);
klass->render (layer, cr);
if (cairo_status (cr))
g_critical ("error capturing image: %s", cairo_status_to_string (cairo_status (cr)));
cairo_restore (cr);
}
cairo_destroy (cr);
surface = ensure_image_surface (surface, invalid);
/* adjust device offset here - the layers work in GdkScreen coordinates, the rest
* of the code works in coordinates realtive to the passed in area. */
cairo_surface_set_device_offset (surface,
recorder->area.x - extents.x, recorder->area.y - extents.y);
return surface;
}
void send_segment(struct segment* s) {
/*
* CHUNK_SEGMENT_START and _END are used for
* reconstructing the segment in filter phase.
*/
struct chunk* ss = new_chunk(0);
SET_CHUNK(ss, CHUNK_SEGMENT_START);
sync_queue_push(dedup_queue, ss);
GSequenceIter *end = g_sequence_get_end_iter(s->chunks);
GSequenceIter *begin = g_sequence_get_begin_iter(s->chunks);
while(begin != end) {
struct chunk* c = g_sequence_get(begin);
if (!CHECK_CHUNK(c, CHUNK_FILE_START) && !CHECK_CHUNK(c, CHUNK_FILE_END)) {
if (CHECK_CHUNK(c, CHUNK_DUPLICATE)) {
if (c->id == TEMPORARY_ID) {
DEBUG("Dedup phase: %ldth chunk is identical to a unique chunk",
chunk_num++);
} else {
DEBUG("Dedup phase: %ldth chunk is duplicate in container %lld",
chunk_num++, c->id);
}
} else {
DEBUG("Dedup phase: %ldth chunk is unique", chunk_num++);
}
}
sync_queue_push(dedup_queue, c);
g_sequence_remove(begin);
begin = g_sequence_get_begin_iter(s->chunks);
}
struct chunk* se = new_chunk(0);
SET_CHUNK(se, CHUNK_SEGMENT_END);
sync_queue_push(dedup_queue, se);
s->chunk_num = 0;
}
static gboolean _is_store_iter_children(GtkTreeModel *tree_model,
GtkTreeIter *iter,
GtkTreeIter *parent)
{
IsStore *self;
IsStorePrivate *priv;
IsStoreEntry *entry;
gboolean ret = FALSE;
g_return_val_if_fail(IS_IS_STORE(tree_model), FALSE);
self = IS_STORE(tree_model);
priv = self->priv;
/* special case - return first node */
if (!parent) {
GSequenceIter *seq_iter =
g_sequence_get_begin_iter(priv->entries);
if (seq_iter) {
iter->stamp = priv->stamp;
iter->user_data = seq_iter;
ret = TRUE;
}
goto out;
}
g_return_val_if_fail(parent->stamp == priv->stamp, FALSE);
g_assert(parent->user_data);
entry = (IsStoreEntry *)g_sequence_get(parent->user_data);
if (!entry->sensor) {
iter->stamp = priv->stamp;
iter->user_data = g_sequence_get_begin_iter(entry->entries);
ret = TRUE;
}
out:
return ret;
}
static gint64
g_file_monitor_source_get_ready_time (GFileMonitorSource *fms)
{
GSequenceIter *iter;
if (fms->event_queue.length)
return 0;
iter = g_sequence_get_begin_iter (fms->pending_changes);
if (g_sequence_iter_is_end (iter))
return -1;
return pending_change_get_ready_time (g_sequence_get (iter), fms);
}
/* FIXME: how about hidden files? */
void on_thumbnail_local_changed(FmConfig* cfg, gpointer user_data)
{
FmFolderModel* model = (FmFolderModel*)user_data;
FmThumbnailRequest* req;
GList* new_reqs = NULL;
GSequenceIter* seq_it;
FmFileInfo* fi;
if(cfg->thumbnail_local)
{
GList* l; /* remove non-local files from thumbnail requests */
for(l = model->thumbnail_requests; l; )
{
GList* next = l->next;
req = (FmThumbnailRequest*)l->data;
fi = fm_thumbnail_request_get_file_info(req);
if(!fm_path_is_local(fi->path))
{
fm_thumbnail_request_cancel(req);
model->thumbnail_requests = g_list_delete_link(model->thumbnail_requests, l);
/* FIXME: item->thumbnail_loading should be set to FALSE. */
}
l = next;
}
}
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);
fi = item->inf;
if(cfg->thumbnail_local)
{
/* add all non-local files to thumbnail requests */
if(!fm_path_is_local(fi->path))
reload_thumbnail(model, seq_it, item);
}
else
{
/* add all non-local files to thumbnail requests */
if(!fm_path_is_local(fi->path))
{
req = fm_thumbnail_request(fi, model->icon_size, on_thumbnail_loaded, model);
new_reqs = g_list_append(new_reqs, req);
}
}
seq_it = g_sequence_iter_next(seq_it);
}
if(new_reqs)
model->thumbnail_requests = g_list_concat(model->thumbnail_requests, new_reqs);
}
gboolean fm_folder_model_find_iter_by_filename(FmFolderModel* model, GtkTreeIter* it, const char* name)
{
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* item = (FmFolderItem*)g_sequence_get(item_it);
if( g_strcmp0(item->inf->path->name, name) == 0 )
{
it->stamp = model->stamp;
it->user_data = item_it;
return TRUE;
}
}
return FALSE;
}
Container* container_cache_lookup(ContainerCache *cc, Fingerprint *finger) {
Container *container = 0;
GSequence *container_list = g_hash_table_lookup(cc->map, finger);
if (container_list) {
container = g_sequence_get(g_sequence_get_begin_iter(container_list));
/*container = g_sequence_get(g_sequence_search(container_list, &tmp, container_cmp_des, NULL));*/
if (container) {
if (!lru_cache_lookup(cc->lru_cache, container_equal, container)) {
printf("%s, %d: inconsistency between map and cache.\n",
__FILE__, __LINE__);
}
}
}
return container;
}
static gboolean
bt_pattern_list_model_tree_model_iter_children (GtkTreeModel * tree_model,
GtkTreeIter * iter, GtkTreeIter * parent)
{
BtPatternListModel *model = BT_PATTERN_LIST_MODEL (tree_model);
/* this is a list, nodes have no children */
if (!parent) {
if (g_sequence_get_length (model->priv->seq) > 0) {
iter->stamp = model->priv->stamp;
iter->user_data = g_sequence_get_begin_iter (model->priv->seq);
return TRUE;
}
}
iter->stamp = 0;
return FALSE;
}
void
desktop_file_index_text_index_populate_strings (GSequence *text_index,
GHashTable *string_table)
{
GSequenceIter *iter;
iter = g_sequence_get_begin_iter (text_index);
while (!g_sequence_iter_is_end (iter))
{
DesktopFileIndexTextIndexItem *item = g_sequence_get (iter);
desktop_file_index_string_table_add_string (string_table, item->token);
iter = g_sequence_iter_next (iter);
}
}
extern gboolean
power_supply_is_ac_online(power_supply* ps)
{
gboolean ac_online = FALSE;
GSequenceIter* it;
ac* ac_power;
if (ps->ac_list != NULL) {
it = g_sequence_get_begin_iter(ps->ac_list);
while (!g_sequence_iter_is_end(it)) {
ac_power = (ac*) g_sequence_get(it);
if (ac_power->online) {
ac_online = TRUE;
break;
}
it = g_sequence_iter_next(it);
}
}
return ac_online;
}
