static GSequenceIter *
find_first_proposal (GscProviderDevhelp *devhelp)
{
GSequenceIter *iter;
GSequenceIter *prev;
iter = g_sequence_search (devhelp->priv->proposals,
NULL,
(GCompareDataFunc)compare_items,
devhelp);
if (iter == NULL)
{
return NULL;
}
/* Test if this position might be after the last match */
if (!g_sequence_iter_is_begin (iter) &&
(g_sequence_iter_is_end (iter) ||
!iter_match_prefix (devhelp, iter)))
{
iter = g_sequence_iter_prev (iter);
/* Maybe there is actually nothing in the sequence */
if (g_sequence_iter_is_end (iter) ||
!iter_match_prefix (devhelp, iter))
{
return NULL;
}
}
if (g_sequence_iter_is_end (iter))
{
return NULL;
}
/* Go back while it matches */
while (iter &&
(prev = g_sequence_iter_prev (iter)) &&
iter_match_prefix (devhelp, prev))
{
iter = prev;
if (g_sequence_iter_is_begin (iter))
{
break;
}
}
return iter;
}
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 ClutterModelIter *
clutter_list_model_iter_prev (ClutterModelIter *iter)
{
ClutterListModelIter *iter_default;
ClutterModelIter *temp_iter;
ClutterModel *model;
GSequenceIter *filter_prev;
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_prev = g_sequence_iter_prev (iter_default->seq_iter);
g_assert (filter_prev != NULL);
temp_iter = CLUTTER_LIST_MODEL (model)->priv->temp_iter;
while (!g_sequence_iter_is_begin (filter_prev))
{
CLUTTER_LIST_MODEL_ITER (temp_iter)->seq_iter = filter_prev;
if (clutter_model_filter_iter (model, temp_iter))
{
row -= 1;
break;
}
filter_prev = g_sequence_iter_prev (filter_prev);
}
if (g_sequence_iter_is_begin (filter_prev))
row -= 1;
/* update the iterator and return it */
clutter_model_iter_set_row (CLUTTER_MODEL_ITER (iter_default), row);
iter_default->seq_iter = filter_prev;
return CLUTTER_MODEL_ITER (iter_default);
}
static gboolean
clutter_list_model_iter_is_last (ClutterModelIter *iter)
{
ClutterListModelIter *iter_default;
ClutterModelIter *temp_iter;
ClutterModel *model;
GSequence *sequence;
GSequenceIter *begin, *end;
iter_default = CLUTTER_LIST_MODEL_ITER (iter);
g_assert (iter_default->seq_iter != NULL);
if (g_sequence_iter_is_end (iter_default->seq_iter))
return TRUE;
model = clutter_model_iter_get_model (iter);
sequence = CLUTTER_LIST_MODEL (model)->priv->sequence;
begin = g_sequence_get_end_iter (sequence);
begin = g_sequence_iter_prev (begin);
end = iter_default->seq_iter;
temp_iter = CLUTTER_LIST_MODEL (model)->priv->temp_iter;
while (!g_sequence_iter_is_begin (begin))
{
CLUTTER_LIST_MODEL_ITER (temp_iter)->seq_iter = begin;
if (clutter_model_filter_iter (model, temp_iter))
{
end = begin;
break;
}
begin = g_sequence_iter_prev (begin);
}
/* This is because the 'end_iter' is always *after* the last valid iter.
* Otherwise we'd have endless loops
*/
end = g_sequence_iter_next (end);
return iter_default->seq_iter == end;
}
/**
* gst_timed_value_control_source_find_control_point_iter:
* @self: the control source to search in
* @timestamp: the search key
*
* Find last value before given timestamp in control point list.
* If all values in the control point list come after the given
* timestamp or no values exist, %NULL is returned.
*
* For use in control source implementations.
*
* Returns: (transfer none): the found #GSequenceIter or %NULL
*/
GSequenceIter *gst_timed_value_control_source_find_control_point_iter
(GstTimedValueControlSource * self, GstClockTime timestamp)
{
GSequenceIter *iter;
if (!self->values)
return NULL;
iter =
g_sequence_search (self->values, ×tamp,
(GCompareDataFunc) gst_control_point_find, NULL);
/* g_sequence_search() returns the iter where timestamp
* would be inserted, i.e. the iter > timestamp, so
* we need to get the previous one. And of course, if
* there is no previous one, we return NULL. */
if (g_sequence_iter_is_begin (iter))
return NULL;
return g_sequence_iter_prev (iter);
}
RmOff rm_offset_bytes_to_next_fragment(RmOffsetTable offset_list, RmOff file_offset) {
if (offset_list != NULL) {
RmOffsetEntry token;
token.physical = 0;
token.logical = file_offset;
GSequenceIter *next_fragment = g_sequence_iter_prev(
g_sequence_search(
offset_list, &token,
(GCompareDataFunc)rm_offset_find_logical, NULL
)
);
if(!g_sequence_iter_is_end(next_fragment) && !g_sequence_iter_is_begin(next_fragment) ) {
RmOffsetEntry *off = g_sequence_get(next_fragment);
return off->logical - file_offset;
}
}
/* default to 0 always */
return 0;
}
gboolean rclib_lyric_load_file(const gchar *filename, guint index)
{
RCLibLyricParsedData *parsed_data;
gchar *line;
GFile *file;
GFileInputStream *input_stream;
GDataInputStream *data_stream;
gsize line_len;
gint64 time = -1;
RCLibLyricPrivate *priv;
GSequenceIter *iter;
RCLibLyricData *lyric_data;
rclib_lyric_clean(index);
if(lyric_instance==NULL) return FALSE;
if(filename==NULL) return FALSE;
priv = RCLIB_LYRIC(lyric_instance)->priv;
if(priv==NULL) return FALSE;
file = g_file_new_for_path(filename);
if(file==NULL) return FALSE;
if(!g_file_query_exists(file, NULL))
{
g_object_unref(file);
return FALSE;
}
input_stream = g_file_read(file, NULL, NULL);
g_object_unref(file);
if(input_stream==NULL) return FALSE;
data_stream = g_data_input_stream_new(G_INPUT_STREAM(input_stream));
g_object_unref(input_stream);
if(data_stream==NULL) return FALSE;
g_data_input_stream_set_newline_type(data_stream,
G_DATA_STREAM_NEWLINE_TYPE_ANY);
if(index==1)
parsed_data = &(priv->parsed_data2);
else
parsed_data = &(priv->parsed_data1);
if(index!=1) index = 0;
while((line=g_data_input_stream_read_line(data_stream, &line_len,
NULL, NULL))!=NULL)
{
rclib_lyric_add_line(parsed_data, priv->regex, priv->encoding,
line, line_len);
g_free(line);
}
g_object_unref(data_stream);
for(iter = g_sequence_get_end_iter(parsed_data->seq);
!g_sequence_iter_is_begin(iter);)
{
iter = g_sequence_iter_prev(iter);
lyric_data = g_sequence_get(iter);
if(lyric_data==NULL) continue;
if(time>=0)
{
lyric_data->length = time - lyric_data->time;
}
time = lyric_data->time;
}
parsed_data->filename = g_strdup(filename);
g_signal_emit(lyric_instance, lyric_signals[SIGNAL_LYRIC_READY], 0,
index);
return TRUE;
}
static ClutterModelIter *
clutter_list_model_get_iter_at_row (ClutterModel *model,
guint row)
{
ClutterListModel *model_default = CLUTTER_LIST_MODEL (model);
GSequence *sequence = model_default->priv->sequence;
gint seq_length = g_sequence_get_length (sequence);
ClutterListModelIter *retval;
if (row >= seq_length)
return NULL;
retval = g_object_new (CLUTTER_TYPE_LIST_MODEL_ITER,
"model", model,
"row", row,
NULL);
/* short-circuit in case we don't have a filter in place */
if (!clutter_model_get_filter_set (model))
{
retval->seq_iter = g_sequence_get_iter_at_pos (sequence, row);
return CLUTTER_MODEL_ITER (retval);
}
if (row == 0)
{
GSequenceIter *filter_next;
gboolean row_found = FALSE;
filter_next = g_sequence_get_begin_iter (sequence);
g_assert (filter_next != NULL);
while (!g_sequence_iter_is_end (filter_next))
{
retval->seq_iter = filter_next;
if (clutter_model_filter_iter (model, CLUTTER_MODEL_ITER (retval)))
{
/* We've found a row that is valid under the filter */
row_found = TRUE;
break;
}
filter_next = g_sequence_iter_next (filter_next);
}
/* Everything has been filtered -> there is no first row */
if (!row_found)
{
g_object_unref (retval);
return NULL;
}
}
else
{
GSequenceIter *filter_prev;
filter_prev = g_sequence_get_end_iter (sequence);
g_assert (filter_prev != NULL);
filter_prev = g_sequence_iter_prev (filter_prev);
while (!g_sequence_iter_is_begin (filter_prev))
{
retval->seq_iter = filter_prev;
if (clutter_model_filter_iter (model, CLUTTER_MODEL_ITER (retval)))
break;
filter_prev = g_sequence_iter_prev (filter_prev);
}
}
return CLUTTER_MODEL_ITER (retval);
}
