isa/mutter
1
0
Fork 0
mirror of https://github.com/brl/mutter.git synced 2024-11-21 15:40:41 -05:00
Code Issues Packages Projects Releases Wiki Activity

clutter: remove unused deprecated types

Browse Source 
They weren't being used anywhere, so they can be easily removed without
going into other files.
This commit is contained in:
Niels De Graef 2018-11-10 12:14:02 +01:00
parent 787bb4316d
commit 1c7472b24d
23 changed files with 0 additions and 7769 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
clutter/clutter/Makefile.am
View File

@ -271,16 +271,11 @@ deprecated_h = \
deprecated/clutter-box.h \
deprecated/clutter-cairo-texture.h \
deprecated/clutter-container.h \
deprecated/clutter-frame-source.h \
deprecated/clutter-group.h \
deprecated/clutter-input-device.h \
deprecated/clutter-keysyms.h \
deprecated/clutter-list-model.h \
deprecated/clutter-main.h \
deprecated/clutter-media.h \
deprecated/clutter-model.h \
deprecated/clutter-rectangle.h \
deprecated/clutter-score.h \
deprecated/clutter-shader.h \
deprecated/clutter-stage-manager.h \
deprecated/clutter-stage.h \
@ -288,7 +283,6 @@ deprecated_h = \
deprecated/clutter-table-layout.h \
deprecated/clutter-texture.h \
deprecated/clutter-timeline.h \
deprecated/clutter-timeout-pool.h \
deprecated/clutter-util.h \
$(NULL)
@ -307,31 +301,14 @@ deprecated_c = \
deprecated/clutter-behaviour-scale.c \
deprecated/clutter-box.c \
deprecated/clutter-cairo-texture.c \
deprecated/clutter-frame-source.c \
deprecated/clutter-group.c \
deprecated/clutter-input-device-deprecated.c \
deprecated/clutter-layout-manager-deprecated.c \
deprecated/clutter-list-model.c \
deprecated/clutter-media.c \
deprecated/clutter-model.c \
deprecated/clutter-rectangle.c \
deprecated/clutter-score.c \
deprecated/clutter-shader.c \
deprecated/clutter-state.c \
deprecated/clutter-table-layout.c \
deprecated/clutter-texture.c \
deprecated/clutter-timeout-pool.c \
$(NULL)
# deprecated private headers; these should not be installed
deprecated_h_priv = \
deprecated/clutter-model-private.h \
deprecated/clutter-timeout-interval.h \
$(NULL)
# deprecated private source code; these should not be introspected
deprecated_c_priv = \
deprecated/clutter-timeout-interval.c \
$(NULL)
# built sources
@ -595,8 +572,6 @@ libmutter_clutter_@LIBMUTTER_API_VERSION@_la_SOURCES = \
$(source_h_priv) \
$(deprecated_c) \
$(deprecated_h) \
$(deprecated_c_priv) \
$(deprecated_h_priv) \
$(cally_sources_c) \
$(cally_sources_h) \
$(cally_sources_private) \

6
clutter/clutter/clutter-deprecated.h
View File

@ -20,16 +20,11 @@
#include "deprecated/clutter-box.h"
#include "deprecated/clutter-cairo-texture.h"
#include "deprecated/clutter-container.h"
#include "deprecated/clutter-frame-source.h"
#include "deprecated/clutter-group.h"
#include "deprecated/clutter-input-device.h"
#include "deprecated/clutter-keysyms.h"
#include "deprecated/clutter-list-model.h"
#include "deprecated/clutter-main.h"
#include "deprecated/clutter-media.h"
#include "deprecated/clutter-model.h"
#include "deprecated/clutter-rectangle.h"
#include "deprecated/clutter-score.h"
#include "deprecated/clutter-shader.h"
#include "deprecated/clutter-stage-manager.h"
#include "deprecated/clutter-stage.h"
@ -37,7 +32,6 @@
#include "deprecated/clutter-table-layout.h"
#include "deprecated/clutter-texture.h"
#include "deprecated/clutter-timeline.h"
#include "deprecated/clutter-timeout-pool.h"
#include "deprecated/clutter-util.h"
#undef __CLUTTER_DEPRECATED_H_INSIDE__

261
clutter/clutter/deprecated/clutter-frame-source.c
View File

@ -1,261 +0,0 @@
/*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Authored By Neil Roberts <neil@linux.intel.com>
*
* Copyright (C) 2008 OpenedHand
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*
*
*/
#include "clutter-build-config.h"
#define CLUTTER_DISABLE_DEPRECATION_WARNINGS
#include "clutter-main.h"
#include "clutter-private.h"
#include "deprecated/clutter-frame-source.h"
#include "deprecated/clutter-timeout-interval.h"
typedef struct _ClutterFrameSource ClutterFrameSource;
struct _ClutterFrameSource
{
GSource source;
ClutterTimeoutInterval timeout;
};
static gboolean clutter_frame_source_prepare (GSource *source,
gint *timeout);
static gboolean clutter_frame_source_check (GSource *source);
static gboolean clutter_frame_source_dispatch (GSource *source,
GSourceFunc callback,
gpointer user_data);
static GSourceFuncs clutter_frame_source_funcs =
{
clutter_frame_source_prepare,
clutter_frame_source_check,
clutter_frame_source_dispatch,
NULL
};
/**
* clutter_frame_source_add_full: (rename-to clutter_frame_source_add)
* @priority: the priority of the frame source. Typically this will be in the
* range between %G_PRIORITY_DEFAULT and %G_PRIORITY_HIGH.
* @fps: the number of times per second to call the function
* @func: function to call
* @data: data to pass to the function
* @notify: function to call when the timeout source is removed
*
* Sets a function to be called at regular intervals with the given
* priority. The function is called repeatedly until it returns
* %FALSE, at which point the timeout is automatically destroyed and
* the function will not be called again. The @notify function is
* called when the timeout is destroyed. The first call to the
* function will be at the end of the first @interval.
*
* This function is similar to g_timeout_add_full() except that it
* will try to compensate for delays. For example, if @func takes half
* the interval time to execute then the function will be called again
* half the interval time after it finished. In contrast
* g_timeout_add_full() would not fire until a full interval after the
* function completes so the delay between calls would be 1.0 / @fps *
* 1.5. This function does not however try to invoke the function
* multiple times to catch up missing frames if @func takes more than
* @interval ms to execute.
*
* Return value: the ID (greater than 0) of the event source.
*
* Since: 0.8
*
* Deprecated: 1.6: There is no direct replacement for this API.
*/
guint
clutter_frame_source_add_full (gint priority,
guint fps,
GSourceFunc func,
gpointer data,
GDestroyNotify notify)
{
guint ret;
GSource *source = g_source_new (&clutter_frame_source_funcs,
sizeof (ClutterFrameSource));
ClutterFrameSource *frame_source = (ClutterFrameSource *) source;
_clutter_timeout_interval_init (&frame_source->timeout, fps);
if (priority != G_PRIORITY_DEFAULT)
g_source_set_priority (source, priority);
g_source_set_name (source, "Clutter frame timeout");
g_source_set_callback (source, func, data, notify);
ret = g_source_attach (source, NULL);
g_source_unref (source);
return ret;
}
/**
* clutter_frame_source_add: (skip)
* @fps: the number of times per second to call the function
* @func: function to call
* @data: data to pass to the function
*
* Simple wrapper around clutter_frame_source_add_full().
*
* Return value: the ID (greater than 0) of the event source.
*
* Since: 0.8
*
* Deprecated: 1.6: There is no direct replacement for this API
*/
guint
clutter_frame_source_add (guint fps,
GSourceFunc func,
gpointer data)
{
return clutter_frame_source_add_full (G_PRIORITY_DEFAULT,
fps, func, data, NULL);
}
static gboolean
clutter_frame_source_prepare (GSource *source,
gint *delay)
{
ClutterFrameSource *frame_source = (ClutterFrameSource *) source;
gint64 current_time;
#if GLIB_CHECK_VERSION (2, 27, 3)
current_time = g_source_get_time (source) / 1000;
#else
{
GTimeVal source_time;
g_source_get_current_time (source, &source_time);
current_time = source_time.tv_sec * 1000 + source_time.tv_usec / 1000;
}
#endif
return _clutter_timeout_interval_prepare (current_time,
&frame_source->timeout,
delay);
}
static gboolean
clutter_frame_source_check (GSource *source)
{
return clutter_frame_source_prepare (source, NULL);
}
static gboolean
clutter_frame_source_dispatch (GSource *source,
GSourceFunc callback,
gpointer user_data)
{
ClutterFrameSource *frame_source = (ClutterFrameSource *) source;
return _clutter_timeout_interval_dispatch (&frame_source->timeout,
callback, user_data);
}
/**
* clutter_threads_add_frame_source_full: (rename-to clutter_threads_add_frame_source)
* @priority: the priority of the frame source. Typically this will be in the
* range between %G_PRIORITY_DEFAULT and %G_PRIORITY_HIGH.
* @fps: the number of times per second to call the function
* @func: function to call
* @data: data to pass to the function
* @notify: function to call when the timeout source is removed
*
* Sets a function to be called at regular intervals holding the Clutter
* threads lock, with the given priority. The function is called repeatedly
* until it returns %FALSE, at which point the timeout is automatically
* removed and the function will not be called again. The @notify function
* is called when the timeout is removed.
*
* This function is similar to clutter_threads_add_timeout_full()
* except that it will try to compensate for delays. For example, if
* @func takes half the interval time to execute then the function
* will be called again half the interval time after it finished. In
* contrast clutter_threads_add_timeout_full() would not fire until a
* full interval after the function completes so the delay between
* calls would be @interval * 1.5. This function does not however try
* to invoke the function multiple times to catch up missing frames if
* @func takes more than @interval ms to execute.
*
* See also clutter_threads_add_idle_full().
*
* Return value: the ID (greater than 0) of the event source.
*
* Since: 0.8
*
* Deprecated: 1.6: There is no direct replacement for this API
*/
guint
clutter_threads_add_frame_source_full (gint priority,
guint fps,
GSourceFunc func,
gpointer data,
GDestroyNotify notify)
{
ClutterThreadsDispatch *dispatch;
g_return_val_if_fail (func != NULL, 0);
dispatch = g_slice_new (ClutterThreadsDispatch);
dispatch->func = func;
dispatch->data = data;
dispatch->notify = notify;
return clutter_frame_source_add_full (priority,
fps,
_clutter_threads_dispatch, dispatch,
_clutter_threads_dispatch_free);
}
/**
* clutter_threads_add_frame_source: (skip)
* @fps: the number of times per second to call the function
* @func: function to call
* @data: data to pass to the function
*
* Simple wrapper around clutter_threads_add_frame_source_full().
*
* Return value: the ID (greater than 0) of the event source.
*
* Since: 0.8
*
* Deprecated: 1.6: There is no direct replacement for this API
*/
guint
clutter_threads_add_frame_source (guint fps,
GSourceFunc func,
gpointer data)
{
g_return_val_if_fail (func != NULL, 0);
return clutter_threads_add_frame_source_full (G_PRIORITY_DEFAULT,
fps,
func, data,
NULL);
}

49
clutter/clutter/deprecated/clutter-frame-source.h
View File

@ -1,49 +0,0 @@
/*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Authored By Matthew Allum <mallum@openedhand.com>
*
* Copyright (C) 2008 OpenedHand
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*/
#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
#error "Only <clutter/clutter.h> can be included directly."
#endif
#ifndef __CLUTTER_FRAME_SOURCE_H__
#define __CLUTTER_FRAME_SOURCE_H__
#include <clutter/clutter-types.h>
G_BEGIN_DECLS
CLUTTER_DEPRECATED
guint clutter_frame_source_add (guint fps,
GSourceFunc func,
gpointer data);
CLUTTER_DEPRECATED
guint clutter_frame_source_add_full (gint priority,
guint fps,
GSourceFunc func,
gpointer data,
GDestroyNotify notify);
G_END_DECLS
#endif /* __CLUTTER_FRAME_SOURCE_H__ */

834
clutter/clutter/deprecated/clutter-list-model.c
View File

