/** * gst_child_proxy_set_valist: * @object: the parent object * @first_property_name: name of the first property to set * @var_args: value for the first property, followed optionally by more name/value pairs, followed by NULL * * Sets properties of the parent object and its children. */ void gst_child_proxy_set_valist (GstChildProxy * object, const gchar * first_property_name, va_list var_args) { const gchar *name; gchar *error = NULL; GValue value = { 0, }; GParamSpec *pspec; GObject *target; g_return_if_fail (GST_IS_CHILD_PROXY (object)); name = first_property_name; /* iterate over pairs */ while (name) { if (!gst_child_proxy_lookup (object, name, &target, &pspec)) goto not_found; G_VALUE_COLLECT_INIT (&value, pspec->value_type, var_args, G_VALUE_NOCOPY_CONTENTS, &error); if (error) goto cant_copy; g_object_set_property (target, pspec->name, &value); g_object_unref (target); g_value_unset (&value); name = va_arg (var_args, gchar *); } return; not_found: { g_warning ("no property %s in object %s", name, (GST_IS_OBJECT (object) ? GST_OBJECT_NAME (object) : "")); return; } cant_copy: { g_warning ("error copying value %s in object %s: %s", pspec->name, (GST_IS_OBJECT (object) ? GST_OBJECT_NAME (object) : ""), error); g_value_unset (&value); g_object_unref (target); return; } }
/** * gst_tracer_record_new: * @name: name of new record, must end on ".class". * @firstfield: name of first field to set * @...: additional arguments * * Create a new tracer record. The record instance can be used to efficiently * log entries using gst_tracer_record_log(). * * The @name without the ".class" suffix will be used for the log records. * There must be fields for each value that gets logged where the field name is * the value name. The field must be a #GstStructure describing the value. The * sub structure must contain a field called 'type' of %G_TYPE_GTYPE that * contains the GType of the value. The resulting #GstTracerRecord will take * ownership of the field structures. * * The way to deal with optional values is to log an additional boolean before * the optional field, that if %TRUE signals that the optional field is valid * and %FALSE signals that the optional field should be ignored. One must still * log a placeholder value for the optional field though. Please also note, that * pointer type values must not be NULL - the underlying serialisation can not * handle that right now. * * > Please note that this is still under discussion and subject to change. * * Returns: (transfer full): a new #GstTracerRecord */ GstTracerRecord * gst_tracer_record_new (const gchar * name, const gchar * firstfield, ...) { GstTracerRecord *self; GstStructure *structure; va_list varargs; gchar *err = NULL; GType type; GQuark id; va_start (varargs, firstfield); structure = gst_structure_new_empty (name); while (firstfield) { GValue val = { 0, }; id = g_quark_from_string (firstfield); type = va_arg (varargs, GType); /* all fields passed here must be GstStructures which we take over */ if (type != GST_TYPE_STRUCTURE) { GST_WARNING ("expected field of type GstStructure, but %s is %s", firstfield, g_type_name (type)); } G_VALUE_COLLECT_INIT (&val, type, varargs, G_VALUE_NOCOPY_CONTENTS, &err); if (G_UNLIKELY (err)) { g_critical ("%s", err); break; } /* see boxed_proxy_collect_value */ val.data[1].v_uint &= ~G_VALUE_NOCOPY_CONTENTS; gst_structure_id_take_value (structure, id, &val); firstfield = va_arg (varargs, gchar *); } va_end (varargs); self = g_object_new (GST_TYPE_TRACER_RECORD, NULL); /* Clear floating flag */ gst_object_ref_sink (self); self->spec = structure; gst_tracer_record_build_format (self); return self; }
/** * clutter_container_child_set: * @container: a #ClutterContainer * @actor: a #ClutterActor that is a child of @container. * @first_prop: name of the first property to be set. * @...: value for the first property, followed optionally by more name/value * pairs terminated with NULL. * * Sets container specific properties on the child of a container. * * Since: 0.8 */ void clutter_container_child_set (ClutterContainer *container, ClutterActor *actor, const gchar *first_prop, ...) { GObjectClass *klass; const gchar *name; va_list var_args; g_return_if_fail (CLUTTER_IS_CONTAINER (container)); g_return_if_fail (CLUTTER_IS_ACTOR (actor)); klass = G_OBJECT_GET_CLASS (container); va_start (var_args, first_prop); name = first_prop; while (name) { GValue value = G_VALUE_INIT; gchar *error = NULL; GParamSpec *pspec; pspec = clutter_container_class_find_child_property (klass, name); if (!pspec) { g_warning ("%s: Containers of type '%s' have no child " "property named '%s'", G_STRLOC, G_OBJECT_TYPE_NAME (container), name); break; } if (!(pspec->flags & G_PARAM_WRITABLE)) { g_warning ("%s: Child property '%s' of the container '%s' " "is not writable", G_STRLOC, pspec->name, G_OBJECT_TYPE_NAME (container)); break; } G_VALUE_COLLECT_INIT (&value, G_PARAM_SPEC_VALUE_TYPE (pspec), var_args, 0, &error); if (error) { /* we intentionally leak the GValue because it might * be in an undefined state and calling g_value_unset() * on it might crash */ g_warning ("%s: %s", G_STRLOC, error); free (error); break; } container_set_child_property (container, actor, &value, pspec); g_value_unset (&value); name = va_arg (var_args, gchar*); } va_end (var_args); }
gboolean _valist_to_parameter_list (GType the_type, gpointer type_struct, const gchar *first_property_name, va_list args, GParameter **params, guint *n_params) { const gchar *name; guint n_allocated_params; g_return_val_if_fail (type_struct != NULL, FALSE); *n_params = 0; n_allocated_params = 16; *params = g_new0 (GParameter, n_allocated_params); name = first_property_name; while (name) { gchar *error_msg = NULL; GParamSpec *pspec = _g_type_struct_find_property (the_type, type_struct, name); if (!pspec) { g_warning ("%s: type '%s' has no property named '%s'", G_STRFUNC, g_type_name (the_type), name); goto error; } if (*n_params >= n_allocated_params) { n_allocated_params += 16; *params = g_renew (GParameter, *params, n_allocated_params); memset (*params + sizeof (GParameter) * (n_allocated_params - 16), 0, sizeof (GParameter) * 16); } (*params)[*n_params].name = name; G_VALUE_COLLECT_INIT (&(*params)[*n_params].value, pspec->value_type, args, 0, &error_msg); (*n_params)++; if (error_msg) { g_warning ("%s: %s", G_STRFUNC, error_msg); g_free (error_msg); goto error; } name = va_arg (args, gchar*); } return TRUE; error: for (; *n_params > 0; --(*n_params)) g_value_unset (&(*params)[*n_params].value); g_free (*params); return FALSE; }
static inline void clutter_box_set_property_valist (ClutterBox *box, ClutterActor *actor, const gchar *first_property, va_list var_args) { ClutterContainer *container = CLUTTER_CONTAINER (box); ClutterBoxPrivate *priv = box->priv; ClutterLayoutMeta *meta; GObjectClass *klass; const gchar *pname; if (priv->manager == NULL) return; meta = clutter_layout_manager_get_child_meta (priv->manager, container, actor); if (meta == NULL) return; klass = G_OBJECT_GET_CLASS (meta); pname = first_property; while (pname) { GValue value = { 0, }; GParamSpec *pspec; gchar *error; pspec = g_object_class_find_property (klass, pname); if (pspec == NULL) { g_warning ("%s: the layout property '%s' for managers " "of type '%s' (meta type '%s') does not exist", G_STRLOC, pname, G_OBJECT_TYPE_NAME (priv->manager), G_OBJECT_TYPE_NAME (meta)); break; } if (!(pspec->flags & G_PARAM_WRITABLE)) { g_warning ("%s: the layout property '%s' for managers " "of type '%s' (meta type '%s') is not writable", G_STRLOC, pspec->name, G_OBJECT_TYPE_NAME (priv->manager), G_OBJECT_TYPE_NAME (meta)); break; } G_VALUE_COLLECT_INIT (&value, G_PARAM_SPEC_VALUE_TYPE (pspec), var_args, 0, &error); if (error) { g_warning ("%s: %s", G_STRLOC, error); g_free (error); break; } clutter_layout_manager_child_set_property (priv->manager, container, actor, pspec->name, &value); g_value_unset (&value); pname = va_arg (var_args, gchar*); } }
/** * clutter_layout_manager_child_set: * @manager: a #ClutterLayoutManager * @container: a #ClutterContainer using @manager * @actor: a #ClutterActor child of @container * @first_property: the first property name * @Varargs: a list of property name and value pairs * * Sets a list of properties and their values on the #ClutterLayoutMeta * associated by @manager to a child of @container * * Languages bindings should use clutter_layout_manager_child_set_property() * instead * * Since: 1.2 */ void clutter_layout_manager_child_set (ClutterLayoutManager *manager, ClutterContainer *container, ClutterActor *actor, const gchar *first_property, ...) { ClutterLayoutMeta *meta; GObjectClass *klass; const gchar *pname; va_list var_args; g_return_if_fail (CLUTTER_IS_LAYOUT_MANAGER (manager)); g_return_if_fail (CLUTTER_IS_CONTAINER (container)); g_return_if_fail (CLUTTER_IS_ACTOR (actor)); g_return_if_fail (first_property != NULL); meta = get_child_meta (manager, container, actor); if (meta == NULL) { g_warning ("Layout managers of type '%s' do not support " "layout metadata", g_type_name (G_OBJECT_TYPE (manager))); return; } klass = G_OBJECT_GET_CLASS (meta); va_start (var_args, first_property); pname = first_property; while (pname) { GValue value = { 0, }; GParamSpec *pspec; gchar *error; gboolean res; pspec = g_object_class_find_property (klass, pname); if (pspec == NULL) { g_warning ("%s: Layout managers of type '%s' have no layout " "property named '%s'", G_STRLOC, G_OBJECT_TYPE_NAME (manager), pname); break; } G_VALUE_COLLECT_INIT (&value, G_PARAM_SPEC_VALUE_TYPE (pspec), var_args, 0, &error); if (error) { g_warning ("%s: %s", G_STRLOC, error); g_free (error); break; } res = layout_set_property_internal (manager, G_OBJECT (meta), pspec, &value); g_value_unset (&value); if (!res) break; pname = va_arg (var_args, gchar*); } va_end (var_args); }
gboolean peas_utils_valist_to_parameter_list (GType iface_type, const gchar *first_property, va_list args, GParameter **params, guint *n_params) { GPtrArray *type_structs; const gchar *name; guint n_allocated_params; g_return_val_if_fail (G_TYPE_IS_INTERFACE (iface_type), FALSE); type_structs = g_ptr_array_new (); g_ptr_array_set_free_func (type_structs, (GDestroyNotify) g_type_default_interface_unref); add_all_interfaces (iface_type, type_structs); *n_params = 0; n_allocated_params = 16; *params = g_new0 (GParameter, n_allocated_params); name = first_property; while (name) { gchar *error_msg = NULL; GParamSpec *pspec = find_param_spec_in_interfaces (type_structs, name); if (!pspec) { g_warning ("%s: type '%s' has no property named '%s'", G_STRFUNC, g_type_name (iface_type), name); goto error; } if (*n_params >= n_allocated_params) { n_allocated_params += 16; *params = g_renew (GParameter, *params, n_allocated_params); memset (*params + (n_allocated_params - 16), 0, sizeof (GParameter) * 16); } (*params)[*n_params].name = name; G_VALUE_COLLECT_INIT (&(*params)[*n_params].value, pspec->value_type, args, 0, &error_msg); (*n_params)++; if (error_msg) { g_warning ("%s: %s", G_STRFUNC, error_msg); g_free (error_msg); goto error; } name = va_arg (args, gchar*); } g_ptr_array_unref (type_structs); return TRUE; error: for (; *n_params > 0; --(*n_params)) g_value_unset (&(*params)[*n_params].value); g_free (*params); g_ptr_array_unref (type_structs); return FALSE; }