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);
}
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 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 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;
}
gboolean fm_folder_model_iter_next(GtkTreeModel *tree_model,
GtkTreeIter *iter)
{
GSequenceIter* item_it, *next_item_it;
FmFolderModel* model;
g_return_val_if_fail(FM_IS_FOLDER_MODEL(tree_model), FALSE);
if( iter == NULL || iter->user_data == NULL )
return FALSE;
model = FM_FOLDER_MODEL(tree_model);
item_it = (GSequenceIter *)iter->user_data;
/* Is this the last iter in the list? */
next_item_it = g_sequence_iter_next(item_it);
if( g_sequence_iter_is_end(next_item_it) )
return FALSE;
iter->stamp = model->stamp;
iter->user_data = next_item_it;
return TRUE;
}
/**
* @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;
}
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 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;
}
}
/**
* @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 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;
}
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 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);
}
}
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);
}
void
swfdec_text_buffer_set_attributes (SwfdecTextBuffer *buffer, gsize start,
gsize length, const SwfdecTextAttributes *attr, guint mask)
{
SwfdecTextBufferFormat *format;
GSequenceIter *start_iter, *iter, *end_iter;
gsize end;
g_return_if_fail (SWFDEC_IS_TEXT_BUFFER (buffer));
g_return_if_fail (start + length <= buffer->text->len);
g_return_if_fail (length > 0);
g_return_if_fail (attr != NULL);
g_return_if_fail (mask != 0);
/* ensure start and end position have an attribtues entry. If not, create one */
end = start + length;
start_iter = swfdec_text_buffer_get_iter_for_pos (buffer, start);
format = g_sequence_get (start_iter);
if (format->start < start) {
start_iter = swfdec_text_buffer_copy_format (buffer, start_iter, start);
}
if (end == buffer->text->len) {
end_iter = g_sequence_get_end_iter (buffer->attributes);
} else {
end_iter = swfdec_text_buffer_get_iter_for_pos (buffer, end);
format = g_sequence_get (end_iter);
if (format->start < end) {
end_iter = swfdec_text_buffer_copy_format (buffer, end_iter, end);
}
}
/* start_iter points to first item to modify, end_iter points after last item to modify */
/* modify all formats in range [start_iter, end_iter) */
for (iter = start_iter; iter != end_iter; iter = g_sequence_iter_next (iter)) {
format = g_sequence_get (iter);
swfdec_text_attributes_copy (&format->attr, attr, mask);
}
/* remove entries that are identical now */
swfdec_text_buffer_remove_duplicates (g_sequence_iter_prev (start_iter),
g_sequence_iter_next (end_iter));
CHECK_ATTRIBUTES (buffer);
g_signal_emit (buffer, signals[TEXT_CHANGED], 0);
}
SwfdecTextBufferIter *
swfdec_text_buffer_iter_next (SwfdecTextBuffer *buffer, SwfdecTextBufferIter *iter)
{
g_return_val_if_fail (SWFDEC_IS_TEXT_BUFFER (buffer), NULL);
g_return_val_if_fail (iter != NULL, NULL);
iter = g_sequence_iter_next (iter);
return g_sequence_iter_is_end (iter) ? NULL : iter;
}
/* removes duplicates in the range [iter, end) */
static void
swfdec_text_buffer_remove_duplicates (GSequenceIter *iter, GSequenceIter *end)
{
SwfdecTextBufferFormat *format, *next;
g_assert (iter != end);
format = g_sequence_get (iter);
for (iter = g_sequence_iter_next (iter); iter != end; iter = g_sequence_iter_next (iter)) {
next = g_sequence_get (iter);
if (swfdec_text_attributes_diff (&format->attr, &next->attr) == 0) {
GSequenceIter *prev = g_sequence_iter_prev (iter);
g_sequence_remove (iter);
iter = prev;
} else {
format = next;
}
}
}
static ClutterModelIter *
clutter_list_model_iter_next (ClutterModelIter *iter)
{
ClutterListModelIter *iter_default;
ClutterModelIter *temp_iter;
ClutterModel *model = NULL;
GSequenceIter *filter_next;
guint row;
iter_default = CLUTTER_LIST_MODEL_ITER (iter);
g_assert (iter_default->seq_iter != NULL);
model = clutter_model_iter_get_model (iter);
row = clutter_model_iter_get_row (iter);
filter_next = g_sequence_iter_next (iter_default->seq_iter);
g_assert (filter_next != NULL);
temp_iter = CLUTTER_LIST_MODEL (model)->priv->temp_iter;
while (!g_sequence_iter_is_end (filter_next))
{
CLUTTER_LIST_MODEL_ITER (temp_iter)->seq_iter = filter_next;
if (clutter_model_filter_iter (model, temp_iter))
{
row += 1;
break;
}
filter_next = g_sequence_iter_next (filter_next);
}
if (g_sequence_iter_is_end (filter_next))
row += 1;
/* update the iterator and return it */
clutter_model_iter_set_row (CLUTTER_MODEL_ITER (iter_default), row);
iter_default->seq_iter = filter_next;
return CLUTTER_MODEL_ITER (iter_default);
}
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;
}
}
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;
}
static gboolean
fm_list_model_iter_next (GtkTreeModel *tree_model, GtkTreeIter *iter)
{
FMListModel *model;
model = (FMListModel *)tree_model;
g_return_val_if_fail (model->details->stamp == iter->stamp, FALSE);
iter->user_data = g_sequence_iter_next (iter->user_data);
return !g_sequence_iter_is_end (iter->user_data);
}
static GSequenceIter *
swfdec_text_buffer_copy_format (SwfdecTextBuffer *buffer, GSequenceIter *iter,
gsize pos)
{
SwfdecTextBufferFormat *format, *new_format;
format = g_sequence_get (iter);
new_format = swfdec_text_buffer_format_new ();
new_format->start = pos;
swfdec_text_attributes_copy (&new_format->attr, &format->attr,
SWFDEC_TEXT_ATTRIBUTES_MASK);
return g_sequence_insert_before (g_sequence_iter_next (iter), new_format);
}
/* 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);
}
static void
CHECK_ATTRIBUTES (SwfdecTextBuffer *buffer)
{
guint last;
GSequenceIter *iter;
SwfdecTextBufferFormat *format;
iter = g_sequence_get_begin_iter (buffer->attributes);
if (g_sequence_iter_is_end (iter)) {
g_assert (buffer->text->len == 0);
return;
}
format = g_sequence_get (iter);
g_assert (format->start == 0);
g_assert (buffer->text->len > 0);
last = 0;
for (iter = g_sequence_iter_next (iter); !g_sequence_iter_is_end (iter); iter = g_sequence_iter_next (iter)) {
format = g_sequence_get (iter);
g_assert (format->start > last);
g_assert (format->start < buffer->text->len);
last = format->start;
}
}
void
swfdec_text_buffer_delete_text (SwfdecTextBuffer *buffer,
gsize pos, gsize length)
{
GSequenceIter *iter, *prev;
SwfdecTextBufferFormat *format;
gsize end;
g_return_if_fail (SWFDEC_IS_TEXT_BUFFER (buffer));
g_return_if_fail (pos + length <= buffer->text->len);
g_return_if_fail (length > 0);
g_string_erase (buffer->text, pos, length);
end = pos + length;
prev = NULL;
for (iter = swfdec_text_buffer_get_iter_for_pos (buffer, pos);
!g_sequence_iter_is_end (iter);
iter = g_sequence_iter_next (iter)) {
format = g_sequence_get (iter);
if (format->start < pos)
continue;
if (format->start > end) {
format->start -= length;
continue;
}
if (prev)
g_sequence_remove (prev);
format->start = pos;
prev = iter;
}
if (prev && pos == buffer->text->len)
g_sequence_remove (prev);
CHECK_ATTRIBUTES (buffer);
/* adapt cursor */
if (buffer->cursor_start > end)
buffer->cursor_start -= length;
else if (buffer->cursor_start > pos)
buffer->cursor_start = pos;
if (buffer->cursor_end > end)
buffer->cursor_end -= length;
else if (buffer->cursor_end > pos)
buffer->cursor_end = pos;
g_signal_emit (buffer, signals[TEXT_CHANGED], 0);
g_signal_emit (buffer, signals[CURSOR_CHANGED], 0,
(gulong) MIN (buffer->cursor_start, buffer->cursor_end),
(gulong) MAX (buffer->cursor_start, buffer->cursor_end));
}
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;
}
static gboolean
bt_pattern_list_model_tree_model_iter_next (GtkTreeModel * tree_model,
GtkTreeIter * iter)
{
BtPatternListModel *model = BT_PATTERN_LIST_MODEL (tree_model);
gboolean res;
g_return_val_if_fail (model->priv->stamp == iter->stamp, FALSE);
iter->user_data = g_sequence_iter_next (iter->user_data);
if ((res = g_sequence_iter_is_end (iter->user_data)))
iter->stamp = 0;
return !res;
}