@ -1,834 +0,0 @@
/*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Authored By Matthew Allum <mallum@openedhand.com>
* Neil Jagdish Patel <njp@o-hand.com>
* Emmanuele Bassi <ebassi@openedhand.com>
*
* Copyright (C) 2006 OpenedHand
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*
*
*/
/**
* SECTION:clutter-list-model
* @short_description: List model implementation
*
* #ClutterListModel is a #ClutterModel implementation provided by
* Clutter. #ClutterListModel uses a #GSequence for storing the
* values for each row, so it's optimized for insertion and look up
* in sorted lists.
*
* #ClutterListModel is available since Clutter 0.6
*
* Deprecated: 1.24: Use a #GListStore instance containing a custom
* object type with properties for each column instead.
*/
#include "clutter-build-config.h"
#include <stdlib.h>
#include <string.h>
#include <glib-object.h>
#define CLUTTER_DISABLE_DEPRECATION_WARNINGS
#include "clutter-list-model.h"
#include "clutter-model.h"
#include "clutter-model-private.h"
#include "clutter-private.h"
#include "clutter-debug.h"
#define CLUTTER_TYPE_LIST_MODEL_ITER \
(clutter_list_model_iter_get_type())
#define CLUTTER_LIST_MODEL_ITER(obj) \
(G_TYPE_CHECK_INSTANCE_CAST((obj), \
CLUTTER_TYPE_LIST_MODEL_ITER, \
ClutterListModelIter))
#define CLUTTER_IS_LIST_MODEL_ITER(obj) \
(G_TYPE_CHECK_INSTANCE_TYPE((obj), \
CLUTTER_TYPE_LIST_MODEL_ITER))
#define CLUTTER_LIST_MODEL_ITER_CLASS(klass) \
(G_TYPE_CHECK_CLASS_CAST ((klass), \
CLUTTER_TYPE_LIST_MODEL_ITER, \
ClutterListModelIterClass))
#define CLUTTER_IS_LIST_MODEL_ITER_CLASS(klass) \
(G_TYPE_CHECK_CLASS_TYPE ((klass), \
CLUTTER_TYPE_LIST_MODEL_ITER))
#define CLUTTER_LIST_MODEL_ITER_GET_CLASS(obj) \
(G_TYPE_INSTANCE_GET_CLASS ((obj), \
CLUTTER_TYPE_LIST_MODEL_ITER, \
ClutterListModelIterClass))
typedef struct _ClutterListModelIter ClutterListModelIter;
typedef struct _ClutterModelIterClass ClutterListModelIterClass;
struct _ClutterListModelPrivate
{
GSequence *sequence;
ClutterModelIter *temp_iter;
};
struct _ClutterListModelIter
{
ClutterModelIter parent_instance;
GSequenceIter *seq_iter;
};
GType clutter_list_model_iter_get_type (void);
/*
* ClutterListModel
*/
G_DEFINE_TYPE (ClutterListModelIter,
clutter_list_model_iter,
CLUTTER_TYPE_MODEL_ITER)
static void
clutter_list_model_iter_get_value (ClutterModelIter *iter,
guint column,
GValue *value)
{
ClutterListModelIter *iter_default;
GValue *values;
GValue *iter_value;
GValue real_value = G_VALUE_INIT;
gboolean converted = FALSE;
iter_default = CLUTTER_LIST_MODEL_ITER (iter);
g_assert (iter_default->seq_iter != NULL);
values = g_sequence_get (iter_default->seq_iter);
iter_value = &values[column];
g_assert (iter_value != NULL);
if (!g_type_is_a (G_VALUE_TYPE (value), G_VALUE_TYPE (iter_value)))
{
if (!g_value_type_compatible (G_VALUE_TYPE (value),
G_VALUE_TYPE (iter_value)) &&
!g_value_type_compatible (G_VALUE_TYPE (iter_value),
G_VALUE_TYPE (value)))
{
g_warning ("%s: Unable to convert from %s to %s",
G_STRLOC,
g_type_name (G_VALUE_TYPE (value)),
g_type_name (G_VALUE_TYPE (iter_value)));
return;
}
if (!g_value_transform (iter_value, &real_value))
{
g_warning ("%s: Unable to make conversion from %s to %s",
G_STRLOC,
g_type_name (G_VALUE_TYPE (value)),
g_type_name (G_VALUE_TYPE (iter_value)));
g_value_unset (&real_value);
}
converted = TRUE;
}
if (converted)
{
g_value_copy (&real_value, value);
g_value_unset (&real_value);
}
else
g_value_copy (iter_value, value);
}
static void
clutter_list_model_iter_set_value (ClutterModelIter *iter,
guint column,
const GValue *value)
{
ClutterListModelIter *iter_default;
GValue *values;
GValue *iter_value;
GValue real_value = G_VALUE_INIT;
gboolean converted = FALSE;
iter_default = CLUTTER_LIST_MODEL_ITER (iter);
g_assert (iter_default->seq_iter != NULL);
values = g_sequence_get (iter_default->seq_iter);
iter_value = &values[column];
g_assert (iter_value != NULL);
if (!g_type_is_a (G_VALUE_TYPE (value), G_VALUE_TYPE (iter_value)))
{
if (!g_value_type_compatible (G_VALUE_TYPE (value),
G_VALUE_TYPE (iter_value)) &&
!g_value_type_compatible (G_VALUE_TYPE (iter_value),
G_VALUE_TYPE (value)))
{
g_warning ("%s: Unable to convert from %s to %s\n",
G_STRLOC,
g_type_name (G_VALUE_TYPE (value)),
g_type_name (G_VALUE_TYPE (iter_value)));
return;
}
if (!g_value_transform (value, &real_value))
{
g_warning ("%s: Unable to make conversion from %s to %s\n",
G_STRLOC,
g_type_name (G_VALUE_TYPE (value)),
g_type_name (G_VALUE_TYPE (iter_value)));
g_value_unset (&real_value);
}
converted = TRUE;
}
if (converted)
{
g_value_copy (&real_value, iter_value);
g_value_unset (&real_value);
}
else
g_value_copy (value, iter_value);
}
static gboolean
clutter_list_model_iter_is_first (ClutterModelIter *iter)
{
ClutterListModelIter *iter_default;
ClutterModel *model;
ClutterModelIter *temp_iter;
GSequence *sequence;
GSequenceIter *begin, *end;
iter_default = CLUTTER_LIST_MODEL_ITER (iter);
g_assert (iter_default->seq_iter != NULL);
model = clutter_model_iter_get_model (iter);
sequence = CLUTTER_LIST_MODEL (model)->priv->sequence;
begin = g_sequence_get_begin_iter (sequence);
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_next (begin);
}
/* This is because the 'begin_iter' is always *before* the last valid
* iter, otherwise we'd have endless loops
*/
end = g_sequence_iter_prev (end);
return iter_default->seq_iter == end;
}
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;
}
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 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 ClutterModelIter *
clutter_list_model_iter_copy (ClutterModelIter *iter)
{
ClutterListModelIter *iter_default;
ClutterListModelIter *iter_copy;
ClutterModel *model;
guint row;
iter_default = CLUTTER_LIST_MODEL_ITER (iter);
model = clutter_model_iter_get_model (iter);
row = clutter_model_iter_get_row (iter) - 1;
iter_copy = g_object_new (CLUTTER_TYPE_LIST_MODEL_ITER,
"model", model,
"row", row,
NULL);
/* this is safe, because the seq_iter pointer on the passed
* iterator will be always be overwritten in ::next or ::prev
*/
iter_copy->seq_iter = iter_default->seq_iter;
return CLUTTER_MODEL_ITER (iter_copy);
}
static void
clutter_list_model_iter_class_init (ClutterListModelIterClass *klass)
{
ClutterModelIterClass *iter_class = CLUTTER_MODEL_ITER_CLASS (klass);
iter_class->get_value = clutter_list_model_iter_get_value;
iter_class->set_value = clutter_list_model_iter_set_value;
iter_class->is_first = clutter_list_model_iter_is_first;
iter_class->is_last = clutter_list_model_iter_is_last;
iter_class->next = clutter_list_model_iter_next;
iter_class->prev = clutter_list_model_iter_prev;
iter_class->copy = clutter_list_model_iter_copy;
}
static void
clutter_list_model_iter_init (ClutterListModelIter *iter)
{
iter->seq_iter = NULL;
}
/*
* ClutterListModel
*/
G_DEFINE_TYPE_WITH_PRIVATE (ClutterListModel, clutter_list_model, CLUTTER_TYPE_MODEL)
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;
GSequenceIter *filter_next;
gint seq_length = g_sequence_get_length (sequence);
ClutterListModelIter *retval;
gint count = -1;
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);
}
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 */
count++;
if (count == row)
break;
}
filter_next = g_sequence_iter_next (filter_next);
}
if (count != row)
{
g_object_unref (retval);
return NULL;
}
return CLUTTER_MODEL_ITER (retval);
}
static ClutterModelIter *
clutter_list_model_insert_row (ClutterModel *model,
gint index_)
{
ClutterListModel *model_default = CLUTTER_LIST_MODEL (model);
GSequence *sequence = model_default->priv->sequence;
ClutterListModelIter *retval;
guint n_columns, i, pos;
GValue *values;
GSequenceIter *seq_iter;
n_columns = clutter_model_get_n_columns (model);
values = g_new0 (GValue, n_columns);
for (i = 0; i < n_columns; i++)
g_value_init (&values[i], clutter_model_get_column_type (model, i));
if (index_ < 0)
{
seq_iter = g_sequence_append (sequence, values);
pos = g_sequence_get_length (sequence) - 1;
}
else if (index_ == 0)
{
seq_iter = g_sequence_prepend (sequence, values);
pos = 0;
}
else
{
seq_iter = g_sequence_get_iter_at_pos (sequence, index_);
seq_iter = g_sequence_insert_before (seq_iter, values);
pos = index_;
}
retval = g_object_new (CLUTTER_TYPE_LIST_MODEL_ITER,
"model", model,
"row", pos,
NULL);
retval->seq_iter = seq_iter;
return CLUTTER_MODEL_ITER (retval);
}
static void
clutter_list_model_remove_row (ClutterModel *model,
guint row)
{
ClutterListModel *model_default = CLUTTER_LIST_MODEL (model);
GSequence *sequence = model_default->priv->sequence;
GSequenceIter *seq_iter;
guint pos = 0;
seq_iter = g_sequence_get_begin_iter (sequence);
while (!g_sequence_iter_is_end (seq_iter))
{
if (clutter_model_filter_row (model, pos))
{
if (pos == row)
{
ClutterModelIter *iter;
iter = g_object_new (CLUTTER_TYPE_LIST_MODEL_ITER,
"model", model,
"row", pos,
NULL);
CLUTTER_LIST_MODEL_ITER (iter)->seq_iter = seq_iter;
/* the actual row is removed from the sequence inside
* the ::row-removed signal class handler, so that every
* handler connected to ::row-removed will still get
* a valid iterator, and every signal connected to
* ::row-removed with the AFTER flag will get an updated
* model
*/
g_signal_emit_by_name (model, "row-removed", iter);
g_object_unref (iter);
break;
}
}
pos += 1;
seq_iter = g_sequence_iter_next (seq_iter);
}
}
typedef struct
{
ClutterModel *model;
guint column;
ClutterModelSortFunc func;
gpointer data;
} SortClosure;
static gint
sort_model_default (gconstpointer a,
gconstpointer b,
gpointer data)
{
const GValue *row_a = a;
const GValue *row_b = b;
SortClosure *clos = data;
return clos->func (clos->model,
&row_a[clos->column],
&row_b[clos->column],
clos->data);
}
static void
clutter_list_model_resort (ClutterModel *model,
ClutterModelSortFunc func,
gpointer data)
{
SortClosure sort_closure = { NULL, 0, NULL, NULL };
sort_closure.model = model;
sort_closure.column = clutter_model_get_sorting_column (model);
sort_closure.func = func;
sort_closure.data = data;
g_sequence_sort (CLUTTER_LIST_MODEL (model)->priv->sequence,
sort_model_default,
&sort_closure);
}
static guint
clutter_list_model_get_n_rows (ClutterModel *model)
{
ClutterListModel *list_model = CLUTTER_LIST_MODEL (model);
/* short-circuit in case we don't have a filter in place */
if (!clutter_model_get_filter_set (model))
return g_sequence_get_length (list_model->priv->sequence);
return CLUTTER_MODEL_CLASS (clutter_list_model_parent_class)->get_n_rows (model);
}
static void
clutter_list_model_row_removed (ClutterModel *model,
ClutterModelIter *iter)
{
ClutterListModelIter *iter_default;
guint i, n_columns;
GValue *values;
n_columns = clutter_model_get_n_columns (model);
iter_default = CLUTTER_LIST_MODEL_ITER (iter);
values = g_sequence_get (iter_default->seq_iter);
for (i = 0; i < n_columns; i++)
g_value_unset (&values[i]);
g_free (values);
g_sequence_remove (iter_default->seq_iter);
iter_default->seq_iter = NULL;
}
static void
clutter_list_model_finalize (GObject *gobject)
{
ClutterListModel *model = CLUTTER_LIST_MODEL (gobject);
GSequence *sequence = model->priv->sequence;
GSequenceIter *iter;
guint n_columns, i;
n_columns = clutter_model_get_n_columns (CLUTTER_MODEL (gobject));
iter = g_sequence_get_begin_iter (sequence);
while (!g_sequence_iter_is_end (iter))
{
GValue *values = g_sequence_get (iter);
for (i = 0; i < n_columns; i++)
g_value_unset (&values[i]);
g_free (values);
iter = g_sequence_iter_next (iter);
}
g_sequence_free (sequence);
G_OBJECT_CLASS (clutter_list_model_parent_class)->finalize (gobject);
}
static void
clutter_list_model_dispose (GObject *gobject)
{
ClutterListModel *model = CLUTTER_LIST_MODEL (gobject);
if (model->priv->temp_iter)
{
g_object_unref (model->priv->temp_iter);
model->priv->temp_iter = NULL;
}
G_OBJECT_CLASS (clutter_list_model_parent_class)->dispose (gobject);
}
static void
clutter_list_model_class_init (ClutterListModelClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
ClutterModelClass *model_class = CLUTTER_MODEL_CLASS (klass);
gobject_class->finalize = clutter_list_model_finalize;
gobject_class->dispose = clutter_list_model_dispose;
model_class->get_iter_at_row = clutter_list_model_get_iter_at_row;
model_class->insert_row = clutter_list_model_insert_row;
model_class->remove_row = clutter_list_model_remove_row;
model_class->resort = clutter_list_model_resort;
model_class->get_n_rows = clutter_list_model_get_n_rows;
model_class->row_removed = clutter_list_model_row_removed;
}
static void
clutter_list_model_init (ClutterListModel *model)
{
model->priv = clutter_list_model_get_instance_private (model);
model->priv->sequence = g_sequence_new (NULL);
model->priv->temp_iter = g_object_new (CLUTTER_TYPE_LIST_MODEL_ITER,
"model",
model,
NULL);
}
/**
* clutter_list_model_new:
* @n_columns: number of columns in the model
* @...: @n_columns number of #GType and string pairs
*
* Creates a new default model with @n_columns columns with the types
* and names passed in.
*
* For example:
*
* <informalexample><programlisting>
* model = clutter_list_model_new (3,
* G_TYPE_INT, "Score",
* G_TYPE_STRING, "Team",
* GDK_TYPE_PIXBUF, "Logo");
* </programlisting></informalexample>
*
* will create a new #ClutterModel with three columns of type int,
* string and #GdkPixbuf respectively.
*
* Note that the name of the column can be set to %NULL, in which case
* the canonical name of the type held by the column will be used as
* the title.
*
* Return value: a new #ClutterListModel
*
* Since: 0.6
*
* Deprecated: 1.24: Use #GListStore instead
*/
ClutterModel *
clutter_list_model_new (guint n_columns,
...)
{
ClutterModel *model;
va_list args;
gint i;
g_return_val_if_fail (n_columns > 0, NULL);
model = g_object_new (CLUTTER_TYPE_LIST_MODEL, NULL);
_clutter_model_set_n_columns (model, n_columns, TRUE, TRUE);
va_start (args, n_columns);
for (i = 0; i < n_columns; i++)
{
GType type = va_arg (args, GType);
const gchar *name = va_arg (args, gchar*);
if (!_clutter_model_check_type (type))
{
g_warning ("%s: Invalid type %s\n", G_STRLOC, g_type_name (type));
g_object_unref (model);
model = NULL;
goto out;
}
_clutter_model_set_column_type (model, i, type);
_clutter_model_set_column_name (model, i, name);
}
out:
va_end (args);
return model;
}
/**
* clutter_list_model_newv:
* @n_columns: number of columns in the model
* @types: (array length=n_columns): an array of #GType types for the columns, from first to last
* @names: (array length=n_columns): an array of names for the columns, from first to last
*
* Non-vararg version of clutter_list_model_new(). This function is
* useful for language bindings.
*
* Return value: (transfer full): a new default #ClutterModel
*
* Since: 0.6
*
* Deprecated: 1.24: Use #GListStore instead
*/
ClutterModel *
clutter_list_model_newv (guint n_columns,
GType *types,
const gchar * const names[])
{
ClutterModel *model;
gint i;
g_return_val_if_fail (n_columns > 0, NULL);
model = g_object_new (CLUTTER_TYPE_LIST_MODEL, NULL);
_clutter_model_set_n_columns (model, n_columns, TRUE, TRUE);
for (i = 0; i < n_columns; i++)
{
if (!_clutter_model_check_type (types[i]))
{
g_warning ("%s: Invalid type %s\n", G_STRLOC, g_type_name (types[i]));
g_object_unref (model);
return NULL;
}
_clutter_model_set_column_type (model, i, types[i]);
_clutter_model_set_column_name (model, i, names[i]);
}
return model;
}

