/** * 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) {