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);
}
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
g_dbus_menu_group_changed (GDBusMenuGroup *group,
guint menu_id,
gint position,
gint removed,
GVariant *added)
{
GSequenceIter *point;
GVariantIter iter;
GDBusMenuModel *proxy;
GSequence *items;
GVariant *item;
gint n_added;
/* We could have signals coming to us when we're not active (due to
* some other process having subscribed to this group) or when we're
* pending. In both of those cases, we want to ignore the signal
* since we'll get our own information when we call "Start" for
* ourselves.
*/
if (group->state != GROUP_ONLINE)
return;
items = g_hash_table_lookup (group->menus, GINT_TO_POINTER (menu_id));
if (items == NULL)
{
items = g_sequence_new (g_dbus_menu_model_item_free);
g_hash_table_insert (group->menus, GINT_TO_POINTER (menu_id), items);
}
point = g_sequence_get_iter_at_pos (items, position + removed);
g_return_if_fail (point != NULL);
if (removed)
{
GSequenceIter *start;
start = g_sequence_get_iter_at_pos (items, position);
g_sequence_remove_range (start, point);
}
n_added = g_variant_iter_init (&iter, added);
while (g_variant_iter_loop (&iter, "@a{sv}", &item))
g_sequence_insert_before (point, g_dbus_menu_group_create_item (item));
if (g_sequence_get_length (items) == 0)
{
g_hash_table_remove (group->menus, GINT_TO_POINTER (menu_id));
items = NULL;
}
if ((proxy = g_hash_table_lookup (group->proxies, GINT_TO_POINTER (menu_id))))
g_dbus_menu_model_changed (proxy, items, position, removed, n_added);
}
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
g_menu_exporter_menu_items_changed (GMenuModel *model,
gint position,
gint removed,
gint added,
gpointer user_data)
{
GMenuExporterMenu *menu = user_data;
GSequenceIter *point;
gint i;
g_assert (menu->model == model);
g_assert (menu->item_links != NULL);
g_assert (position + removed <= g_sequence_get_length (menu->item_links));
point = g_sequence_get_iter_at_pos (menu->item_links, position + removed);
g_sequence_remove_range (g_sequence_get_iter_at_pos (menu->item_links, position), point);
for (i = position; i < position + added; i++)
g_sequence_insert_before (point, g_menu_exporter_menu_create_links (menu, i));
if (g_menu_exporter_group_is_subscribed (menu->group))
{
GVariantBuilder builder;
g_variant_builder_init (&builder, G_VARIANT_TYPE ("(uuuuaa{sv})"));
g_variant_builder_add (&builder, "u", g_menu_exporter_group_get_id (menu->group));
g_variant_builder_add (&builder, "u", menu->id);
g_variant_builder_add (&builder, "u", position);
g_variant_builder_add (&builder, "u", removed);
g_variant_builder_open (&builder, G_VARIANT_TYPE ("aa{sv}"));
for (i = position; i < position + added; i++)
g_variant_builder_add_value (&builder, g_menu_exporter_menu_describe_item (menu, i));
g_variant_builder_close (&builder);
g_menu_exporter_report (g_menu_exporter_group_get_exporter (menu->group), g_variant_builder_end (&builder));
}
}