95
clutter/clutter/deprecated/clutter-list-model.h
View File

@ -1,95 +0,0 @@
/*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Authored By Matthew Allum <mallum@openedhand.com>
* Neil Jagdish Patel <njp@o-hand.com>
* Emmanuele Bassi <ebassi@openedhand.com>
*
* Copyright (C) 2006 OpenedHand
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*
* NB: Inspiration for column storage taken from GtkListStore
*/
#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
#error "Only <clutter/clutter.h> can be included directly."
#endif
#ifndef __CLUTTER_LIST_MODEL_H__
#define __CLUTTER_LIST_MODEL_H__
#include <clutter/deprecated/clutter-model.h>
G_BEGIN_DECLS
#define CLUTTER_TYPE_LIST_MODEL (clutter_list_model_get_type ())
#define CLUTTER_LIST_MODEL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_LIST_MODEL, ClutterListModel))
#define CLUTTER_IS_LIST_MODEL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_LIST_MODEL))
#define CLUTTER_LIST_MODEL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), CLUTTER_TYPE_LIST_MODEL, ClutterListModeClass))
#define CLUTTER_IS_LIST_MODEL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CLUTTER_TYPE_LIST_MODEL))
#define CLUTTER_LIST_MODEL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_TYPE_LIST_MODEL, ClutterListModeClass))
typedef struct _ClutterListModel ClutterListModel;
typedef struct _ClutterListModelPrivate ClutterListModelPrivate;
typedef struct _ClutterListModelClass ClutterListModelClass;
/**
* ClutterListModel:
*
* The #ClutterListModel struct contains only private data.
*
* Since: 0.6
*
* Deprecated: 1.24: Use #GListStore instead
*/
struct _ClutterListModel
{
/*< private >*/
ClutterModel parent_instance;
ClutterListModelPrivate *priv;
};
/**
* ClutterListModelClass:
*
* The #ClutterListModelClass struct contains only private data.
*
* Since: 0.6
*
* Deprecated: 1.24: Use #GListStore instead
*/
struct _ClutterListModelClass
{
/*< private >*/
ClutterModelClass parent_class;
};
CLUTTER_DEPRECATED_FOR(g_list_store_get_type)
GType clutter_list_model_get_type (void) G_GNUC_CONST;
CLUTTER_DEPRECATED_FOR(g_list_store_new)
ClutterModel *clutter_list_model_new (guint n_columns,
...);
CLUTTER_DEPRECATED_FOR(g_list_store_new)
ClutterModel *clutter_list_model_newv (guint n_columns,
GType *types,
const gchar * const names[]);
G_END_DECLS
#endif /* __CLUTTER_LIST_MODEL_H__ */

664
clutter/clutter/deprecated/clutter-media.c
View File

@ -1,664 +0,0 @@
/*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Authored By: Matthew Allum <mallum@openedhand.com>
* Emmanuele Bassi <ebassi@linux.intel.com>
*
* Copyright (C) 2006 OpenedHand
* Copyright (C) 2009 Intel Corp.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*/
/**
* SECTION:clutter-media
* @short_description: An interface for controlling playback of media data
*
* #ClutterMedia is an interface for controlling playback of media sources.
*
* Clutter core does not provide an implementation of this interface, but
* other integration libraries like Clutter-GStreamer implement it to offer
* a uniform API for applications.
*
* #ClutterMedia is available since Clutter 0.2
*
* #ClutterMedia is deprecated since Clutter 1.12. Use the Clutter-GStreamer
* API directly instead.
*/
#include "clutter-build-config.h"
#define CLUTTER_DISABLE_DEPRECATION_WARNINGS
#include "clutter-debug.h"
#include "clutter-enum-types.h"
#include "clutter-marshal.h"
#include "clutter-media.h"
#include "clutter-main.h"
#include "clutter-private.h" /* for DBG */
enum
{
EOS_SIGNAL,
ERROR_SIGNAL, /* can't be called 'ERROR' otherwise it clashes with wingdi.h */
LAST_SIGNAL
};
static guint media_signals[LAST_SIGNAL] = { 0, };
typedef ClutterMediaIface ClutterMediaInterface;
G_DEFINE_INTERFACE (ClutterMedia, clutter_media, G_TYPE_OBJECT);
static void
clutter_media_default_init (ClutterMediaInterface *iface)
{
GParamSpec *pspec = NULL;
/**
* ClutterMedia:uri:
*
* The location of a media file, expressed as a valid URI.
*
* Since: 0.2
*
* Deprecated: 1.12
*/
pspec = g_param_spec_string ("uri",
P_("URI"),
P_("URI of a media file"),
NULL,
CLUTTER_PARAM_READWRITE |
G_PARAM_DEPRECATED);
g_object_interface_install_property (iface, pspec);
/**
* ClutterMedia:playing:
*
* Whether the #ClutterMedia actor is playing.
*
* Since: 0.2
*
* Deprecated: 1.12
*/
pspec = g_param_spec_boolean ("playing",
P_("Playing"),
P_("Whether the actor is playing"),
FALSE,
CLUTTER_PARAM_READWRITE |
G_PARAM_DEPRECATED);
g_object_interface_install_property (iface, pspec);
/**
* ClutterMedia:progress:
*
* The current progress of the playback, as a normalized
* value between 0.0 and 1.0.
*
* Since: 1.0
*
* Deprecated: 1.12
*/
pspec = g_param_spec_double ("progress",
P_("Progress"),
P_("Current progress of the playback"),
0.0, 1.0, 0.0,
CLUTTER_PARAM_READWRITE |
G_PARAM_DEPRECATED);
g_object_interface_install_property (iface, pspec);
/**
* ClutterMedia:subtitle-uri:
*
* The location of a subtitle file, expressed as a valid URI.
*
* Since: 1.2
*
* Deprecated: 1.12
*/
pspec = g_param_spec_string ("subtitle-uri",
P_("Subtitle URI"),
P_("URI of a subtitle file"),
NULL,
CLUTTER_PARAM_READWRITE |
G_PARAM_DEPRECATED);
g_object_interface_install_property (iface, pspec);
/**
* ClutterMedia:subtitle-font-name:
*
* The font used to display subtitles. The font description has to
* follow the same grammar as the one recognized by
* pango_font_description_from_string().
*
* Since: 1.2
*
* Deprecated: 1.12
*/
pspec = g_param_spec_string ("subtitle-font-name",
P_("Subtitle Font Name"),
P_("The font used to display subtitles"),
NULL,
CLUTTER_PARAM_READWRITE |
G_PARAM_DEPRECATED);
g_object_interface_install_property (iface, pspec);
/**
* ClutterMedia:audio-volume:
*
* The volume of the audio, as a normalized value between
* 0.0 and 1.0.
*
* Since: 1.0
*
* Deprecated: 1.12
*/
pspec = g_param_spec_double ("audio-volume",
P_("Audio Volume"),
P_("The volume of the audio"),
0.0, 1.0, 0.5,
CLUTTER_PARAM_READWRITE |
G_PARAM_DEPRECATED);
g_object_interface_install_property (iface, pspec);
/**
* ClutterMedia:can-seek:
*
* Whether the current stream is seekable.
*
* Since: 0.2
*
* Deprecated: 1.12
*/
pspec = g_param_spec_boolean ("can-seek",
P_("Can Seek"),
P_("Whether the current stream is seekable"),
FALSE,
CLUTTER_PARAM_READABLE |
G_PARAM_DEPRECATED);
g_object_interface_install_property (iface, pspec);
/**
* ClutterMedia:buffer-fill:
*
* The fill level of the buffer for the current stream,
* as a value between 0.0 and 1.0.
*
* Since: 1.0
*
* Deprecated: 1.12
*/
pspec = g_param_spec_double ("buffer-fill",
P_("Buffer Fill"),
P_("The fill level of the buffer"),
0.0, 1.0, 0.0,
CLUTTER_PARAM_READABLE |
G_PARAM_DEPRECATED);
g_object_interface_install_property (iface, pspec);
/**
* ClutterMedia:duration:
*
* The duration of the current stream, in seconds
*
* Since: 0.2
*
* Deprecated: 1.12
*/
pspec = g_param_spec_double ("duration",
P_("Duration"),
P_("The duration of the stream, in seconds"),
0, G_MAXDOUBLE, 0,
CLUTTER_PARAM_READABLE);
g_object_interface_install_property (iface, pspec);
/**
* ClutterMedia::eos:
* @media: the #ClutterMedia instance that received the signal
*
* The ::eos signal is emitted each time the media stream ends.
*
* Since: 0.2
*
* Deprecated: 1.12
*/
media_signals[EOS_SIGNAL] =
g_signal_new (I_("eos"),
CLUTTER_TYPE_MEDIA,
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (ClutterMediaIface, eos),
NULL, NULL,
_clutter_marshal_VOID__VOID,
G_TYPE_NONE, 0);
/**
* ClutterMedia::error:
* @media: the #ClutterMedia instance that received the signal
* @error: the #GError
*
* The ::error signal is emitted each time an error occurred.
*
* Since: 0.2
*
* Deprecated: 1.12
*/
media_signals[ERROR_SIGNAL] =
g_signal_new (I_("error"),
CLUTTER_TYPE_MEDIA,
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (ClutterMediaIface, error),
NULL, NULL,
_clutter_marshal_VOID__BOXED,
G_TYPE_NONE, 1,
G_TYPE_ERROR);
}
/**
* clutter_media_set_uri:
* @media: a #ClutterMedia
* @uri: the URI of the media stream
*
* Sets the URI of @media to @uri.
*
* Since: 0.2
*
* Deprecated: 1.12
*/
void
clutter_media_set_uri (ClutterMedia *media,
const gchar *uri)
{
g_return_if_fail (CLUTTER_IS_MEDIA(media));
g_object_set (G_OBJECT (media), "uri", uri, NULL);
}
/**
* clutter_media_get_uri:
* @media: a #ClutterMedia
*
* Retrieves the URI from @media.
*
* Return value: the URI of the media stream. Use g_free()
* to free the returned string
*
* Since: 0.2
*
* Deprecated: 1.12
*/
gchar *
clutter_media_get_uri (ClutterMedia *media)
{
gchar *retval = NULL;
g_return_val_if_fail (CLUTTER_IS_MEDIA(media), NULL);
g_object_get (G_OBJECT (media), "uri", &retval, NULL);
return retval;
}
/**
* clutter_media_set_playing:
* @media: a #ClutterMedia
* @playing: %TRUE to start playing
*
* Starts or stops playing of @media.
* The implementation might be asynchronous, so the way to know whether
* the actual playing state of the @media is to use the #GObject::notify
* signal on the #ClutterMedia:playing property and then retrieve the
* current state with clutter_media_get_playing(). ClutterGstVideoTexture
* in clutter-gst is an example of such an asynchronous implementation.
*
* Since: 0.2
*
* Deprecated: 1.12
*/
void
clutter_media_set_playing (ClutterMedia *media,
gboolean playing)
{
g_return_if_fail (CLUTTER_IS_MEDIA(media));
g_object_set (G_OBJECT (media), "playing", playing, NULL);
}
/**
* clutter_media_get_playing:
* @media: A #ClutterMedia object
*
* Retrieves the playing status of @media.
*
* Return value: %TRUE if playing, %FALSE if stopped.
*
* Since: 0.2
*
* Deprecated: 1.12
*/
gboolean
clutter_media_get_playing (ClutterMedia *media)
{
gboolean is_playing = FALSE;
g_return_val_if_fail (CLUTTER_IS_MEDIA (media), FALSE);
g_object_get (G_OBJECT (media), "playing", &is_playing, NULL);
return is_playing;
}
/**
* clutter_media_set_progress:
* @media: a #ClutterMedia
* @progress: the progress of the playback, between 0.0 and 1.0
*
* Sets the playback progress of @media. The @progress is
* a normalized value between 0.0 (begin) and 1.0 (end).
*
* Since: 1.0
*
* Deprecated: 1.12
*/
void
clutter_media_set_progress (ClutterMedia *media,
gdouble progress)
{
g_return_if_fail (CLUTTER_IS_MEDIA (media));
g_object_set (G_OBJECT (media), "progress", progress, NULL);
}
/**
* clutter_media_get_progress:
* @media: a #ClutterMedia
*
* Retrieves the playback progress of @media.
*
* Return value: the playback progress, between 0.0 and 1.0
*
* Since: 1.0
*
* Deprecated: 1.12
*/
gdouble
clutter_media_get_progress (ClutterMedia *media)
{
gdouble retval = 0.0;
g_return_val_if_fail (CLUTTER_IS_MEDIA (media), 0);
g_object_get (G_OBJECT (media), "progress", &retval, NULL);
return retval;
}
/**
* clutter_media_set_subtitle_uri:
* @media: a #ClutterMedia
* @uri: the URI of a subtitle file
*
* Sets the location of a subtitle file to display while playing @media.
*
* Since: 1.2
*
* Deprecated: 1.12
*/
void
clutter_media_set_subtitle_uri (ClutterMedia *media,
const char *uri)
{
g_return_if_fail (CLUTTER_IS_MEDIA (media));
g_object_set (G_OBJECT (media), "subtitle-uri", uri, NULL);
}
/**
* clutter_media_get_subtitle_uri:
* @media: a #ClutterMedia
*
* Retrieves the URI of the subtitle file in use.
*
* Return value: the URI of the subtitle file. Use g_free()
* to free the returned string
*
* Since: 1.2
*
* Deprecated: 1.12
*/
gchar *
clutter_media_get_subtitle_uri (ClutterMedia *media)
{
gchar *retval = NULL;
g_return_val_if_fail (CLUTTER_IS_MEDIA(media), NULL);
g_object_get (G_OBJECT (media), "subtitle-uri", &retval, NULL);
return retval;
}
/**
* clutter_media_set_subtitle_font_name:
* @media: a #ClutterMedia
* @font_name: a font name, or %NULL to set the default font name
*
* Sets the font used by the subtitle renderer. The @font_name string must be
* either %NULL, which means that the default font name of the underlying
* implementation will be used; or must follow the grammar recognized by
* pango_font_description_from_string() like:
*
* |[
* clutter_media_set_subtitle_font_name (media, "Sans 24pt");
* ]|
*
* Since: 1.2
*
* Deprecated: 1.12
*/
void
clutter_media_set_subtitle_font_name (ClutterMedia *media,
const char *font_name)
{
g_return_if_fail (CLUTTER_IS_MEDIA (media));
g_object_set (G_OBJECT (media), "subtitle-font-name", font_name, NULL);
}
/**
* clutter_media_get_subtitle_font_name:
* @media: a #ClutterMedia
*
* Retrieves the font name currently used.
*
* Return value: a string containing the font name. Use g_free()
* to free the returned string
*
* Since: 1.2
*
* Deprecated: 1.12
*/
gchar *
clutter_media_get_subtitle_font_name (ClutterMedia *media)
{
gchar *retval = NULL;
g_return_val_if_fail (CLUTTER_IS_MEDIA(media), NULL);
g_object_get (G_OBJECT (media), "subtitle-font-name", &retval, NULL);
return retval;
}
/**
* clutter_media_set_audio_volume:
* @media: a #ClutterMedia
* @volume: the volume as a double between 0.0 and 1.0
*
* Sets the playback volume of @media to @volume.
*
* Since: 1.0
*
* Deprecated: 1.12
*/
void
clutter_media_set_audio_volume (ClutterMedia *media,
gdouble volume)
{
g_return_if_fail (CLUTTER_IS_MEDIA(media));
g_object_set (G_OBJECT (media), "audio-volume", volume, NULL);
}
/**
* clutter_media_get_audio_volume:
* @media: a #ClutterMedia
*
* Retrieves the playback volume of @media.
*
* Return value: The playback volume between 0.0 and 1.0
*
* Since: 1.0
*
* Deprecated: 1.12
*/
gdouble
clutter_media_get_audio_volume (ClutterMedia *media)
{
gdouble retval = 0.0;
g_return_val_if_fail (CLUTTER_IS_MEDIA (media), 0.0);
g_object_get (G_OBJECT (media), "audio-volume", &retval, NULL);
return retval;
}
/**
* clutter_media_get_can_seek:
* @media: a #ClutterMedia
*
* Retrieves whether @media is seekable or not.
*
* Return value: %TRUE if @media can seek, %FALSE otherwise.
*
* Since: 0.2
*
* Deprecated: 1.12
*/
gboolean
clutter_media_get_can_seek (ClutterMedia *media)
{
gboolean retval = FALSE;
g_return_val_if_fail (CLUTTER_IS_MEDIA (media), FALSE);
g_object_get (G_OBJECT (media), "can-seek", &retval, NULL);
return retval;
}
/**
* clutter_media_get_buffer_fill:
* @media: a #ClutterMedia
*
* Retrieves the amount of the stream that is buffered.
*
* Return value: the fill level, between 0.0 and 1.0
*
* Since: 1.0
*
* Deprecated: 1.12
*/
gdouble
clutter_media_get_buffer_fill (ClutterMedia *media)
{
gdouble retval = 0.0;
g_return_val_if_fail (CLUTTER_IS_MEDIA (media), 0);
g_object_get (G_OBJECT (media), "buffer-fill", &retval, NULL);
return retval;
}
/**
* clutter_media_get_duration:
* @media: a #ClutterMedia
*
* Retrieves the duration of the media stream that @media represents.
*
* Return value: the duration of the media stream, in seconds
*
* Since: 0.2
*
* Deprecated: 1.12
*/
gdouble
clutter_media_get_duration (ClutterMedia *media)
{
gdouble retval = 0;
g_return_val_if_fail (CLUTTER_IS_MEDIA(media), 0);
g_object_get (G_OBJECT (media), "duration", &retval, NULL);
return retval;
}
/* helper funcs */
/**
* clutter_media_set_filename:
* @media: a #ClutterMedia
* @filename: A filename
*
* Sets the source of @media using a file path.
*
* Since: 0.2
*
* Deprecated: 1.12
*/
void
clutter_media_set_filename (ClutterMedia *media,
const gchar *filename)
{
gchar *uri;
GError *uri_error = NULL;
if (!g_path_is_absolute (filename))
{
gchar *abs_path;
abs_path = g_build_filename (g_get_current_dir (), filename, NULL);
uri = g_filename_to_uri (abs_path, NULL, &uri_error);
g_free (abs_path);
}
else
uri = g_filename_to_uri (filename, NULL, &uri_error);
if (uri_error)
{
g_signal_emit (media, media_signals[ERROR_SIGNAL], 0, uri_error);
g_error_free (uri_error);
return;
}
clutter_media_set_uri (media, uri);
g_free (uri);
}

