/**
* bt_persistence_load:
* @type: a #GObject type
* @self: a deserialiable object
* @node: the xml node
* @err: a GError for deserialisation errors
* @...: extra parameters NULL terminated name/value pairs.
*
* Deserializes the given object from the @node. If @self is %NULL and a @type
* is given it constructs a new object.
*
* Returns: (transfer none): the deserialized object or %NULL.
*/
BtPersistence *
bt_persistence_load (const GType type, const BtPersistence * const self,
xmlNodePtr node, GError ** err, ...)
{
BtPersistence *result;
va_list var_args;
if (!self) {
GObjectClass *klass;
BtPersistenceInterface *iface;
g_return_val_if_fail (G_TYPE_IS_OBJECT (type), NULL);
klass = g_type_class_ref (type);
iface = g_type_interface_peek (klass, BT_TYPE_PERSISTENCE);
va_start (var_args, err);
result = iface->load (type, self, node, err, var_args);
va_end (var_args);
g_type_class_unref (klass);
} else {
g_return_val_if_fail (BT_IS_PERSISTENCE (self), NULL);
va_start (var_args, err);
result =
BT_PERSISTENCE_GET_INTERFACE (self)->load (type, self, node, err,
var_args);
va_end (var_args);
}
return result;
}
/**
* clutter_container_class_find_child_property:
* @klass: a #GObjectClass implementing the #ClutterContainer interface.
* @property_name: a property name.
*
* Looks up the #GParamSpec for a child property of @klass.
*
* Return value: (transfer none): The #GParamSpec for the property or %NULL
* if no such property exist.
*
* Since: 0.8
*/
GParamSpec *
clutter_container_class_find_child_property (GObjectClass *klass,
const gchar *property_name)
{
ClutterContainerIface *iface;
GObjectClass *child_class;
GParamSpec *pspec;
g_return_val_if_fail (G_IS_OBJECT_CLASS (klass), NULL);
g_return_val_if_fail (property_name != NULL, NULL);
g_return_val_if_fail (g_type_is_a (G_TYPE_FROM_CLASS (klass),
CLUTTER_TYPE_CONTAINER),
NULL);
iface = g_type_interface_peek (klass, CLUTTER_TYPE_CONTAINER);
g_return_val_if_fail (iface != NULL, NULL);
if (iface->child_meta_type == G_TYPE_INVALID)
return NULL;
child_class = g_type_class_ref (iface->child_meta_type);
pspec = g_object_class_find_property (child_class, property_name);
g_type_class_unref (child_class);
return pspec;
}
static gboolean
gimp_config_iface_equal (GimpConfig *a,
GimpConfig *b)
{
GObjectClass *klass;
GParamSpec **property_specs;
guint n_property_specs;
guint i;
gboolean equal = TRUE;
klass = G_OBJECT_GET_CLASS (a);
property_specs = g_object_class_list_properties (klass, &n_property_specs);
for (i = 0; equal && i < n_property_specs; i++)
{
GParamSpec *prop_spec;
GValue a_value = G_VALUE_INIT;
GValue b_value = G_VALUE_INIT;
prop_spec = property_specs[i];
if (! (prop_spec->flags & G_PARAM_READABLE))
continue;
g_value_init (&a_value, prop_spec->value_type);
g_value_init (&b_value, prop_spec->value_type);
g_object_get_property (G_OBJECT (a), prop_spec->name, &a_value);
g_object_get_property (G_OBJECT (b), prop_spec->name, &b_value);
if (g_param_values_cmp (prop_spec, &a_value, &b_value))
{
if ((prop_spec->flags & GIMP_CONFIG_PARAM_AGGREGATE) &&
G_IS_PARAM_SPEC_OBJECT (prop_spec) &&
g_type_interface_peek (g_type_class_peek (prop_spec->value_type),
GIMP_TYPE_CONFIG))
{
if (! gimp_config_is_equal_to (g_value_get_object (&a_value),
g_value_get_object (&b_value)))
{
equal = FALSE;
}
}
else
{
equal = FALSE;
}
}
g_value_unset (&a_value);
g_value_unset (&b_value);
}
g_free (property_specs);
return equal;
}
static void
delegate_notify (GObject *object,
GParamSpec *pspec,
gpointer data)
{
gpointer iface;
iface = g_type_interface_peek (g_type_class_peek (G_OBJECT_TYPE (object)),
gtk_file_chooser_get_type ());
if (g_object_interface_find_property (iface, pspec->name))
g_object_notify (data, pspec->name);
}
/**
* ges_extractable_get_real_extractable_type:
* @type: The #GType implementing #GESExtractable
* @id: The ID to check
*
* Get the #GType that should be used as extractable_type for @type and
* @id. Usually this will be the same as @type but in some cases they can
* be some subclasses of @type. For example, in the case of #GESFormatter,
* the returned #GType will be a subclass of #GESFormatter that can be used
* to load the file pointed by @id.
*
* Returns: Return the #GESExtractable type that should be used for @id
*/
GType
ges_extractable_get_real_extractable_type_for_id (GType type, const gchar * id)
{
GType ret;
GObjectClass *klass;
GESExtractableInterface *iface;
klass = g_type_class_ref (type);
iface = g_type_interface_peek (klass, GES_TYPE_EXTRACTABLE);
g_type_class_unref (klass);
ret = iface->get_real_extractable_type (type, id);
GST_DEBUG ("Extractable type for id %s and wanted type %s is: %s",
id, g_type_name (type), g_type_name (ret));
return ret;
}
/**
* ges_extractable_type_check_id:
* @type: The #GType implementing #GESExtractable
* @id: The ID to check
*
* Check if @id is valid for @type
*
* Returns: (transfer full) (nullable): A newly allocated string containing
* the actual ID (after some processing) or %NULL if the ID is wrong.
*/
gchar *
ges_extractable_type_check_id (GType type, const gchar * id, GError ** error)
{
GObjectClass *klass;
GESExtractableInterface *iface;
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
g_return_val_if_fail (g_type_is_a (type, G_TYPE_OBJECT), NULL);
g_return_val_if_fail (g_type_is_a (type, GES_TYPE_EXTRACTABLE), NULL);
klass = g_type_class_ref (type);
iface = g_type_interface_peek (klass, GES_TYPE_EXTRACTABLE);
g_type_class_unref (klass);
return iface->check_id (type, id, error);
}
/**
* ges_extractable_type_get_asset_type:
* @type: The #GType implementing #GESExtractable
*
* Get the #GType, subclass of #GES_TYPE_ASSET to instanciate
* to be able to extract a @type
*
* Returns: the #GType to use to create a asset to extract @type
*/
GType
ges_extractable_type_get_asset_type (GType type)
{
GObjectClass *klass;
GESExtractableInterface *iface;
g_return_val_if_fail (g_type_is_a (type, G_TYPE_OBJECT), G_TYPE_INVALID);
g_return_val_if_fail (g_type_is_a (type, GES_TYPE_EXTRACTABLE),
G_TYPE_INVALID);
klass = g_type_class_ref (type);
iface = g_type_interface_peek (klass, GES_TYPE_EXTRACTABLE);
g_type_class_unref (klass);
return iface->asset_type;
}
/**
* ges_extractable_register_metas:
* @self: A #GESExtractable
* @asset: The #GESAsset on which metadatas should be registered
*
* Lets you register standard method for @extractable_type on @asset
*
* Returns: %TRUE if metas could be register %FALSE otherwize
*/
gboolean
ges_extractable_register_metas (GType extractable_type, GESAsset * asset)
{
GObjectClass *klass;
gboolean ret = FALSE;
GESExtractableInterface *iface;
g_return_val_if_fail (g_type_is_a (extractable_type, GES_TYPE_EXTRACTABLE),
FALSE);
klass = g_type_class_ref (extractable_type);
iface = g_type_interface_peek (klass, GES_TYPE_EXTRACTABLE);
if (iface->register_metas)
ret = iface->register_metas (iface, klass, asset);
g_type_class_unref (klass);
return ret;
}
/**
* ges_extractable_type_get_parameters_for_id:
* @type: The #GType implementing #GESExtractable
* @id: The ID of the Extractable
* @n_params: (out): Return location for the returned array
*
* Returns: (transfer full) (array length=n_params): an array of #GParameter
* needed to extract the #GESExtractable from a #GESAsset of @id
*/
GParameter *
ges_extractable_type_get_parameters_from_id (GType type, const gchar * id,
guint * n_params)
{
GObjectClass *klass;
GESExtractableInterface *iface;
GParameter *ret = NULL;
g_return_val_if_fail (g_type_is_a (type, G_TYPE_OBJECT), NULL);
g_return_val_if_fail (g_type_is_a (type, GES_TYPE_EXTRACTABLE), NULL);
klass = g_type_class_ref (type);
iface = g_type_interface_peek (klass, GES_TYPE_EXTRACTABLE);
ret = iface->get_parameters_from_id (id, n_params);
g_type_class_unref (klass);
return ret;
}
static GObjectClass *
rbclt_container_get_container_class (VALUE rclass)
{
GObjectClass *ret = NULL;
const RGObjClassInfo *cinfo = CLASS2CINFO (rclass);
if (G_TYPE_IS_CLASSED (cinfo->gtype))
{
gpointer cptr = g_type_class_ref (cinfo->gtype);
if (g_type_interface_peek (cptr, CLUTTER_TYPE_CONTAINER))
ret = cptr;
else
g_type_class_unref (cptr);
}
if (ret == NULL)
rb_raise (rb_eArgError, "expected class including Clutter::Container");
return ret;
}
static PyObject *
_wrap_TestInterface__do_iface_method(PyObject *cls, PyObject *args, PyObject *kwargs)
{
TestInterfaceIface *iface;
static char *kwlist[] = { "self", NULL };
PyGObject *self;
if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O!:TestInterface.iface_method", kwlist, &PyTestInterface_Type, &self))
return NULL;
iface = g_type_interface_peek(g_type_class_peek(pyg_type_from_object(cls)),
TEST_TYPE_INTERFACE);
if (iface->iface_method)
iface->iface_method(TEST_INTERFACE(self->obj));
else {
PyErr_SetString(PyExc_NotImplementedError,
"interface method TestInterface.iface_method not implemented");
return NULL;
}
Py_INCREF(Py_None);
return Py_None;
}
/**
* gcr_importer_create_for_parsed:
* @parsed: a parser with a parsed item to import
*
* Create a set of importers which can import this parsed item.
* The parsed item is represented by the state of the GcrParser at the
* time of calling this method.
*
* Returns: (element-type Gcr.Importer) (transfer full): a list of importers
* which can import the parsed item, which should be freed with
* g_object_unref(), or %NULL if no types of importers can be created
*/
GList *
gcr_importer_create_for_parsed (GcrParsed *parsed)
{
GcrRegistered *registered;
GcrImporterIface *iface;
gpointer instance_class;
GckAttributes *attrs;
gboolean matched;
gulong n_attrs;
GList *results = NULL;
GHashTable *seen;
gulong j;
gsize i;
g_return_val_if_fail (parsed != NULL, NULL);
gcr_importer_register_well_known ();
if (!registered_importers)
return NULL;
if (!registered_sorted) {
g_array_sort (registered_importers, sort_registered_by_n_attrs);
registered_sorted = TRUE;
}
attrs = gcr_parsed_get_attributes (parsed);
if (attrs != NULL)
gck_attributes_ref (attrs);
else
attrs = gck_attributes_new_empty (GCK_INVALID);
seen = g_hash_table_new (g_direct_hash, g_direct_equal);
if (_gcr_debugging) {
gchar *a = gck_attributes_to_string (attrs);
_gcr_debug ("looking for importer for: %s", a);
g_free (a);
}
for (i = 0; i < registered_importers->len; ++i) {
registered = &(g_array_index (registered_importers, GcrRegistered, i));
n_attrs = gck_attributes_count (registered->attrs);
matched = TRUE;
for (j = 0; j < n_attrs; ++j) {
if (!gck_attributes_contains (attrs, gck_attributes_at (registered->attrs, j))) {
matched = FALSE;
break;
}
}
if (_gcr_debugging) {
gchar *a = gck_attributes_to_string (registered->attrs);
_gcr_debug ("importer %s %s: %s", g_type_name (registered->importer_type),
matched ? "matched" : "didn't match", a);
g_free (a);
}
if (matched) {
if (check_if_seen_or_add (seen, GUINT_TO_POINTER (registered->importer_type)))
continue;
instance_class = g_type_class_ref (registered->importer_type);
iface = g_type_interface_peek (instance_class, GCR_TYPE_IMPORTER);
g_return_val_if_fail (iface != NULL, NULL);
g_return_val_if_fail (iface->create_for_parsed, NULL);
results = g_list_concat (results, (iface->create_for_parsed) (parsed));
g_type_class_unref (instance_class);
}
}
g_hash_table_unref (seen);
gck_attributes_unref (attrs);
return results;
}
/**
* gst_element_register:
* @plugin: (allow-none): #GstPlugin to register the element with, or NULL for
* a static element (note that passing NULL only works in GStreamer 0.10.13
* and later)
* @name: name of elements of this type
* @rank: rank of element (higher rank means more importance when autoplugging)
* @type: GType of element to register
*
* Create a new elementfactory capable of instantiating objects of the
* @type and add the factory to @plugin.
*
* Returns: TRUE, if the registering succeeded, FALSE on error
*/
gboolean
gst_element_register (GstPlugin * plugin, const gchar * name, guint rank,
GType type)
{
GstPluginFeature *existing_feature;
GstRegistry *registry;
GstElementFactory *factory;
GType *interfaces;
guint n_interfaces, i;
GstElementClass *klass;
GList *item;
g_return_val_if_fail (name != NULL, FALSE);
g_return_val_if_fail (g_type_is_a (type, GST_TYPE_ELEMENT), FALSE);
registry = gst_registry_get_default ();
/* check if feature already exists, if it exists there is no need to update it
* when the registry is getting updated, outdated plugins and all their
* features are removed and readded.
*/
existing_feature = gst_registry_lookup_feature (registry, name);
if (existing_feature) {
GST_DEBUG_OBJECT (registry, "update existing feature %p (%s)",
existing_feature, name);
factory = GST_ELEMENT_FACTORY_CAST (existing_feature);
factory->type = type;
existing_feature->loaded = TRUE;
g_type_set_qdata (type, _gst_elementclass_factory, factory);
gst_object_unref (existing_feature);
return TRUE;
}
factory =
GST_ELEMENT_FACTORY_CAST (g_object_newv (GST_TYPE_ELEMENT_FACTORY, 0,
NULL));
gst_plugin_feature_set_name (GST_PLUGIN_FEATURE_CAST (factory), name);
GST_LOG_OBJECT (factory, "Created new elementfactory for type %s",
g_type_name (type));
/* provide info needed during class structure setup */
g_type_set_qdata (type, _gst_elementclass_factory, factory);
klass = GST_ELEMENT_CLASS (g_type_class_ref (type));
if ((klass->details.longname == NULL) ||
(klass->details.klass == NULL) || (klass->details.author == NULL))
goto detailserror;
factory->type = type;
__gst_element_details_copy (&factory->details, &klass->details);
if (klass->meta_data) {
factory->meta_data = gst_structure_copy ((GstStructure *) klass->meta_data);
} else {
factory->meta_data = NULL;
}
for (item = klass->padtemplates; item; item = item->next) {
GstPadTemplate *templ = item->data;
GstStaticPadTemplate *newt;
gchar *caps_string = gst_caps_to_string (templ->caps);
newt = g_slice_new (GstStaticPadTemplate);
newt->name_template = g_intern_string (templ->name_template);
newt->direction = templ->direction;
newt->presence = templ->presence;
newt->static_caps.caps.refcount = 0;
newt->static_caps.string = g_intern_string (caps_string);
factory->staticpadtemplates =
g_list_append (factory->staticpadtemplates, newt);
g_free (caps_string);
}
factory->numpadtemplates = klass->numpadtemplates;
/* special stuff for URI handling */
if (g_type_is_a (type, GST_TYPE_URI_HANDLER)) {
GstURIHandlerInterface *iface = (GstURIHandlerInterface *)
g_type_interface_peek (klass, GST_TYPE_URI_HANDLER);
if (!iface || (!iface->get_type && !iface->get_type_full) ||
(!iface->get_protocols && !iface->get_protocols_full))
goto urierror;
if (iface->get_type)
factory->uri_type = iface->get_type ();
else if (iface->get_type_full)
factory->uri_type = iface->get_type_full (factory->type);
if (!GST_URI_TYPE_IS_VALID (factory->uri_type))
goto urierror;
if (iface->get_protocols)
factory->uri_protocols = g_strdupv (iface->get_protocols ());
else if (iface->get_protocols_full)
factory->uri_protocols = iface->get_protocols_full (factory->type);
if (!factory->uri_protocols)
goto urierror;
}
interfaces = g_type_interfaces (type, &n_interfaces);
for (i = 0; i < n_interfaces; i++) {
__gst_element_factory_add_interface (factory, g_type_name (interfaces[i]));
}
g_free (interfaces);
if (plugin && plugin->desc.name) {
GST_PLUGIN_FEATURE_CAST (factory)->plugin_name = plugin->desc.name;
GST_PLUGIN_FEATURE_CAST (factory)->plugin = plugin;
g_object_add_weak_pointer ((GObject *) plugin,
(gpointer *) & GST_PLUGIN_FEATURE_CAST (factory)->plugin);
} else {
GST_PLUGIN_FEATURE_CAST (factory)->plugin_name = "NULL";
GST_PLUGIN_FEATURE_CAST (factory)->plugin = NULL;
}
gst_plugin_feature_set_rank (GST_PLUGIN_FEATURE_CAST (factory), rank);
GST_PLUGIN_FEATURE_CAST (factory)->loaded = TRUE;
gst_registry_add_feature (registry, GST_PLUGIN_FEATURE_CAST (factory));
return TRUE;
/* ERRORS */
urierror:
{
GST_WARNING_OBJECT (factory, "error with uri handler!");
gst_element_factory_cleanup (factory);
return FALSE;
}
detailserror:
{
GST_WARNING_OBJECT (factory,
"The GstElementDetails don't seem to have been set properly");
gst_element_factory_cleanup (factory);
return FALSE;
}
}
/**
* gimp_config_deserialize_property:
* @config: a #GimpConfig.
* @scanner: a #GScanner.
* @nest_level: the nest level
*
* This function deserializes a single property of @config. You
* shouldn't need to call this function directly. If possible, use
* gimp_config_deserialize_properties() instead.
*
* Return value: %G_TOKEN_RIGHT_PAREN on success, otherwise the
* expected #GTokenType or %G_TOKEN_NONE if the expected token was
* found but couldn't be parsed.
*
* Since: GIMP 2.4
**/
GTokenType
gimp_config_deserialize_property (GimpConfig *config,
GScanner *scanner,
gint nest_level)
{
GimpConfigInterface *config_iface = NULL;
GimpConfigInterface *parent_iface = NULL;
GParamSpec *prop_spec;
GTokenType token = G_TOKEN_RIGHT_PAREN;
GValue value = { 0, };
guint old_scope_id;
old_scope_id = g_scanner_set_scope (scanner, 0);
prop_spec = G_PARAM_SPEC (scanner->value.v_symbol);
g_value_init (&value, prop_spec->value_type);
if (G_TYPE_IS_OBJECT (prop_spec->owner_type))
{
GTypeClass *owner_class = g_type_class_peek (prop_spec->owner_type);
config_iface = g_type_interface_peek (owner_class, GIMP_TYPE_CONFIG);
/* We must call deserialize_property() *only* if the *exact* class
* which implements it is param_spec->owner_type's class.
*
* Therefore, we ask param_spec->owner_type's immediate parent class
* for it's GimpConfigInterface and check if we get a different
* pointer.
*
* (if the pointers are the same, param_spec->owner_type's
* GimpConfigInterface is inherited from one of it's parent classes
* and thus not able to handle param_spec->owner_type's properties).
*/
if (config_iface)
{
GTypeClass *owner_parent_class;
owner_parent_class = g_type_class_peek_parent (owner_class);
parent_iface = g_type_interface_peek (owner_parent_class,
GIMP_TYPE_CONFIG);
}
}
if (config_iface &&
config_iface != parent_iface && /* see comment above */
config_iface->deserialize_property &&
config_iface->deserialize_property (config,
prop_spec->param_id,
&value,
prop_spec,
scanner,
&token))
{
/* nop */
}
else
{
if (G_VALUE_HOLDS_OBJECT (&value))
token = gimp_config_deserialize_object (&value,
config, prop_spec,
scanner, nest_level);
else
token = gimp_config_deserialize_value (&value,
config, prop_spec, scanner);
}
if (token == G_TOKEN_RIGHT_PAREN &&
g_scanner_peek_next_token (scanner) == token)
{
if (! (G_VALUE_HOLDS_OBJECT (&value) &&
(prop_spec->flags & GIMP_CONFIG_PARAM_AGGREGATE)))
g_object_set_property (G_OBJECT (config), prop_spec->name, &value);
}
#ifdef CONFIG_DEBUG
else
{
g_warning ("%s: couldn't deserialize property %s::%s of type %s",
G_STRFUNC,
g_type_name (G_TYPE_FROM_INSTANCE (config)),
prop_spec->name,
g_type_name (prop_spec->value_type));
}
#endif
g_value_unset (&value);
g_scanner_set_scope (scanner, old_scope_id);
return token;
}
g_type_add_interface_static (freezable_spin_button_type,
GTK_TYPE_EDITABLE, &editable_interface_info);
}
return freezable_spin_button_type;
}
static void
gtk_freezable_spin_button_class_init (GtkFreezableSpinButtonClass *class)
{
GTK_SPIN_BUTTON_CLASS (class)->change_value
= gtk_freezable_spin_button_change_value;
parent_class = g_type_class_peek_parent (class);
parent_editable_interface = g_type_interface_peek (parent_class,
GTK_TYPE_EDITABLE);
input_signal_id = g_signal_lookup ("input", GTK_TYPE_SPIN_BUTTON);
}
static void
gtk_freezable_spin_button_editable_interface_init (GtkEditableClass *interface)
{
interface->changed = gtk_freezable_spin_button_changed;
}
static void
gtk_freezable_spin_button_init (GtkFreezableSpinButton *spin_button)
{