121
clutter/clutter/deprecated/clutter-media.h
View File

@ -1,121 +0,0 @@
/*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Authored By: Matthew Allum <mallum@openedhand.com>
* Emmanuele Bassi <ebassi@linux.intel.com>
*
* Copyright (C) 2006 OpenedHand
* Copyright (C) 2009 Intel Corp.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*/
#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
#error "Only <clutter/clutter.h> can be included directly."
#endif
#ifndef __CLUTTER_MEDIA_H__
#define __CLUTTER_MEDIA_H__
#include <glib-object.h>
G_BEGIN_DECLS
#define CLUTTER_TYPE_MEDIA (clutter_media_get_type ())
#define CLUTTER_MEDIA(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_MEDIA, ClutterMedia))
#define CLUTTER_IS_MEDIA(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_MEDIA))
#define CLUTTER_MEDIA_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), CLUTTER_TYPE_MEDIA, ClutterMediaIface))
typedef struct _ClutterMedia ClutterMedia; /* dummy typedef */
typedef struct _ClutterMediaIface ClutterMediaIface;
/**
* ClutterMedia:
*
* #ClutterMedia is an opaque structure whose members cannot be directly
* accessed
*
* Since: 0.2
*/
/**
* ClutterMediaIface:
* @eos: handler for the #ClutterMedia::eos signal
* @error: handler for the #ClutterMedia::error signal
*
* Interface vtable for #ClutterMedia implementations
*
* Since: 0.2
*/
struct _ClutterMediaIface
{
/*< private >*/
GTypeInterface base_iface;
/*< public >*/
/* signals */
void (* eos) (ClutterMedia *media);
void (* error) (ClutterMedia *media,
const GError *error);
};
CLUTTER_DEPRECATED
GType clutter_media_get_type (void) G_GNUC_CONST;
CLUTTER_DEPRECATED
void clutter_media_set_uri (ClutterMedia *media,
const gchar *uri);
CLUTTER_DEPRECATED
gchar * clutter_media_get_uri (ClutterMedia *media);
CLUTTER_DEPRECATED
void clutter_media_set_filename (ClutterMedia *media,
const gchar *filename);
CLUTTER_DEPRECATED
void clutter_media_set_playing (ClutterMedia *media,
gboolean playing);
CLUTTER_DEPRECATED
gboolean clutter_media_get_playing (ClutterMedia *media);
CLUTTER_DEPRECATED
void clutter_media_set_progress (ClutterMedia *media,
gdouble progress);
CLUTTER_DEPRECATED
gdouble clutter_media_get_progress (ClutterMedia *media);
CLUTTER_DEPRECATED
void clutter_media_set_subtitle_uri (ClutterMedia *media,
const gchar *uri);
CLUTTER_DEPRECATED
gchar * clutter_media_get_subtitle_uri (ClutterMedia *media);
CLUTTER_DEPRECATED
void clutter_media_set_subtitle_font_name (ClutterMedia *media,
const char *font_name);
CLUTTER_DEPRECATED
gchar * clutter_media_get_subtitle_font_name (ClutterMedia *media);
CLUTTER_DEPRECATED
void clutter_media_set_audio_volume (ClutterMedia *media,
gdouble volume);
CLUTTER_DEPRECATED
gdouble clutter_media_get_audio_volume (ClutterMedia *media);
CLUTTER_DEPRECATED
gboolean clutter_media_get_can_seek (ClutterMedia *media);
CLUTTER_DEPRECATED
gdouble clutter_media_get_buffer_fill (ClutterMedia *media);
CLUTTER_DEPRECATED
gdouble clutter_media_get_duration (ClutterMedia *media);
G_END_DECLS
#endif /* __CLUTTER_MEDIA_H__ */

52
clutter/clutter/deprecated/clutter-model-private.h
View File

@ -1,52 +0,0 @@
/*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Authored By Matthew Allum <mallum@openedhand.com>
* Neil Jagdish Patel <njp@o-hand.com>
* Emmanuele Bassi <ebassi@openedhand.com>
*
* Copyright (C) 2006 OpenedHand
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __CLUTTER_MODEL_PRIVATE_H__
#define __CLUTTER_MODEL_PRIVATE_H__
#include "clutter-types.h"
#include "clutter-model.h"
G_BEGIN_DECLS
void _clutter_model_set_n_columns (ClutterModel *model,
gint n_columns,
gboolean set_types,
gboolean set_names);
gboolean _clutter_model_check_type (GType gtype);
void _clutter_model_set_column_type (ClutterModel *model,
gint column,
GType gtype);
void _clutter_model_set_column_name (ClutterModel *model,
gint column,
const gchar *name);
void _clutter_model_iter_set_row (ClutterModelIter *iter,
guint row);
G_END_DECLS
#endif /* __CLUTTER_MODEL_PRIVATE_H__ */

2475
clutter/clutter/deprecated/clutter-model.c
View File

File diff suppressed because it is too large Load Diff

436
clutter/clutter/deprecated/clutter-model.h
View File

@ -1,436 +0,0 @@
/*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Authored By Matthew Allum <mallum@openedhand.com>
* Neil Jagdish Patel <njp@o-hand.com>
* Emmanuele Bassi <ebassi@openedhand.com>
*
* Copyright (C) 2006 OpenedHand
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*/
#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
#error "Only <clutter/clutter.h> can be included directly."
#endif
#ifndef __CLUTTER_MODEL_H__
#define __CLUTTER_MODEL_H__
#include <clutter/clutter-types.h>
G_BEGIN_DECLS
#define CLUTTER_TYPE_MODEL (clutter_model_get_type ())
#define CLUTTER_MODEL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_MODEL, ClutterModel))
#define CLUTTER_MODEL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), CLUTTER_TYPE_MODEL, ClutterModelClass))
#define CLUTTER_IS_MODEL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_MODEL))
#define CLUTTER_IS_MODEL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CLUTTER_TYPE_MODEL))
#define CLUTTER_MODEL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_TYPE_MODEL, ClutterModelClass))
typedef struct _ClutterModel ClutterModel;
typedef struct _ClutterModelClass ClutterModelClass;
typedef struct _ClutterModelPrivate ClutterModelPrivate;
typedef struct _ClutterModelIter ClutterModelIter;
typedef struct _ClutterModelIterClass ClutterModelIterClass;
typedef struct _ClutterModelIterPrivate ClutterModelIterPrivate;
/**
* ClutterModelFilterFunc:
* @model: a #ClutterModel
* @iter: the iterator for the row
* @user_data: data passed to clutter_model_set_filter()
*
* Filters the content of a row in the model.
*
* Return value: If the row should be displayed, return %TRUE
*
* Since: 0.6
*
* Deprecated: 1.24: Implement filters using a custom #GListModel instead
*/
typedef gboolean (*ClutterModelFilterFunc) (ClutterModel *model,
ClutterModelIter *iter,
gpointer user_data);
/**
* ClutterModelSortFunc:
* @model: a #ClutterModel
* @a: a #GValue representing the contents of the row
* @b: a #GValue representing the contents of the second row
* @user_data: data passed to clutter_model_set_sort()
*
* Compares the content of two rows in the model.
*
* Return value: a positive integer if @a is after @b, a negative integer if
* @a is before @b, or 0 if the rows are the same
*
* Since: 0.6
*
* Deprecated: 1.24: Implement sorting using a custom #GListModel instead
*/
typedef gint (*ClutterModelSortFunc) (ClutterModel *model,
const GValue *a,
const GValue *b,
gpointer user_data);
/**
* ClutterModelForeachFunc:
* @model: a #ClutterModel
* @iter: the iterator for the row
* @user_data: data passed to clutter_model_foreach()
*
* Iterates on the content of a row in the model
*
* Return value: %TRUE if the iteration should continue, %FALSE otherwise
*
* Since: 0.6
*
* Deprecated: 1.24: Use #GListModel
*/
typedef gboolean (*ClutterModelForeachFunc) (ClutterModel *model,
ClutterModelIter *iter,
gpointer user_data);
/**
* ClutterModel:
*
* Base class for list models. The #ClutterModel structure contains
* only private data and should be manipulated using the provided
* API.
*
* Since: 0.6
*
* Deprecated: 1.24: Use #GListModel instead
*/
struct _ClutterModel
{
/*< private >*/
GObject parent_instance;
ClutterModelPrivate *priv;
};
/**
* ClutterModelClass:
* @row_added: signal class handler for ClutterModel::row-added
* @row_removed: signal class handler for ClutterModel::row-removed
* @row_changed: signal class handler for ClutterModel::row-changed
* @sort_changed: signal class handler for ClutterModel::sort-changed
* @filter_changed: signal class handler for ClutterModel::filter-changed
* @get_column_name: virtual function for returning the name of a column
* @get_column_type: virtual function for returning the type of a column
* @get_iter_at_row: virtual function for returning an iterator for the
* given row
* @get_n_rows: virtual function for returning the number of rows
* of the model
* @get_n_columns: virtual function for retuning the number of columns
* of the model
* @resort: virtual function for sorting the model using the passed
* sorting function
* @insert_row: virtual function for inserting a row at the given index
* and returning an iterator pointing to it; if the index is a negative
* integer, the row should be appended to the model
* @remove_row: virtual function for removing a row at the given index
*
* Class for #ClutterModel instances.
*
* Since: 0.6
*
* Deprecated: 1.24: Use #GListModel instead
*/
struct _ClutterModelClass
{
/*< private >*/
GObjectClass parent_class;
/*< public >*/
/* vtable */
guint (* get_n_rows) (ClutterModel *model);
guint (* get_n_columns) (ClutterModel *model);
const gchar * (* get_column_name) (ClutterModel *model,
guint column);
GType (* get_column_type) (ClutterModel *model,
guint column);
ClutterModelIter *(* insert_row) (ClutterModel *model,
gint index_);
void (* remove_row) (ClutterModel *model,
guint row);
ClutterModelIter *(* get_iter_at_row) (ClutterModel *model,
guint row);
void (* resort) (ClutterModel *model,
ClutterModelSortFunc func,
gpointer data);
/* signals */
void (* row_added) (ClutterModel *model,
ClutterModelIter *iter);
void (* row_removed) (ClutterModel *model,
ClutterModelIter *iter);
void (* row_changed) (ClutterModel *model,
ClutterModelIter *iter);
void (* sort_changed) (ClutterModel *model);
void (* filter_changed) (ClutterModel *model);
/*< private >*/
/* padding for future expansion */
void (*_clutter_model_1) (void);
void (*_clutter_model_2) (void);
void (*_clutter_model_3) (void);
void (*_clutter_model_4) (void);
void (*_clutter_model_5) (void);
void (*_clutter_model_6) (void);
void (*_clutter_model_7) (void);
void (*_clutter_model_8) (void);
};
CLUTTER_DEPRECATED_FOR(g_list_model_get_type)
GType clutter_model_get_type (void) G_GNUC_CONST;
CLUTTER_DEPRECATED_FOR(GListModel)
void clutter_model_set_types (ClutterModel *model,
guint n_columns,
GType *types);
CLUTTER_DEPRECATED_FOR(GListModel)
void clutter_model_set_names (ClutterModel *model,
guint n_columns,
const gchar * const names[]);
CLUTTER_DEPRECATED_FOR(GListModel)
void clutter_model_append (ClutterModel *model,
...);
CLUTTER_DEPRECATED_FOR(GListModel)
void clutter_model_appendv (ClutterModel *model,
guint n_columns,
guint *columns,
GValue *values);
CLUTTER_DEPRECATED_FOR(GListModel)
void clutter_model_prepend (ClutterModel *model,
...);
CLUTTER_DEPRECATED_FOR(GListModel)
void clutter_model_prependv (ClutterModel *model,
guint n_columns,
guint *columns,
GValue *values);
CLUTTER_DEPRECATED_FOR(GListModel)
void clutter_model_insert (ClutterModel *model,
guint row,
...);
CLUTTER_DEPRECATED_FOR(GListModel)
void clutter_model_insertv (ClutterModel *model,
guint row,
guint n_columns,
guint *columns,
GValue *values);
CLUTTER_DEPRECATED_FOR(GListModel)
void clutter_model_insert_value (ClutterModel *model,
guint row,
guint column,
const GValue *value);
CLUTTER_DEPRECATED_FOR(GListModel)
void clutter_model_remove (ClutterModel *model,
guint row);
CLUTTER_DEPRECATED_FOR(GListModel)
guint clutter_model_get_n_rows (ClutterModel *model);
CLUTTER_DEPRECATED_FOR(GListModel)
guint clutter_model_get_n_columns (ClutterModel *model);
CLUTTER_DEPRECATED_FOR(GListModel)
const gchar * clutter_model_get_column_name (ClutterModel *model,
guint column);
CLUTTER_DEPRECATED_FOR(GListModel)
GType clutter_model_get_column_type (ClutterModel *model,
guint column);
CLUTTER_DEPRECATED_FOR(GListModel)
ClutterModelIter * clutter_model_get_first_iter (ClutterModel *model);
CLUTTER_DEPRECATED_FOR(GListModel)
ClutterModelIter * clutter_model_get_last_iter (ClutterModel *model);
CLUTTER_DEPRECATED_FOR(GListModel)
ClutterModelIter * clutter_model_get_iter_at_row (ClutterModel *model,
guint row);
CLUTTER_DEPRECATED_FOR(GListModel)
void clutter_model_set_sorting_column (ClutterModel *model,
gint column);
CLUTTER_DEPRECATED_FOR(GListModel)
gint clutter_model_get_sorting_column (ClutterModel *model);
CLUTTER_DEPRECATED_FOR(GListModel)
void clutter_model_foreach (ClutterModel *model,
ClutterModelForeachFunc func,
gpointer user_data);
CLUTTER_DEPRECATED_FOR(GListModel)
void clutter_model_set_sort (ClutterModel *model,
gint column,
ClutterModelSortFunc func,
gpointer user_data,
GDestroyNotify notify);
CLUTTER_DEPRECATED_FOR(GListModel)
void clutter_model_set_filter (ClutterModel *model,
ClutterModelFilterFunc func,
gpointer user_data,
GDestroyNotify notify);
CLUTTER_DEPRECATED_FOR(GListModel)
gboolean clutter_model_get_filter_set (ClutterModel *model);
CLUTTER_DEPRECATED_FOR(GListModel)
void clutter_model_resort (ClutterModel *model);
CLUTTER_DEPRECATED_FOR(GListModel)
gboolean clutter_model_filter_row (ClutterModel *model,
guint row);
CLUTTER_DEPRECATED_FOR(GListModel)
gboolean clutter_model_filter_iter (ClutterModel *model,
ClutterModelIter *iter);
/*
* ClutterModelIter
*/
#define CLUTTER_TYPE_MODEL_ITER (clutter_model_iter_get_type ())
#define CLUTTER_MODEL_ITER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_MODEL_ITER, ClutterModelIter))
#define CLUTTER_MODEL_ITER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), CLUTTER_TYPE_MODEL_ITER, ClutterModelIterClass))
#define CLUTTER_IS_MODEL_ITER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_MODEL_ITER))
#define CLUTTER_IS_MODEL_ITER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CLUTTER_TYPE_MODEL_ITER))
#define CLUTTER_MODEL_ITER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_TYPE_MODEL_ITER, ClutterModelIterClass))
/**
* ClutterModelIter:
*
* Base class for list models iters. The #ClutterModelIter structure
* contains only private data and should be manipulated using the
* provided API.
*
* Since: 0.6
*
* Deprecated: 1.24: Use custom iterators for #GListModel
*/
struct _ClutterModelIter
{
/*< private >*/
GObject parent_instance;
ClutterModelIterPrivate *priv;
};
/**
* ClutterModelIterClass:
* @get_value: Virtual function for retrieving the value at the given
* column of the row pointed by the iterator
* @set_value: Virtual function for setting the value at the given
* column of the row pointer by the iterator
* @is_last: Virtual function for knowing whether the iterator points
* at the last row in the model
* @is_first: Virtual function for knowing whether the iterator points
* at the first row in the model
* @next: Virtual function for moving the iterator to the following
* row in the model
* @prev: Virtual function for moving the iterator toe the previous
* row in the model
* @get_model: Virtual function for getting the model to which the
* iterator belongs to
* @get_row: Virtual function for getting the row to which the iterator
* points
* @copy: Virtual function for copying a #ClutterModelIter.
*
* Class for #ClutterModelIter instances.
*
* Since: 0.6
*
* Deprecated: 1.24: Use custom iterators for #GListModel
*/
struct _ClutterModelIterClass
{
/*< private >*/
GObjectClass parent_class;
/*< public >*/
/* vtable not signals */
void (* get_value) (ClutterModelIter *iter,
guint column,
GValue *value);
void (* set_value) (ClutterModelIter *iter,
guint column,
const GValue *value);
gboolean (* is_first) (ClutterModelIter *iter);
gboolean (* is_last) (ClutterModelIter *iter);
ClutterModelIter *(* next) (ClutterModelIter *iter);
ClutterModelIter *(* prev) (ClutterModelIter *iter);
ClutterModel * (* get_model) (ClutterModelIter *iter);
guint (* get_row) (ClutterModelIter *iter);
ClutterModelIter *(* copy) (ClutterModelIter *iter);
/*< private >*/
/* padding for future expansion */
void (*_clutter_model_iter_1) (void);
void (*_clutter_model_iter_2) (void);
void (*_clutter_model_iter_3) (void);
void (*_clutter_model_iter_4) (void);
void (*_clutter_model_iter_5) (void);
void (*_clutter_model_iter_6) (void);
void (*_clutter_model_iter_7) (void);
void (*_clutter_model_iter_8) (void);
};
CLUTTER_DEPRECATED
GType clutter_model_iter_get_type (void) G_GNUC_CONST;
CLUTTER_DEPRECATED
void clutter_model_iter_get (ClutterModelIter *iter,
...);
CLUTTER_DEPRECATED
void clutter_model_iter_get_valist (ClutterModelIter *iter,
va_list args);
CLUTTER_DEPRECATED
void clutter_model_iter_get_value (ClutterModelIter *iter,
guint column,
GValue *value);
CLUTTER_DEPRECATED
void clutter_model_iter_set (ClutterModelIter *iter,
...);
CLUTTER_DEPRECATED
void clutter_model_iter_set_valist (ClutterModelIter *iter,
va_list args);
CLUTTER_DEPRECATED
void clutter_model_iter_set_value (ClutterModelIter *iter,
guint column,
const GValue *value);
CLUTTER_DEPRECATED
gboolean clutter_model_iter_is_first (ClutterModelIter *iter);
CLUTTER_DEPRECATED
gboolean clutter_model_iter_is_last (ClutterModelIter *iter);
CLUTTER_DEPRECATED
ClutterModelIter *clutter_model_iter_next (ClutterModelIter *iter);
CLUTTER_DEPRECATED
ClutterModelIter *clutter_model_iter_prev (ClutterModelIter *iter);
CLUTTER_DEPRECATED
ClutterModel * clutter_model_iter_get_model (ClutterModelIter *iter);
CLUTTER_DEPRECATED
guint clutter_model_iter_get_row (ClutterModelIter *iter);
CLUTTER_DEPRECATED
ClutterModelIter *clutter_model_iter_copy (ClutterModelIter *iter);
G_END_DECLS
#endif /* __CLUTTER_MODEL_H__ */

1166
clutter/clutter/deprecated/clutter-score.c
View File

File diff suppressed because it is too large Load Diff

144
clutter/clutter/deprecated/clutter-score.h
View File

@ -1,144 +0,0 @@
/*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Authored By Matthew Allum <mallum@openedhand.com>
*
* Copyright (C) 2006 OpenedHand
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*/
#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
#error "Only <clutter/clutter.h> can be included directly."
#endif
#ifndef __CLUTTER_SCORE_H__
#define __CLUTTER_SCORE_H__
#include <clutter/clutter-timeline.h>
G_BEGIN_DECLS
#define CLUTTER_TYPE_SCORE (clutter_score_get_type ())
#define CLUTTER_SCORE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_SCORE, ClutterScore))
#define CLUTTER_SCORE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), CLUTTER_TYPE_SCORE, ClutterScoreClass))
#define CLUTTER_IS_SCORE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_SCORE))
#define CLUTTER_IS_SCORE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CLUTTER_TYPE_SCORE))
#define CLUTTER_SCORE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_TYPE_SCORE, ClutterScoreClass))
typedef struct _ClutterScore ClutterScore;
typedef struct _ClutterScorePrivate ClutterScorePrivate;
typedef struct _ClutterScoreClass ClutterScoreClass;
/**
* ClutterScore:
*
* The #ClutterScore structure contains only private data
* and should be accessed using the provided API
*
* Since: 0.6
*/
struct _ClutterScore
{
/*< private >*/
GObject parent;
ClutterScorePrivate *priv;
};
/**
* ClutterScoreClass:
* @timeline_started: handler for the #ClutterScore::timeline-started signal
* @timeline_completed: handler for the #ClutterScore::timeline-completed
* signal
* @started: handler for the #ClutterScore::started signal
* @completed: handler for the #ClutterScore::completed signal
* @paused: handler for the #ClutterScore::paused signal
*
* The #ClutterScoreClass structure contains only private data
*
* Since: 0.6
*/
struct _ClutterScoreClass
{
/*< private >*/
GObjectClass parent_class;
/*< public >*/
void (* timeline_started) (ClutterScore *score,
ClutterTimeline *timeline);
void (* timeline_completed) (ClutterScore *score,
ClutterTimeline *timeline);
void (* started) (ClutterScore *score);
void (* completed) (ClutterScore *score);
void (* paused) (ClutterScore *score);
/*< private >*/
/* padding for future expansion */
void (*_clutter_score_1) (void);
void (*_clutter_score_2) (void);
void (*_clutter_score_3) (void);
void (*_clutter_score_4) (void);
void (*_clutter_score_5) (void);
};
CLUTTER_DEPRECATED
GType clutter_score_get_type (void) G_GNUC_CONST;
CLUTTER_DEPRECATED
ClutterScore * clutter_score_new (void);
CLUTTER_DEPRECATED
void clutter_score_set_loop (ClutterScore *score,
gboolean loop);
CLUTTER_DEPRECATED
gboolean clutter_score_get_loop (ClutterScore *score);
CLUTTER_DEPRECATED
gulong clutter_score_append (ClutterScore *score,
ClutterTimeline *parent,
ClutterTimeline *timeline);
CLUTTER_DEPRECATED
gulong clutter_score_append_at_marker (ClutterScore *score,
ClutterTimeline *parent,
const gchar *marker_name,
ClutterTimeline *timeline);
CLUTTER_DEPRECATED
void clutter_score_remove (ClutterScore *score,
gulong id_);
CLUTTER_DEPRECATED
void clutter_score_remove_all (ClutterScore *score);
CLUTTER_DEPRECATED
ClutterTimeline *clutter_score_get_timeline (ClutterScore *score,
gulong id_);
CLUTTER_DEPRECATED
GSList * clutter_score_list_timelines (ClutterScore *score);
CLUTTER_DEPRECATED
void clutter_score_start (ClutterScore *score);
CLUTTER_DEPRECATED
void clutter_score_stop (ClutterScore *score);
CLUTTER_DEPRECATED
void clutter_score_pause (ClutterScore *score);
CLUTTER_DEPRECATED
void clutter_score_rewind (ClutterScore *score);
CLUTTER_DEPRECATED
gboolean clutter_score_is_playing (ClutterScore *score);
G_END_DECLS
#endif /* __CLUTTER_SCORE_H__ */

140
clutter/clutter/deprecated/clutter-timeout-interval.c
View File

@ -1,140 +0,0 @@
/*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Authored By Neil Roberts <neil@linux.intel.com>
*
* Copyright (C) 2009 Intel Corporation.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*/
#include "clutter-build-config.h"
#define CLUTTER_DISABLE_DEPRECATION_WARNINGS
/* This file contains the common code to check whether an interval has
expired used in clutter-frame-source and clutter-timeout-pool. */
#include "clutter-timeout-interval.h"
void
_clutter_timeout_interval_init (ClutterTimeoutInterval *interval,
guint fps)
{
#if GLIB_CHECK_VERSION (2, 27, 3)
interval->start_time = g_get_monotonic_time () / 1000;
#else
{
GTimeVal start_time;
g_get_current_time (&start_time);
interval->start_time = start_time.tv_sec * 1000
+ start_time.tv_usec / 1000;
}
#endif
interval->fps = fps;
interval->frame_count = 0;
}
static gint64
_clutter_timeout_interval_get_ticks (gint64 current_time,
ClutterTimeoutInterval *interval)
{
return MAX (current_time - interval->start_time, 0);
}
gboolean
_clutter_timeout_interval_prepare (gint64 current_time,
ClutterTimeoutInterval *interval,
gint *delay)
{
gint elapsed_time, new_frame_num;
elapsed_time = _clutter_timeout_interval_get_ticks (current_time, interval);
new_frame_num = elapsed_time * interval->fps / 1000;
/* If time has gone backwards or the time since the last frame is
greater than the two frames worth then reset the time and do a
frame now */
if (new_frame_num < interval->frame_count ||
new_frame_num - interval->frame_count > 2)
{
/* Get the frame time rounded up to the nearest ms */
guint frame_time = (1000 + interval->fps - 1) / interval->fps;
/* Reset the start time */
interval->start_time = current_time;
/* Move the start time as if one whole frame has elapsed */
interval->start_time -= frame_time;
interval->frame_count = 0;
if (delay)
*delay = 0;
return TRUE;
}
else if (new_frame_num > interval->frame_count)
{
if (delay)
*delay = 0;
return TRUE;
}
else
{
if (delay)
*delay = ((interval->frame_count + 1) * 1000 / interval->fps
- elapsed_time);
return FALSE;
}
}
gboolean
_clutter_timeout_interval_dispatch (ClutterTimeoutInterval *interval,
GSourceFunc callback,
gpointer user_data)
{
if ((* callback) (user_data))
{
interval->frame_count++;
return TRUE;
}
return FALSE;
}
gint
_clutter_timeout_interval_compare_expiration (const ClutterTimeoutInterval *a,
const ClutterTimeoutInterval *b)
{
guint a_delay = 1000 / a->fps;
guint b_delay = 1000 / b->fps;
gint64 b_difference;
gint comparison;
b_difference = a->start_time - b->start_time;
comparison = ((gint) ((a->frame_count + 1) * a_delay)
- (gint) ((b->frame_count + 1) * b_delay + b_difference));
return (comparison < 0 ? -1
: comparison > 0 ? 1
: 0);
}

58
clutter/clutter/deprecated/clutter-timeout-interval.h
View File

@ -1,58 +0,0 @@
/*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Authored By Neil Roberts <neil@linux.intel.com>
*
* Copyright (C) 2009 Intel Corporation.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __CLUTTER_TIMEOUT_INTERVAL_H__
#define __CLUTTER_TIMEOUT_INTERVAL_H__
#include <glib.h>
G_BEGIN_DECLS
typedef struct _ClutterTimeoutInterval ClutterTimeoutInterval;
struct _ClutterTimeoutInterval
{
/* milliseconds */
gint64 start_time;
guint frame_count;
guint fps;
};
void _clutter_timeout_interval_init (ClutterTimeoutInterval *interval,
guint fps);
gboolean _clutter_timeout_interval_prepare (gint64 current_time,
ClutterTimeoutInterval *interval,
gint *delay);
gboolean _clutter_timeout_interval_dispatch (ClutterTimeoutInterval *interval,
GSourceFunc callback,
gpointer user_data);
gint _clutter_timeout_interval_compare_expiration (const ClutterTimeoutInterval *a,
const ClutterTimeoutInterval *b);
G_END_DECLS
#endif /* __CLUTTER_TIMEOUT_INTERVAL_H__ */

498
clutter/clutter/deprecated/clutter-timeout-pool.c
View File

@ -1,498 +0,0 @@
/*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Authored By Matthew Allum <mallum@openedhand.com>
*
* Copyright (C) 2006 OpenedHand
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*
*
*
* ClutterTimeoutPool: pool of timeout functions using the same slice of
* the GLib main loop
*
* Author: Emmanuele Bassi <ebassi@openedhand.com>
*
* Based on similar code by Tristan van Berkom
*/
#include "clutter-build-config.h"
#define CLUTTER_DISABLE_DEPRECATION_WARNINGS
#include "deprecated/clutter-main.h"
#include "clutter-timeout-pool.h"
#include "clutter-debug.h"
#include "clutter-timeout-interval.h"
typedef struct _ClutterTimeout ClutterTimeout;
typedef enum {
CLUTTER_TIMEOUT_NONE = 0,
CLUTTER_TIMEOUT_READY = 1 << 1
} ClutterTimeoutFlags;
struct _ClutterTimeout
{
guint id;
ClutterTimeoutFlags flags;
gint refcount;
ClutterTimeoutInterval interval;
GSourceFunc func;
gpointer data;
GDestroyNotify notify;
};
struct _ClutterTimeoutPool
{
GSource source;
guint next_id;
GList *timeouts;
GList *dispatched_timeouts;
gint ready;
guint id;
};
#define TIMEOUT_READY(timeout) (timeout->flags & CLUTTER_TIMEOUT_READY)
static gboolean clutter_timeout_pool_prepare (GSource *source,
gint *next_timeout);
static gboolean clutter_timeout_pool_check (GSource *source);
static gboolean clutter_timeout_pool_dispatch (GSource *source,
GSourceFunc callback,
gpointer data);
static void clutter_timeout_pool_finalize (GSource *source);
static GSourceFuncs clutter_timeout_pool_funcs =
{
clutter_timeout_pool_prepare,
clutter_timeout_pool_check,
clutter_timeout_pool_dispatch,
clutter_timeout_pool_finalize
};
static gint
clutter_timeout_sort (gconstpointer a,
gconstpointer b)
{
const ClutterTimeout *t_a = a;
const ClutterTimeout *t_b = b;
/* Keep 'ready' timeouts at the front */
if (TIMEOUT_READY (t_a))
return -1;
if (TIMEOUT_READY (t_b))
return 1;
return _clutter_timeout_interval_compare_expiration (&t_a->interval,
&t_b->interval);
}
static gint
clutter_timeout_find_by_id (gconstpointer a,
gconstpointer b)
{
const ClutterTimeout *t_a = a;
return t_a->id == GPOINTER_TO_UINT (b) ? 0 : 1;
}
static ClutterTimeout *
clutter_timeout_new (guint fps)
{
ClutterTimeout *timeout;
timeout = g_slice_new0 (ClutterTimeout);
_clutter_timeout_interval_init (&timeout->interval, fps);
timeout->flags = CLUTTER_TIMEOUT_NONE;
timeout->refcount = 1;
return timeout;
}
static gboolean
clutter_timeout_prepare (ClutterTimeoutPool *pool,
ClutterTimeout *timeout,
gint *next_timeout)
{
GSource *source = (GSource *) pool;
gint64 now;
#if GLIB_CHECK_VERSION (2, 27, 3)
now = g_source_get_time (source) / 1000;
#else
{
GTimeVal source_time;
g_source_get_current_time (source, &source_time);
now = source_time.tv_sec * 1000 + source_time.tv_usec / 1000;
}
#endif
return _clutter_timeout_interval_prepare (now,
&timeout->interval,
next_timeout);
}
/* ref and unref are always called under the main Clutter lock, so there
* is not need for us to use g_atomic_int_* API.
*/
static ClutterTimeout *
clutter_timeout_ref (ClutterTimeout *timeout)
{
g_return_val_if_fail (timeout != NULL, timeout);
g_return_val_if_fail (timeout->refcount > 0, timeout);
timeout->refcount += 1;
return timeout;
}
static void
clutter_timeout_unref (ClutterTimeout *timeout)
{
g_return_if_fail (timeout != NULL);
g_return_if_fail (timeout->refcount > 0);
timeout->refcount -= 1;
if (timeout->refcount == 0)
{
if (timeout->notify)
timeout->notify (timeout->data);
g_slice_free (ClutterTimeout, timeout);
}
}
static void
clutter_timeout_free (ClutterTimeout *timeout)
{
if (G_LIKELY (timeout))
{
if (timeout->notify)
timeout->notify (timeout->data);
g_slice_free (ClutterTimeout, timeout);
}
}
static gboolean
clutter_timeout_pool_prepare (GSource *source,
gint *next_timeout)
{
ClutterTimeoutPool *pool = (ClutterTimeoutPool *) source;
GList *l = pool->timeouts;
/* the pool is ready if the first timeout is ready */
if (l && l->data)
{
ClutterTimeout *timeout = l->data;
return clutter_timeout_prepare (pool, timeout, next_timeout);
}
else
{
*next_timeout = -1;
return FALSE;
}
}
static gboolean
clutter_timeout_pool_check (GSource *source)
{
ClutterTimeoutPool *pool = (ClutterTimeoutPool *) source;
GList *l;
clutter_threads_enter ();
for (l = pool->timeouts; l; l = l->next)
{
ClutterTimeout *timeout = l->data;
/* since the timeouts are sorted by expiration, as soon
* as we get a check returning FALSE we know that the
* following timeouts are not expiring, so we break as
* soon as possible
*/
if (clutter_timeout_prepare (pool, timeout, NULL))
{
timeout->flags |= CLUTTER_TIMEOUT_READY;
pool->ready += 1;
}
else
break;
}
clutter_threads_leave ();
return (pool->ready > 0);
}
static gboolean
clutter_timeout_pool_dispatch (GSource *source,
GSourceFunc func,
gpointer data)
{
ClutterTimeoutPool *pool = (ClutterTimeoutPool *) source;
GList *dispatched_timeouts;
/* the main loop might have predicted this, so we repeat the
* check for ready timeouts.
*/
if (!pool->ready)
clutter_timeout_pool_check (source);
clutter_threads_enter ();
/* Iterate by moving the actual start of the list along so that it
* can cope with adds and removes while a timeout is being dispatched
*/
while (pool->timeouts && pool->timeouts->data && pool->ready-- > 0)
{
ClutterTimeout *timeout = pool->timeouts->data;
GList *l;
/* One of the ready timeouts may have been removed during dispatch,
* in which case pool->ready will be wrong, but the ready timeouts
* are always kept at the start of the list so we can stop once
* we've reached the first non-ready timeout
*/
if (!(TIMEOUT_READY (timeout)))
break;
/* Add a reference to the timeout so it can't disappear
* while it's being dispatched
*/
clutter_timeout_ref (timeout);
timeout->flags &= ~CLUTTER_TIMEOUT_READY;
/* Move the list node to a list of dispatched timeouts */
l = pool->timeouts;
if (l->next)
l->next->prev = NULL;
pool->timeouts = l->next;
if (pool->dispatched_timeouts)
pool->dispatched_timeouts->prev = l;
l->prev = NULL;
l->next = pool->dispatched_timeouts;
pool->dispatched_timeouts = l;
if (!_clutter_timeout_interval_dispatch (&timeout->interval,
timeout->func, timeout->data))
{
/* The timeout may have already been removed, but nothing
* can be added to the dispatched_timeout list except in this
* function so it will always either be at the head of the
* dispatched list or have been removed
*/
if (pool->dispatched_timeouts &&
pool->dispatched_timeouts->data == timeout)
{
pool->dispatched_timeouts =
g_list_delete_link (pool->dispatched_timeouts,
pool->dispatched_timeouts);
/* Remove the reference that was held by it being in the list */
clutter_timeout_unref (timeout);
}
}
clutter_timeout_unref (timeout);
}
/* Re-insert the dispatched timeouts in sorted order */
dispatched_timeouts = pool->dispatched_timeouts;
while (dispatched_timeouts)
{
ClutterTimeout *timeout = dispatched_timeouts->data;
GList *next = dispatched_timeouts->next;
if (timeout)
pool->timeouts = g_list_insert_sorted (pool->timeouts, timeout,
clutter_timeout_sort);
dispatched_timeouts = next;
}
g_list_free (pool->dispatched_timeouts);
pool->dispatched_timeouts = NULL;
pool->ready = 0;
clutter_threads_leave ();
return TRUE;
}
static void
clutter_timeout_pool_finalize (GSource *source)
{
ClutterTimeoutPool *pool = (ClutterTimeoutPool *) source;
/* force destruction */
g_list_foreach (pool->timeouts, (GFunc) clutter_timeout_free, NULL);
g_list_free (pool->timeouts);
}
/**
* clutter_timeout_pool_new:
* @priority: the priority of the timeout pool. Typically this will
* be #G_PRIORITY_DEFAULT
*
* Creates a new timeout pool source. A timeout pool should be used when
* multiple timeout functions, running at the same priority, are needed and
* the g_timeout_add() API might lead to starvation of the time slice of
* the main loop. A timeout pool allocates a single time slice of the main
* loop and runs every timeout function inside it. The timeout pool is
* always sorted, so that the extraction of the next timeout function is
* a constant time operation.
*
* Return value: the newly created #ClutterTimeoutPool. The created pool
* is owned by the GLib default context and will be automatically
* destroyed when the context is destroyed. It is possible to force
* the destruction of the timeout pool using g_source_destroy()
*
* Since: 0.4
*
* Deprecated: 1.6: There is no direct replacement for this API
*/
ClutterTimeoutPool *
clutter_timeout_pool_new (gint priority)
{
ClutterTimeoutPool *pool;
GSource *source;
source = g_source_new (&clutter_timeout_pool_funcs,
sizeof (ClutterTimeoutPool));
if (!source)
return NULL;
g_source_set_name (source, "Clutter timeout pool");
if (priority != G_PRIORITY_DEFAULT)
g_source_set_priority (source, priority);
pool = (ClutterTimeoutPool *) source;
pool->next_id = 1;
pool->id = g_source_attach (source, NULL);
/* let the default GLib context manage the pool */
g_source_unref (source);
return pool;
}
/**
* clutter_timeout_pool_add:
* @pool: a #ClutterTimeoutPool
* @fps: the time between calls to the function, in frames per second
* @func: function to call
* @data: (closure): data to pass to the function, or %NULL
* @notify: function to call when the timeout is removed, or %NULL
*
* Sets a function to be called at regular intervals, and puts it inside
* the @pool. The function is repeatedly called until it returns %FALSE,
* at which point the timeout is automatically destroyed and the function
* won't be called again. If @notify is not %NULL, the @notify function
* will be called. The first call to @func will be at the end of @interval.
*
* Since Clutter 0.8 this will try to compensate for delays. For
* example, if @func takes half the interval time to execute then the
* function will be called again half the interval time after it
* finished. Before version 0.8 it would not fire until a full
* interval after the function completes so the delay between calls
* would be @interval * 1.5. This function does not however try to
* invoke the function multiple times to catch up missing frames if
* @func takes more than @interval ms to execute.
*
* Return value: the ID (greater than 0) of the timeout inside the pool.
* Use clutter_timeout_pool_remove() to stop the timeout.
*
* Since: 0.4
*
* Deprecated: 1.6: There is no direct replacement for this API
*/
guint
clutter_timeout_pool_add (ClutterTimeoutPool *pool,
guint fps,
GSourceFunc func,
gpointer data,
GDestroyNotify notify)
{
ClutterTimeout *timeout;
guint retval = 0;
timeout = clutter_timeout_new (fps);
retval = timeout->id = pool->next_id++;
timeout->func = func;
timeout->data = data;
timeout->notify = notify;
pool->timeouts = g_list_insert_sorted (pool->timeouts, timeout,
clutter_timeout_sort);
return retval;
}
/**
* clutter_timeout_pool_remove:
* @pool: a #ClutterTimeoutPool
* @id_: the id of the timeout to remove
*
* Removes a timeout function with @id_ from the timeout pool. The id
* is the same returned when adding a function to the timeout pool with
* clutter_timeout_pool_add().
*
* Since: 0.4
*
* Deprecated: 1.6: There is no direct replacement for this API
*/
void
clutter_timeout_pool_remove (ClutterTimeoutPool *pool,
guint id_)
{
GList *l;
if ((l = g_list_find_custom (pool->timeouts, GUINT_TO_POINTER (id_),
clutter_timeout_find_by_id)))
{
clutter_timeout_unref (l->data);
pool->timeouts = g_list_delete_link (pool->timeouts, l);
}
else if ((l = g_list_find_custom (pool->dispatched_timeouts,
GUINT_TO_POINTER (id_),
clutter_timeout_find_by_id)))
{
clutter_timeout_unref (l->data);
pool->dispatched_timeouts =
g_list_delete_link (pool->dispatched_timeouts, l);
}
}

69
clutter/clutter/deprecated/clutter-timeout-pool.h
View File

@ -1,69 +0,0 @@
/*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Authored By Matthew Allum <mallum@openedhand.com>
*
* Copyright (C) 2006 OpenedHand
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*
* ClutterTimeoutPool: pool of timeout functions using the same slice of
* the GLib main loop
*
* Author: Emmanuele Bassi <ebassi@openedhand.com>
*
* Based on similar code by Tristan van Berkom
*/
#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
#error "Only <clutter/clutter.h> can be included directly."
#endif
#ifndef __CLUTTER_TIMEOUT_POOL_H__
#define __CLUTTER_TIMEOUT_POOL_H__
#include <clutter/clutter-types.h>
G_BEGIN_DECLS
/**
* ClutterTimeoutPool: (skip)
*
* #ClutterTimeoutPool is an opaque structure
* whose members cannot be directly accessed.
*
* Since: 0.6
*
* Deprecated: 1.6
*/
typedef struct _ClutterTimeoutPool ClutterTimeoutPool;
CLUTTER_DEPRECATED
ClutterTimeoutPool *clutter_timeout_pool_new (gint priority);
CLUTTER_DEPRECATED
guint clutter_timeout_pool_add (ClutterTimeoutPool *pool,
guint fps,
GSourceFunc func,
gpointer data,
GDestroyNotify notify);
CLUTTER_DEPRECATED
void clutter_timeout_pool_remove (ClutterTimeoutPool *pool,
guint id_);
G_END_DECLS
#endif /* __CLUTTER_TIMEOUT_POOL_H__ */

23
clutter/clutter/meson.build
View File

@ -231,16 +231,11 @@ clutter_deprecated_headers = [
'deprecated/clutter-box.h',
'deprecated/clutter-cairo-texture.h',
'deprecated/clutter-container.h',
'deprecated/clutter-frame-source.h',
'deprecated/clutter-group.h',
'deprecated/clutter-input-device.h',
'deprecated/clutter-keysyms.h',
'deprecated/clutter-list-model.h',
'deprecated/clutter-main.h',
'deprecated/clutter-media.h',
'deprecated/clutter-model.h',
'deprecated/clutter-rectangle.h',
'deprecated/clutter-score.h',
'deprecated/clutter-shader.h',
'deprecated/clutter-stage-manager.h',
'deprecated/clutter-stage.h',
@ -248,7 +243,6 @@ clutter_deprecated_headers = [
'deprecated/clutter-table-layout.h',
'deprecated/clutter-texture.h',
'deprecated/clutter-timeline.h',
'deprecated/clutter-timeout-pool.h',
'deprecated/clutter-util.h',
]
@ -266,29 +260,14 @@ clutter_deprecated_sources = [
'deprecated/clutter-behaviour-scale.c',
'deprecated/clutter-box.c',
'deprecated/clutter-cairo-texture.c',
'deprecated/clutter-frame-source.c',
'deprecated/clutter-group.c',
'deprecated/clutter-input-device-deprecated.c',
'deprecated/clutter-layout-manager-deprecated.c',
'deprecated/clutter-list-model.c',
'deprecated/clutter-media.c',
'deprecated/clutter-model.c',
'deprecated/clutter-rectangle.c',
'deprecated/clutter-score.c',
'deprecated/clutter-shader.c',
'deprecated/clutter-state.c',
'deprecated/clutter-table-layout.c',
'deprecated/clutter-texture.c',
'deprecated/clutter-timeout-pool.c',
]
clutter_deprecated_private_headers = [
'deprecated/clutter-model-private.h',
'deprecated/clutter-timeout-interval.h',
]
clutter_deprecated_nonintrospected_sources = [
'deprecated/clutter-timeout-interval.c',
]
clutter_backend_sources = []
@ -508,9 +487,7 @@ libmutter_clutter = shared_library(libmutter_clutter_name,
clutter_private_headers,
clutter_nonintrospected_sources,
clutter_deprecated_sources,
clutter_deprecated_nonintrospected_sources,
clutter_deprecated_headers,
clutter_deprecated_private_headers,
clutter_backend_sources,
clutter_backend_nonintrospected_sources,
clutter_backend_headers,

1
clutter/tests/conform/Makefile.am
View File

@ -43,7 +43,6 @@ general_tests = \
binding-pool \
color \
interval \
model \
script-parser \
units \
$(NULL)

1
clutter/tests/conform/meson.build
View File

@ -35,7 +35,6 @@ clutter_conform_tests_general_tests = [
'binding-pool',
'color',
'interval',
'model',
'script-parser',
'units',
]

528
clutter/tests/conform/model.c
View File

@ -1,528 +0,0 @@
#include <stdlib.h>
#include <string.h>
#define CLUTTER_DISABLE_DEPRECATION_WARNINGS
#include <clutter/clutter.h>
typedef struct _ModelData
{
ClutterModel *model;
guint n_row;
} ModelData;
typedef struct _ChangedData
{
ClutterModel *model;
ClutterModelIter *iter;
guint row;
guint n_emissions;
gint value_check;
} ChangedData;
enum
{
COLUMN_FOO, /* G_TYPE_STRING */
COLUMN_BAR, /* G_TYPE_INT */
N_COLUMNS
};
static const struct {
const gchar *expected_foo;
gint expected_bar;
} base_model[] = {
{ "String 1", 1 },
{ "String 2", 2 },
{ "String 3", 3 },
{ "String 4", 4 },
{ "String 5", 5 },
{ "String 6", 6 },
{ "String 7", 7 },
{ "String 8", 8 },
{ "String 9", 9 },
};
static const struct {
const gchar *expected_foo;
gint expected_bar;
} forward_base[] = {
{ "String 1", 1 },
{ "String 2", 2 },
{ "String 3", 3 },
{ "String 4", 4 },
{ "String 5", 5 },
{ "String 6", 6 },
{ "String 7", 7 },
{ "String 8", 8 },
{ "String 9", 9 },
};
static const struct {
const gchar *expected_foo;
gint expected_bar;
} backward_base[] = {
{ "String 9", 9 },
{ "String 8", 8 },
{ "String 7", 7 },
{ "String 6", 6 },
{ "String 5", 5 },
{ "String 4", 4 },
{ "String 3", 3 },
{ "String 2", 2 },
{ "String 1", 1 },
};
static const struct {
const gchar *expected_foo;
gint expected_bar;
} filter_odd[] = {
{ "String 1", 1 },
{ "String 3", 3 },
{ "String 5", 5 },
{ "String 7", 7 },
{ "String 9", 9 },
};
static const struct {
const gchar *expected_foo;
gint expected_bar;
} filter_even[] = {
{ "String 8", 8 },
{ "String 6", 6 },
{ "String 4", 4 },
{ "String 2", 2 },
};
static inline void
compare_iter (ClutterModelIter *iter,
const gint expected_row,
const gchar *expected_foo,
const gint expected_bar)
{
gchar *foo = NULL;
gint bar = 0;
gint row = 0;
row = clutter_model_iter_get_row (iter);
clutter_model_iter_get (iter,
COLUMN_FOO, &foo,
COLUMN_BAR, &bar,
-1);
if (g_test_verbose ())
g_print ("Row %d => %d: Got [ '%s', '%d' ], expected [ '%s', '%d' ]\n",
row, expected_row,
foo, bar,
expected_foo, expected_bar);
g_assert_cmpint (row, ==, expected_row);
g_assert_cmpstr (foo, ==, expected_foo);
g_assert_cmpint (bar, ==, expected_bar);
g_free (foo);
}
static void
on_row_added (ClutterModel *model,
ClutterModelIter *iter,
gpointer data)
{
ModelData *model_data = data;
compare_iter (iter,
model_data->n_row,
base_model[model_data->n_row].expected_foo,
base_model[model_data->n_row].expected_bar);
model_data->n_row += 1;
}
static gboolean
filter_even_rows (ClutterModel *model,
ClutterModelIter *iter,
gpointer dummy G_GNUC_UNUSED)
{
gint bar_value;
clutter_model_iter_get (iter, COLUMN_BAR, &bar_value, -1);
if (bar_value % 2 == 0)
return TRUE;
return FALSE;
}
static gboolean
filter_odd_rows (ClutterModel *model,
ClutterModelIter *iter,
gpointer dummy G_GNUC_UNUSED)
{
gint bar_value;
clutter_model_iter_get (iter, COLUMN_BAR, &bar_value, -1);
if (bar_value % 2 != 0)
return TRUE;
return FALSE;
}
static void
list_model_filter (void)
{
ModelData test_data = { NULL, 0 };
ClutterModelIter *iter;
gint i;
test_data.model = clutter_list_model_new (N_COLUMNS,
G_TYPE_STRING, "Foo",
G_TYPE_INT, "Bar");
test_data.n_row = 0;
for (i = 1; i < 10; i++)
{
gchar *foo = g_strdup_printf ("String %d", i);
clutter_model_append (test_data.model,
COLUMN_FOO, foo,
COLUMN_BAR, i,
-1);
g_free (foo);
}
if (g_test_verbose ())
g_print ("Forward iteration (filter odd)...\n");
clutter_model_set_filter (test_data.model, filter_odd_rows, NULL, NULL);
iter = clutter_model_get_first_iter (test_data.model);
g_assert (iter != NULL);
i = 0;
while (!clutter_model_iter_is_last (iter))
{
compare_iter (iter, i,
filter_odd[i].expected_foo,
filter_odd[i].expected_bar);
iter = clutter_model_iter_next (iter);
i += 1;
}
g_object_unref (iter);
if (g_test_verbose ())
g_print ("Backward iteration (filter even)...\n");
clutter_model_set_filter (test_data.model, filter_even_rows, NULL, NULL);
iter = clutter_model_get_last_iter (test_data.model);
g_assert (iter != NULL);
i = 0;
do
{
compare_iter (iter, G_N_ELEMENTS (filter_even) - i - 1,
filter_even[i].expected_foo,
filter_even[i].expected_bar);
iter = clutter_model_iter_prev (iter);
i += 1;
}
while (!clutter_model_iter_is_first (iter));
g_object_unref (iter);
if (g_test_verbose ())
g_print ("get_iter_at_row...\n");
clutter_model_set_filter (test_data.model, filter_odd_rows, NULL, NULL);
for (i = 0; i < 5; i++)
{
iter = clutter_model_get_iter_at_row (test_data.model, i);
compare_iter (iter, i ,
filter_odd[i].expected_foo,
filter_odd[i].expected_bar);
g_object_unref (iter);
}
iter = clutter_model_get_iter_at_row (test_data.model, 5);
g_assert (iter == NULL);
g_object_unref (test_data.model);
}
static void
list_model_iterate (void)
{
ModelData test_data = { NULL, 0 };
ClutterModelIter *iter;
gint i;
test_data.model = clutter_list_model_new (N_COLUMNS,
G_TYPE_STRING, "Foo",
G_TYPE_INT, "Bar");
test_data.n_row = 0;
g_signal_connect (test_data.model, "row-added",
G_CALLBACK (on_row_added),
&test_data);
for (i = 1; i < 10; i++)
{
gchar *foo = g_strdup_printf ("String %d", i);
clutter_model_append (test_data.model,
COLUMN_FOO, foo,
COLUMN_BAR, i,
-1);
g_free (foo);
}
if (g_test_verbose ())
g_print ("Forward iteration...\n");
iter = clutter_model_get_first_iter (test_data.model);
g_assert (iter != NULL);
i = 0;
while (!clutter_model_iter_is_last (iter))
{
compare_iter (iter, i,
forward_base[i].expected_foo,
forward_base[i].expected_bar);
iter = clutter_model_iter_next (iter);
i += 1;
}
g_object_unref (iter);
if (g_test_verbose ())
g_print ("Backward iteration...\n");
iter = clutter_model_get_last_iter (test_data.model);
g_assert (iter != NULL);
i = 0;
do
{
compare_iter (iter, G_N_ELEMENTS (backward_base) - i - 1,
backward_base[i].expected_foo,
backward_base[i].expected_bar);
iter = clutter_model_iter_prev (iter);
i += 1;
}
while (!clutter_model_iter_is_first (iter));
compare_iter (iter, G_N_ELEMENTS (backward_base) - i - 1,
backward_base[i].expected_foo,
backward_base[i].expected_bar);
g_object_unref (iter);
g_object_unref (test_data.model);
}
static void
list_model_populate (void)
{
ModelData test_data = { NULL, 0 };
gint i;
test_data.model = clutter_list_model_new (N_COLUMNS,
G_TYPE_STRING, "Foo",
G_TYPE_INT, "Bar");
test_data.n_row = 0;
g_signal_connect (test_data.model, "row-added",
G_CALLBACK (on_row_added),
&test_data);
for (i = 1; i < 10; i++)
{
gchar *foo = g_strdup_printf ("String %d", i);
clutter_model_append (test_data.model,
COLUMN_FOO, foo,
COLUMN_BAR, i,
-1);
g_free (foo);
}
g_object_unref (test_data.model);
}
static void
list_model_from_script (void)
{
ClutterScript *script = clutter_script_new ();
GObject *model;
GError *error = NULL;
gchar *test_file;
const gchar *name;
GType type;
ClutterModelIter *iter;
GValue value = { 0, };
test_file = g_test_build_filename (G_TEST_DIST, "scripts", "test-script-model.json", NULL);
clutter_script_load_from_file (script, test_file, &error);
if (g_test_verbose () && error)
g_print ("Error: %s", error->message);
g_assert_no_error (error);
model = clutter_script_get_object (script, "test-model");
g_assert (CLUTTER_IS_MODEL (model));
g_assert (clutter_model_get_n_columns (CLUTTER_MODEL (model)) == 3);
name = clutter_model_get_column_name (CLUTTER_MODEL (model), 0);
type = clutter_model_get_column_type (CLUTTER_MODEL (model), 0);
if (g_test_verbose ())
g_print ("column[0]: %s, type: %s\n", name, g_type_name (type));
g_assert (strcmp (name, "text-column") == 0);
g_assert (type == G_TYPE_STRING);
name = clutter_model_get_column_name (CLUTTER_MODEL (model), 2);
type = clutter_model_get_column_type (CLUTTER_MODEL (model), 2);
if (g_test_verbose ())
g_print ("column[2]: %s, type: %s\n", name, g_type_name (type));
g_assert (strcmp (name, "actor-column") == 0);
g_assert (g_type_is_a (type, CLUTTER_TYPE_ACTOR));
g_assert (clutter_model_get_n_rows (CLUTTER_MODEL (model)) == 3);
iter = clutter_model_get_iter_at_row (CLUTTER_MODEL (model), 0);
clutter_model_iter_get_value (iter, 0, &value);
g_assert (G_VALUE_HOLDS_STRING (&value));
g_assert (strcmp (g_value_get_string (&value), "text-row-1") == 0);
g_value_unset (&value);
clutter_model_iter_get_value (iter, 1, &value);
g_assert (G_VALUE_HOLDS_INT (&value));
g_assert (g_value_get_int (&value) == 1);
g_value_unset (&value);
clutter_model_iter_get_value (iter, 2, &value);
g_assert (G_VALUE_HOLDS_OBJECT (&value));
g_assert (g_value_get_object (&value) == NULL);
g_value_unset (&value);
iter = clutter_model_iter_next (iter);
clutter_model_iter_get_value (iter, 2, &value);
g_assert (G_VALUE_HOLDS_OBJECT (&value));
g_assert (CLUTTER_IS_ACTOR (g_value_get_object (&value)));
g_value_unset (&value);
iter = clutter_model_iter_next (iter);
clutter_model_iter_get_value (iter, 2, &value);
g_assert (G_VALUE_HOLDS_OBJECT (&value));
g_assert (CLUTTER_IS_ACTOR (g_value_get_object (&value)));
g_assert (strcmp (clutter_actor_get_name (g_value_get_object (&value)),
"actor-row-3") == 0);
g_value_unset (&value);
g_object_unref (iter);
}
static void
on_row_changed (ClutterModel *model,
ClutterModelIter *iter,
ChangedData *data)
{
gint value = -1;
clutter_model_iter_get (iter, COLUMN_BAR, &value, -1);
if (g_test_verbose ())
g_print ("row-changed value-check: %d, expected: %d\n",
value, data->value_check);
g_assert_cmpint (value, ==, data->value_check);
data->n_emissions += 1;
}
static void
list_model_row_changed (void)
{
ChangedData test_data = { NULL, NULL, 0, 0 };
GValue value = { 0, };
gint i;
test_data.model = clutter_list_model_new (N_COLUMNS,
G_TYPE_STRING, "Foo",
G_TYPE_INT, "Bar");
for (i = 1; i < 10; i++)
{
gchar *foo = g_strdup_printf ("String %d", i);
clutter_model_append (test_data.model,
COLUMN_FOO, foo,
COLUMN_BAR, i,
-1);
g_free (foo);
}
g_signal_connect (test_data.model, "row-changed",
G_CALLBACK (on_row_changed),
&test_data);
test_data.row = g_random_int_range (0, 9);
test_data.iter = clutter_model_get_iter_at_row (test_data.model,
test_data.row);
g_assert (CLUTTER_IS_MODEL_ITER (test_data.iter));
test_data.value_check = 47;
g_value_init (&value, G_TYPE_INT);
g_value_set_int (&value, test_data.value_check);
clutter_model_iter_set_value (test_data.iter, COLUMN_BAR, &value);
g_value_unset (&value);
if (g_test_verbose ())
g_print ("iter.set_value() emissions: %d, expected: 1\n",
test_data.n_emissions);
g_assert_cmpint (test_data.n_emissions, ==, 1);
test_data.n_emissions = 0;
test_data.value_check = 42;
clutter_model_iter_set (test_data.iter,
COLUMN_FOO, "changed",
COLUMN_BAR, test_data.value_check,
-1);
if (g_test_verbose ())
g_print ("iter.set() emissions: %d, expected: 1\n",
test_data.n_emissions);
g_assert_cmpint (test_data.n_emissions, ==, 1);
g_object_unref (test_data.iter);
g_object_unref (test_data.model);
}
CLUTTER_TEST_SUITE (
CLUTTER_TEST_UNIT ("/list-model/populate", list_model_populate)
CLUTTER_TEST_UNIT ("/list-model/iterate", list_model_iterate)
CLUTTER_TEST_UNIT ("/list-model/filter", list_model_filter)
CLUTTER_TEST_UNIT ("/list-model/row-changed", list_model_row_changed)
CLUTTER_TEST_UNIT ("/list-model/from-script", list_model_from_script)
)

121
clutter/tests/conform/score.c
View File

@ -1,121 +0,0 @@
#include <stdio.h>
#include <stdlib.h>
#include <clutter/clutter.h>
#include "test-conform-common.h"
static guint level = 0;
static void
on_score_started (ClutterScore *score)
{
if (g_test_verbose ())
g_print ("Score started\n");
}
static void
on_score_completed (ClutterScore *score)
{
if (g_test_verbose ())
g_print ("Score completed\n");
}
static void
on_timeline_started (ClutterScore *score,
ClutterTimeline *timeline)
{
if (g_test_verbose ())
g_print ("Started timeline: '%s'\n",
(gchar *) g_object_get_data (G_OBJECT (timeline), "timeline-name"));
level += 1;
}
static void
on_timeline_completed (ClutterScore *score,
ClutterTimeline *timeline)
{
if (g_test_verbose ())
g_print ("Completed timeline: '%s'\n",
(gchar *) g_object_get_data (G_OBJECT (timeline), "timeline-name"));
level -= 1;
}
void
score_base (TestConformSimpleFixture *fixture,
gconstpointer data)
{
ClutterScore *score;
ClutterTimeline *timeline_1;
ClutterTimeline *timeline_2;
ClutterTimeline *timeline_3;
ClutterTimeline *timeline_4;
ClutterTimeline *timeline_5;
GSList *timelines;
/* FIXME - this is necessary to make the master clock spin */
ClutterActor *stage = clutter_stage_new ();
timeline_1 = clutter_timeline_new (100);
g_object_set_data_full (G_OBJECT (timeline_1),
"timeline-name", g_strdup ("Timeline 1"),
g_free);
timeline_2 = clutter_timeline_new (100);
clutter_timeline_add_marker_at_time (timeline_2, "foo", 50);
g_object_set_data_full (G_OBJECT (timeline_2),
"timeline-name", g_strdup ("Timeline 2"),
g_free);
timeline_3 = clutter_timeline_new (100);
g_object_set_data_full (G_OBJECT (timeline_3),
"timeline-name", g_strdup ("Timeline 3"),
g_free);
timeline_4 = clutter_timeline_new (100);
g_object_set_data_full (G_OBJECT (timeline_4),
"timeline-name", g_strdup ("Timeline 4"),
g_free);
timeline_5 = clutter_timeline_new (100);
g_object_set_data_full (G_OBJECT (timeline_5),
"timeline-name", g_strdup ("Timeline 5"),
g_free);
score = clutter_score_new();
g_signal_connect (score, "started",
G_CALLBACK (on_score_started),
NULL);
g_signal_connect (score, "timeline-started",
G_CALLBACK (on_timeline_started),
NULL);
g_signal_connect (score, "timeline-completed",
G_CALLBACK (on_timeline_completed),
NULL);
g_signal_connect (score, "completed",
G_CALLBACK (on_score_completed),
NULL);
clutter_score_append (score, NULL, timeline_1);
clutter_score_append (score, timeline_1, timeline_2);
clutter_score_append (score, timeline_1, timeline_3);
clutter_score_append (score, timeline_3, timeline_4);
clutter_score_append_at_marker (score, timeline_2, "foo", timeline_5);
timelines = clutter_score_list_timelines (score);
g_assert (5 == g_slist_length (timelines));
g_slist_free (timelines);
clutter_score_start (score);
clutter_actor_destroy (stage);
g_object_unref (timeline_1);
g_object_unref (timeline_2);
g_object_unref (timeline_3);
g_object_unref (timeline_4);
g_object_unref (timeline_5);
g_object_unref (score);
}

2
po/POTFILES.skip
View File

@ -66,8 +66,6 @@ clutter/clutter/deprecated/clutter-behaviour-rotate.c
clutter/clutter/deprecated/clutter-behaviour-scale.c
clutter/clutter/deprecated/clutter-box.c
clutter/clutter/deprecated/clutter-cairo-texture.c
clutter/clutter/deprecated/clutter-fixed.c
clutter/clutter/deprecated/clutter-media.c
clutter/clutter/deprecated/clutter-rectangle.c
clutter/clutter/deprecated/clutter-shader.c
clutter/clutter/deprecated/clutter-state.c