自学教程：C++ G_PARAM_SPEC_VALUE_TYPE函数代码示例

/* void setAttribute (in nsIAtom name, in AString newValue); */NS_IMETHODIMPxgGtkElement::SetAttribute (nsIAtom *name, const nsAString &newValue){    GOM_ASTRING_TO_GSTRING_RETURN (value, newValue, NS_ERROR_INVALID_ARG);    GParamSpec *spec;    guint signal_id;    if (!Resolve (name, &spec, &signal_id)) {	return NS_ERROR_FAILURE;    }    if (!spec) {	return NS_ERROR_FAILURE;    }    GError *error = NULL;    GValue gval = { 0 };    if (G_TYPE_FUNDAMENTAL (G_PARAM_SPEC_VALUE_TYPE (spec)) == G_TYPE_OBJECT) {	g_warning (GOM_LOC ("Attribute %s.%s is a %s, which a string cannot be converted to"),		   G_OBJECT_TYPE_NAME (mObject), spec->name,		   g_type_name (G_PARAM_SPEC_VALUE_TYPE (spec)));	return NS_ERROR_FAILURE;    } else if (gtk_builder_value_from_string (NULL, spec, value, &gval, &error)) {	g_object_set_property (mObject, spec->name, &gval);	g_value_unset (&gval);    } else {	g_warning (GOM_LOC ("Could not get value from string: '%s'"), value);	return NS_ERROR_FAILURE;    }    return NS_OK;}

static voide_bind_properties_transfer (GObject *src_object,                            GParamSpec *src_pspec,                            GObject *dst_object,                            GParamSpec *dst_pspec,                            GlideBindingTransform  transform,                            gpointer user_data){	const gchar *src_name;	const gchar *dst_name;	gboolean result;	GValue src_value = { 0, };	GValue dst_value = { 0, };	src_name = g_param_spec_get_name (src_pspec);	dst_name = g_param_spec_get_name (dst_pspec);	g_value_init (&src_value, G_PARAM_SPEC_VALUE_TYPE (src_pspec));	g_object_get_property (src_object, src_name, &src_value);	g_value_init (&dst_value, G_PARAM_SPEC_VALUE_TYPE (dst_pspec));	result = (*transform) (&src_value, &dst_value, user_data);	g_value_unset (&src_value);	g_return_if_fail (result);	g_param_value_validate (dst_pspec, &dst_value);	g_object_set_property (dst_object, dst_name, &dst_value);	g_value_unset (&dst_value);}

static VALUErg_set_child_property(VALUE self, VALUE child,                                      VALUE prop_name, VALUE val){    GParamSpec* pspec;    const char* name;    if (SYMBOL_P(prop_name)) {        name = rb_id2name(SYM2ID(prop_name));    } else {        StringValue(prop_name);        name = StringValuePtr(prop_name);    }    pspec = goo_canvas_item_class_find_child_property(G_OBJECT_GET_CLASS(RVAL2GOBJ(self)), name);    if (!pspec)        rb_raise(rb_eRuntimeError, "No such child property: %s", name);#define _SET_PROP_FOR_TYPE(gtype, ctype, val) /    case gtype: /        goo_canvas_item_set_child_properties(SELF(self), SELF(child), name, (ctype)(val), NULL); /        break;    switch (G_TYPE_FUNDAMENTAL(G_PARAM_SPEC_VALUE_TYPE(pspec))) {        _SET_PROP_FOR_TYPE(G_TYPE_CHAR, gchar, NUM2INT(val));        _SET_PROP_FOR_TYPE(G_TYPE_UCHAR, guchar, NUM2INT(val));        _SET_PROP_FOR_TYPE(G_TYPE_BOOLEAN, gboolean, RTEST(val));        _SET_PROP_FOR_TYPE(G_TYPE_INT, gint, NUM2INT(val));        _SET_PROP_FOR_TYPE(G_TYPE_UINT, guint, NUM2UINT(val));        _SET_PROP_FOR_TYPE(G_TYPE_LONG, glong, NUM2LONG(val));        _SET_PROP_FOR_TYPE(G_TYPE_ULONG, gulong, NUM2ULONG(val));        _SET_PROP_FOR_TYPE(G_TYPE_INT64, gint64, rbglib_num_to_int64(val));        _SET_PROP_FOR_TYPE(G_TYPE_UINT64, guint64, rbglib_num_to_uint64(val));        _SET_PROP_FOR_TYPE(G_TYPE_ENUM, gint, rbgobj_get_enum(val, G_PARAM_SPEC_VALUE_TYPE(pspec)));        _SET_PROP_FOR_TYPE(G_TYPE_FLAGS, guint, rbgobj_get_flags(val, G_PARAM_SPEC_VALUE_TYPE(pspec)));        _SET_PROP_FOR_TYPE(G_TYPE_FLOAT, gfloat, NUM2DBL(val));        _SET_PROP_FOR_TYPE(G_TYPE_DOUBLE, gdouble, NUM2DBL(val));      case G_TYPE_STRING:        {            if (SYMBOL_P(val))                val = rb_funcall(val, rb_intern("to_s"), 0);            goo_canvas_item_set_child_properties(SELF(self), SELF(child), name, StringValuePtr(val), NULL);            break;        }      default:        g_warning("rb_goo_canvas_item_set_child_property: unsupported type: %s/n", g_type_name(G_PARAM_SPEC_VALUE_TYPE(pspec)));        return Qnil;    }#undef _SET_PROP_FOR_TYPE    G_CHILD_ADD(child, val);    return self;}

static voidset_sysfs_uint (const char *iface,                GObject *obj,                const char *obj_prop,                const char *dir,                const char *sysfs_prop,                gboolean default_if_zero,                gboolean user_hz_compensate){	char *path, *s;	GParamSpec *pspec;	GValue val = { 0 };	guint32 uval = 0;	pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (obj), obj_prop);	g_return_if_fail (pspec != NULL);	/* Get the property's value */	g_value_init (&val, G_PARAM_SPEC_VALUE_TYPE (pspec));	g_object_get_property (obj, obj_prop, &val);	if (G_VALUE_HOLDS_BOOLEAN (&val))		uval = g_value_get_boolean (&val) ? 1 : 0;	else if (G_VALUE_HOLDS_UINT (&val)) {		uval = g_value_get_uint (&val);		/* zero means "unspecified" for some NM properties but isn't in the		 * allowed kernel range, so reset the property to the default value.		 */		if (default_if_zero && uval == 0) {			g_value_unset (&val);			g_value_init (&val, G_PARAM_SPEC_VALUE_TYPE (pspec));			g_param_value_set_default (pspec, &val);			uval = g_value_get_uint (&val);		}	} else		g_assert_not_reached ();	g_value_unset (&val);	/* Linux kernel bridge interfaces use 'centiseconds' for time-based values.	 * In reality it's not centiseconds, but depends on HZ and USER_HZ, which	 * is almost always works out to be a multiplier of 100, so we can assume	 * centiseconds.  See clock_t_to_jiffies().	 */	if (user_hz_compensate)		uval *= 100;	path = g_strdup_printf ("/sys/class/net/%s/%s/%s", iface, dir, sysfs_prop);	s = g_strdup_printf ("%u", uval);	/* FIXME: how should failure be handled? */	nm_utils_do_sysctl (path, s);	g_free (path);	g_free (s);}

static inline voidtidy_stylable_set_property_internal (TidyStylable       *stylable,                                     GParamSpec         *pspec,                                     const GValue       *value,                                     GObjectNotifyQueue *nqueue){  GValue tmp_value = { 0, };  g_value_init (&tmp_value, G_PARAM_SPEC_VALUE_TYPE (pspec));  if (!g_value_transform (value, &tmp_value))    g_warning ("unable to set property `%s' of type `%s' from value of type `%s'",               pspec->name,               g_type_name (G_PARAM_SPEC_VALUE_TYPE (pspec)),               G_VALUE_TYPE_NAME (value));  else if (g_param_value_validate (pspec, &tmp_value) &&           !(pspec->flags & G_PARAM_LAX_VALIDATION))    {      gchar *contents = g_strdup_value_contents (value);      g_warning ("value /"%s/" of type `%s' is invalid or out of range for property `%s' of type `%s'",                 contents,                 G_VALUE_TYPE_NAME (value),                 pspec->name,                 g_type_name (G_PARAM_SPEC_VALUE_TYPE (pspec)));      g_free (contents);    }  else    {      TidyStyle *style = tidy_stylable_get_style (stylable);      gchar *real_name;      real_name = g_strconcat (g_param_spec_get_qdata (pspec, quark_real_owner),                               "::",                               pspec->name,                               NULL);      if (!tidy_style_has_property (style, real_name))        tidy_style_add_property (style, real_name,                                 G_PARAM_SPEC_VALUE_TYPE (pspec));      tidy_style_set_property (style, real_name, &tmp_value);      g_object_notify_queue_add (G_OBJECT (stylable), nqueue, pspec);      g_free (real_name);    }  g_value_unset (&tmp_value);}

static GitgDataBinding *gitg_data_binding_create(gpointer source, gchar const *source_property, 						 gpointer dest, gchar const *dest_property, 						 GitgDataBindingConversion source_to_dest,						 GitgDataBindingConversion dest_to_source,						 gpointer userdata,						 GitgDataBindingFlags flags){	g_return_val_if_fail(G_IS_OBJECT(source), NULL);	g_return_val_if_fail(G_IS_OBJECT(dest), NULL);	GObjectClass *sclass = G_OBJECT_GET_CLASS(source);	GObjectClass *dclass = G_OBJECT_GET_CLASS(dest);	GParamSpec *sspec = g_object_class_find_property(sclass, source_property);	if (!sspec)	{		g_warning("No such source property found: %s", source_property);		return NULL;	}	GParamSpec *dspec = g_object_class_find_property(dclass, dest_property);	if (!dspec)	{		g_warning("No such dest property found: %s", dest_property);		return NULL;	}	GitgDataBinding *binding = g_slice_new0(GitgDataBinding);	binding->flags = flags;	binding_fill(&binding->source, source, source_property, G_PARAM_SPEC_VALUE_TYPE(sspec), source_to_dest, userdata);	binding_fill(&binding->dest, dest, dest_property, G_PARAM_SPEC_VALUE_TYPE(dspec), dest_to_source, userdata);	binding_connect(binding, &binding->source);	if (flags & GITG_DATA_BINDING_MUTUAL)		binding_connect(binding, &binding->dest);	g_object_weak_ref(binding->source.object, (GWeakNotify)on_data_binding_destroy, binding);	g_object_weak_ref(binding->dest.object, (GWeakNotify)on_data_binding_destroy, binding);	/* initial value */	on_data_binding_changed(binding->source.object, NULL, binding);	return binding;}

static voidcommit_option (NMDevice *device, NMSetting *setting, const Option *option, gboolean slave){	int ifindex = nm_device_get_ifindex (device);	GParamSpec *pspec;	GValue val = G_VALUE_INIT;	guint32 uval = 0;	gs_free char *value = NULL;	g_assert (setting);	pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (setting), option->name);	g_assert (pspec);	/* Get the property's value */	g_value_init (&val, G_PARAM_SPEC_VALUE_TYPE (pspec));	g_object_get_property ((GObject *) setting, option->name, &val);	if (G_VALUE_HOLDS_BOOLEAN (&val))		uval = g_value_get_boolean (&val) ? 1 : 0;	else if (G_VALUE_HOLDS_UINT (&val)) {		uval = g_value_get_uint (&val);		/* zero means "unspecified" for some NM properties but isn't in the		 * allowed kernel range, so reset the property to the default value.		 */		if (option->default_if_zero && uval == 0) {			g_value_unset (&val);			g_value_init (&val, G_PARAM_SPEC_VALUE_TYPE (pspec));			g_param_value_set_default (pspec, &val);			uval = g_value_get_uint (&val);		}		/* Linux kernel bridge interfaces use 'centiseconds' for time-based values.		 * In reality it's not centiseconds, but depends on HZ and USER_HZ, which		 * is almost always works out to be a multiplier of 100, so we can assume		 * centiseconds.  See clock_t_to_jiffies().		 */		if (option->user_hz_compensate)			uval *= 100;	} else		g_assert_not_reached ();	g_value_unset (&val);	value = g_strdup_printf ("%u", uval);	if (slave)		nm_platform_slave_set_option (ifindex, option->sysname, value);	else		nm_platform_master_set_option (ifindex, option->sysname, value);}

static GstElement *create_payloader_for_caps (const GstCaps * caps){  GList *payloader_list, *filtered_list, *l;  GstElementFactory *payloader_factory = NULL;  GstElement *payloader = NULL;  payloader_list =      gst_element_factory_list_get_elements (GST_ELEMENT_FACTORY_TYPE_PAYLOADER,      GST_RANK_NONE);  filtered_list =      gst_element_factory_list_filter (payloader_list, caps, GST_PAD_SRC,      FALSE);  for (l = filtered_list; l != NULL && payloader_factory == NULL; l = l->next) {    payloader_factory = GST_ELEMENT_FACTORY (l->data);    if (gst_element_factory_get_num_pad_templates (payloader_factory) != 2)      payloader_factory = NULL;  }  if (payloader_factory != NULL) {    payloader = gst_element_factory_create (payloader_factory, NULL);  }  if (payloader) {    GParamSpec *pspec;    pspec =        g_object_class_find_property (G_OBJECT_GET_CLASS (payloader),        "config-interval");    if (pspec != NULL && G_PARAM_SPEC_VALUE_TYPE (pspec) == G_TYPE_UINT) {      g_object_set (payloader, "config-interval", 1, NULL);    }    pspec =        g_object_class_find_property (G_OBJECT_GET_CLASS (payloader),        "picture-id-mode");    if (pspec != NULL && G_TYPE_IS_ENUM (G_PARAM_SPEC_VALUE_TYPE (pspec))) {      /* Set picture id so that remote peer can determine continuity if */      /* there are lost FEC packets and if it has to NACK them */      g_object_set (payloader, "picture-id-mode", PICTURE_ID_15_BIT, NULL);    }  }  gst_plugin_feature_list_free (filtered_list);  gst_plugin_feature_list_free (payloader_list);  return payloader;}

static VALUE_params_setup(VALUE arg, struct param_setup_arg *param_setup_arg){    guint index;    VALUE name, val;    GParamSpec* pspec;    index = param_setup_arg->index;    if (index >= param_setup_arg->param_size)       rb_raise(rb_eArgError, "too many parameters");    name = rb_ary_entry(arg, 0);    val  = rb_ary_entry(arg, 1);    if (SYMBOL_P(name))        param_setup_arg->params[index].name = rb_id2name(SYM2ID(name));    else        param_setup_arg->params[index].name = StringValuePtr(name);    pspec = g_object_class_find_property(        param_setup_arg->gclass,        param_setup_arg->params[index].name);    if (!pspec)        rb_raise(rb_eArgError, "No such property: %s",                 param_setup_arg->params[index].name);    g_value_init(&(param_setup_arg->params[index].value),                 G_PARAM_SPEC_VALUE_TYPE(pspec));    rbgobj_rvalue_to_gvalue(val, &(param_setup_arg->params[index].value));    param_setup_arg->index++;    return Qnil;}

/* Looking for construct-time optional output args. Append them to out. */static void *vo_get_optional_arg( const char *name, PElement *value, Vo *vo, PElement *out ){	GParamSpec *pspec;	VipsArgumentClass *argument_class;	VipsArgumentInstance *argument_instance;	if( vips_object_get_argument( vo->object, name,		&pspec, &argument_class, &argument_instance ) )		return( NULL );	if( !(argument_class->flags & VIPS_ARGUMENT_REQUIRED) &&		(argument_class->flags & VIPS_ARGUMENT_OUTPUT) &&		argument_instance->assigned ) {		GType type = G_PARAM_SPEC_VALUE_TYPE( pspec );		GValue gvalue = { 0 };		PElement lhs;		if( !heap_list_add( vo->rc->heap, out, &lhs ) )			return( value );		g_value_init( &gvalue, type );		g_object_get_property( G_OBJECT( vo->object ), name, &gvalue );		if( !heap_gvalue_to_ip( &gvalue, &lhs ) ) {			g_value_unset( &gvalue );			return( value );		}		g_value_unset( &gvalue );		(void) heap_list_next( out );	}	return( NULL );}

/* Looking for required output args ... append to out. */static void *vo_get_required_output( VipsObject *object, GParamSpec *pspec,        VipsArgumentClass *argument_class, 	VipsArgumentInstance *argument_instance, Vo *vo, PElement *out ){	if( (argument_class->flags & VIPS_ARGUMENT_REQUIRED) &&		(argument_class->flags & VIPS_ARGUMENT_OUTPUT) &&		argument_instance->assigned ) {		const char *name = g_param_spec_get_name( pspec );		GType type = G_PARAM_SPEC_VALUE_TYPE( pspec );		PElement lhs;		GValue value = { 0 };		if( !heap_list_add( vo->rc->heap, out, &lhs ) )			return( object );		g_value_init( &value, type );		g_object_get_property( G_OBJECT( object ), name, &value );		if( !heap_gvalue_to_ip( &value, &lhs ) ) {			g_value_unset( &value );			return( object );		}		g_value_unset( &value );		(void) heap_list_next( out );	}	return( NULL );}

static VALUErg_style_get_property(VALUE self, VALUE prop_name){    GParamSpec* pspec = NULL;    const char* name;    if (SYMBOL_P(prop_name)) {        name = rb_id2name(SYM2ID(prop_name));    } else {        name = RVAL2CSTR(prop_name);    }    pspec = gtk_widget_class_find_style_property((GtkWidgetClass*)g_type_class_ref(RVAL2GTYPE(self)), name);    if (!pspec)        rb_raise(rb_eval_string("GLib::NoPropertyError"), "No such property: %s", name);    else {        // FIXME: use rb_ensure to call g_value_unset()        GValue gval = G_VALUE_INIT;        VALUE ret;        g_value_init(&gval, G_PARAM_SPEC_VALUE_TYPE(pspec));        gtk_widget_style_get_property(GTK_WIDGET(RVAL2GOBJ(self)), name, &gval);        ret = GVAL2RVAL(&gval);        g_value_unset(&gval);        return ret;    }}

/* * gst_controlled_property_new: * @object: for which object the controlled property should be set up * @name: the name of the property to be controlled * * Private method which initializes the fields of a new controlled property * structure. * * Returns: a freshly allocated structure or %NULL */static GstControlledProperty *gst_controlled_property_new (GObject * object, const gchar * name){  GstControlledProperty *prop = NULL;  GParamSpec *pspec;  GST_INFO ("trying to put property '%s' under control", name);  /* check if the object has a property of that name */  if ((pspec =          g_object_class_find_property (G_OBJECT_GET_CLASS (object), name))) {    GST_DEBUG ("  psec->flags : 0x%08x", pspec->flags);    /* check if this param is witable && controlable && !construct-only */    g_return_val_if_fail ((pspec->flags & (G_PARAM_WRITABLE |                GST_PARAM_CONTROLLABLE | G_PARAM_CONSTRUCT_ONLY)) ==        (G_PARAM_WRITABLE | GST_PARAM_CONTROLLABLE), NULL);    if ((prop = g_slice_new (GstControlledProperty))) {      prop->pspec = pspec;      prop->name = pspec->name;      prop->csource = NULL;      prop->disabled = FALSE;      memset (&prop->last_value, 0, sizeof (GValue));      g_value_init (&prop->last_value, G_PARAM_SPEC_VALUE_TYPE (prop->pspec));    }  } else {    GST_WARNING ("class '%s' has no property '%s'", G_OBJECT_TYPE_NAME (object),        name);  }  return prop;}

static voidtidy_stylable_set_valist (TidyStylable *stylable,                          const gchar  *first_property_name,                          va_list       varargs){  GObjectNotifyQueue *nqueue;  const gchar *name;  g_object_ref (stylable);  nqueue = g_object_notify_queue_freeze (G_OBJECT (stylable),                                         &property_notify_context);  name = first_property_name;  while (name)    {      GParamSpec *pspec;      GValue value = { 0, };      gchar *error;      pspec = tidy_stylable_find_property (stylable, name);      if (!pspec)        {          g_warning ("%s: no style property named `%s' found for class `%s'",                     G_STRLOC,                     name,                     g_type_name (G_OBJECT_TYPE (stylable)));          break;        }      if (!(pspec->flags & G_PARAM_WRITABLE) ||          (pspec->flags & G_PARAM_CONSTRUCT_ONLY))        {          g_warning ("Style property `%s' of class `%s' is not writable",                     pspec->name,                     g_type_name (G_OBJECT_TYPE (stylable)));          break;        }      g_value_init (&value, G_PARAM_SPEC_VALUE_TYPE (pspec));      G_VALUE_COLLECT (&value, varargs, 0, &error);      if (error)        {          g_warning ("%s: %s", G_STRLOC, error);          g_free (error);          g_value_unset (&value);          break;        }      tidy_stylable_set_property_internal (stylable, pspec, &value, nqueue);      g_value_unset (&value);      name = va_arg (varargs, gchar*);    }  g_object_notify_queue_thaw (G_OBJECT (stylable), nqueue);  g_object_unref (stylable);}

static voidgobj_mark(gpointer ptr){    GObject* gobj = ptr;    guint n_properties;    GParamSpec** properties;    GValue gval = {0,};    guint i;    properties = g_object_class_list_properties(G_OBJECT_GET_CLASS(gobj), &n_properties);    for (i = 0; i < n_properties; i++) {        GParamSpec* pspec = properties[i];        GType value_type = G_PARAM_SPEC_VALUE_TYPE(pspec);        if (G_TYPE_FUNDAMENTAL(value_type) != G_TYPE_OBJECT) continue;        if (!(pspec->flags & G_PARAM_READABLE)) continue;        /* FIXME: exclude types that doesn't have identity. */        {            g_value_init(&gval, value_type);            g_object_get_property(gobj, pspec->name, &gval);            rbgobj_gc_mark_gvalue(&gval);            g_value_unset(&gval);        }    }    g_free(properties);}

static VALUErbgio_gasyncinitiable_new_async_parameters_initialize(VALUE key_value,                                                      struct rbgio_gasyncinitable_new_async_data *data){        VALUE key, value;        GParamSpec *spec;        if (data->index >= data->n_parameters)                rb_raise(rb_eArgError,                         "too many parameters (%d >= %d)",                         data->index, data->n_parameters);        key = rb_ary_entry(key_value, 0);        value = rb_ary_entry(key_value, 1);        data->parameters[data->index].name = SYMBOL_P(key) ?                rb_id2name(SYM2ID(key)) :                StringValuePtr(key);        spec = g_object_class_find_property(data->gclass,                                            data->parameters[data->index].name);        if (spec == NULL)                rb_raise(rb_eArgError,                         "%s: no such property",                         data->parameters[data->index].name);        g_value_init(&(data->parameters[data->index].value),                     G_PARAM_SPEC_VALUE_TYPE(spec));        rbgobj_rvalue_to_gvalue(value, &(data->parameters[data->index].value));        data->index++;        return Qnil;}

json_t *json_gobject_serialize (GObject *gobject){    json_t *object = json_object();    GParamSpec **pspecs;    guint n_pspecs, i;    pspecs = g_object_class_list_properties (G_OBJECT_GET_CLASS (gobject), &n_pspecs);    for (i=0; i!=n_pspecs; ++i) {        json_t *node;        GParamSpec *pspec = pspecs[i];        GValue value = { 0, };        g_value_init (&value, G_PARAM_SPEC_VALUE_TYPE (pspec));        g_object_get_property(gobject, pspec->name, &value);        node=json_serialize_pspec (&value);        if (node)            json_object_set_new (object, pspec->name, node);        g_value_unset (&value);    }    g_free (pspecs);    return object;}

voidgog_object_set_arg (char const *name, char const *val, GogObject *obj){	GParamSpec *pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (obj), name);	GType prop_type;	GValue res = { 0 };	gboolean success = TRUE;	if (pspec == NULL) {		g_warning ("unknown property `%s' for class `%s'",			   name, G_OBJECT_TYPE_NAME (obj));		return;	}	prop_type = G_PARAM_SPEC_VALUE_TYPE (pspec);	if (val == NULL &&	    G_TYPE_FUNDAMENTAL (prop_type) != G_TYPE_BOOLEAN) {		g_warning ("could not convert NULL to type `%s' for property `%s'",			   g_type_name (prop_type), pspec->name);		return;	}	if (!gsf_xml_gvalue_from_str (&res, prop_type, val))		success = FALSE;	if (!success) {		g_warning ("could not convert string to type `%s' for property `%s'",			   g_type_name (prop_type), pspec->name);	} else		g_object_set_property (G_OBJECT (obj), name, &res);	g_value_unset (&res);}

static void *vips_operation_class_usage_arg( VipsObjectClass *object_class, 	GParamSpec *pspec, VipsArgumentClass *argument_class,	VipsBuf *buf, VipsOperationClassUsage *usage ){	/* Only show construct args ... others are internal.	 */	if( usage->required == 		((argument_class->flags & VIPS_ARGUMENT_REQUIRED) != 0) &&		(argument_class->flags & VIPS_ARGUMENT_CONSTRUCT) &&		!(argument_class->flags & VIPS_ARGUMENT_DEPRECATED) ) { 		if( usage->message && usage->n == 0 ) 			vips_buf_appendf( buf, "%s/n", usage->message );		if( usage->oftype ) {			vips_buf_appendf( buf, "   %-12s - %s, %s %s/n",				g_param_spec_get_name( pspec ), 				g_param_spec_get_blurb( pspec ), 				(argument_class->flags & VIPS_ARGUMENT_INPUT) ?					_( "input" ) : _( "output" ),				g_type_name( 					G_PARAM_SPEC_VALUE_TYPE( pspec ) ) );		}		else {			if( usage->n > 0 )				vips_buf_appends( buf, " " );			vips_buf_appends( buf, g_param_spec_get_name( pspec ) );		}		usage->n += 1;	}	return( NULL );}

voidgegl_operation_context_take_object (GeglOperationContext *context,                                    const gchar          *padname,                                    GObject              *data){  GParamSpec *pspec;  /* FIXME: check that there isn't already an existing   *        output object/value set?   */  pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (G_OBJECT (context->operation)), padname);  if (pspec)    {      GValue value = {0, };      g_value_init (&value, G_PARAM_SPEC_VALUE_TYPE (pspec));      g_value_take_object (&value, data);      gegl_operation_context_set_property (context, padname, &value);      g_value_unset (&value);    }  else    {      g_warning ("%s: No paramspec found for pad '%s' on /"%s/"/n",                 G_STRFUNC,                 padname,                 gegl_operation_get_name (context->operation));    }}

/** * gst_controller_get: * @self: the controller object which handles the properties * @property_name: the name of the property to get * @timestamp: the time the control-change should be read from * * Gets the value for the given controller-handled property at the requested * time. * * Returns: the GValue of the property at the given time, or %NULL if the * property isn't handled by the controller */GValue *gst_controller_get (GstController * self, gchar * property_name,    GstClockTime timestamp){  GstControlledProperty *prop;  GValue *val = NULL;  g_return_val_if_fail (GST_IS_CONTROLLER (self), NULL);  g_return_val_if_fail (property_name, NULL);  g_return_val_if_fail (GST_CLOCK_TIME_IS_VALID (timestamp), NULL);  g_mutex_lock (self->lock);  if ((prop = gst_controller_find_controlled_property (self, property_name))) {    val = g_new0 (GValue, 1);    g_value_init (val, G_PARAM_SPEC_VALUE_TYPE (prop->pspec));    if (prop->csource) {      gboolean res;      /* get current value via control source */      res = gst_control_source_get_value (prop->csource, timestamp, val);      if (!res) {        g_free (val);        val = NULL;      }    } else {      g_object_get_property (self->object, prop->name, val);    }  }  g_mutex_unlock (self->lock);  return val;}

voidgegl_operation_context_set_property (GeglOperationContext *context,                                     const gchar          *property_name,                                     const GValue         *value){  GParamSpec *pspec;  GValue     *storage;  g_return_if_fail (context != NULL);  pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (G_OBJECT (context->operation)), property_name);  if (!pspec)    {      g_warning ("%s: node %s has no pad|property named '%s'",                 G_STRFUNC,                 GEGL_OPERATION_GET_CLASS (context->operation)->name,                 property_name);    }  /* if the value already exists in the context it will be reused */  storage = gegl_operation_context_add_value (context, property_name, G_PARAM_SPEC_VALUE_TYPE(pspec));  /* storage needs to have the correct type */  g_value_copy (value, storage);}

static VALUEvalue_convert(int argc, VALUE* argv, VALUE self){    GParamSpec* pspec = rbgobj_get_param_spec(self);    VALUE src, strict_validation;    VALUE src_type;    VALUE result = Qnil;    GValue src_value = {0,};    GValue dest_value = {0,};    gboolean b;    rb_scan_args(argc, argv, "21", &src, &src_type, &strict_validation);    /* FIXME: use rb_ensure to ensure following g_value_unset() call*/    g_value_init(&src_value, rbgobj_gtype_get(src_type));    g_value_init(&dest_value, G_PARAM_SPEC_VALUE_TYPE(pspec));    rbgobj_rvalue_to_gvalue(src, &src_value);    b = g_param_value_convert(rbgobj_get_param_spec(self),                              &src_value, &dest_value,                              RVAL2CBOOL(strict_validation));    if (b)        result = rbgobj_gvalue_to_rvalue(&dest_value);    g_value_unset(&src_value);    g_value_unset(&dest_value);    if (b)        return result;    else        rb_raise(rb_eTypeError, "can't convert");}

/* Cell packing parsing */static voidgtk_cell_layout_buildable_set_cell_property (GtkCellArea     *area,					     GtkBuilder      *builder,					     GtkCellRenderer *cell,					     gchar           *name,					     const gchar     *value){  GParamSpec *pspec;  GValue gvalue = G_VALUE_INIT;  GError *error = NULL;  pspec = gtk_cell_area_class_find_cell_property (GTK_CELL_AREA_GET_CLASS (area), name);  if (!pspec)    {      g_warning ("%s does not have a property called %s",		 g_type_name (G_OBJECT_TYPE (area)), name);      return;    }  if (!gtk_builder_value_from_string (builder, pspec, value, &gvalue, &error))    {      g_warning ("Could not read property %s:%s with value %s of type %s: %s",		 g_type_name (G_OBJECT_TYPE (area)),		 name,		 value,		 g_type_name (G_PARAM_SPEC_VALUE_TYPE (pspec)),		 error->message);      g_error_free (error);      return;    }  gtk_cell_area_cell_set_property (area, cell, name, &gvalue);  g_value_unset (&gvalue);}

static voidcheck_property (const char *output,	        GParamSpec *pspec,		GValue *value){  GValue default_value = G_VALUE_INIT;  char *v, *dv, *msg;  if (g_param_value_defaults (pspec, value))      return;  g_value_init (&default_value, G_PARAM_SPEC_VALUE_TYPE (pspec));  g_param_value_set_default (pspec, &default_value);  v = g_strdup_value_contents (value);  dv = g_strdup_value_contents (&default_value);  msg = g_strdup_printf ("%s %s.%s: %s != %s/n",			 output,			 g_type_name (pspec->owner_type),			 pspec->name,			 dv, v);  g_assertion_message (G_LOG_DOMAIN, __FILE__, __LINE__,		       G_STRFUNC, msg);  g_free (msg);  g_free (v);  g_free (dv);  g_value_unset (&default_value);}

static void *vips_object_equal_arg( VipsObject *object,	GParamSpec *pspec,	VipsArgumentClass *argument_class,	VipsArgumentInstance *argument_instance,	void *a, void *b ){	VipsObject *other = (VipsObject *) a;	if( (argument_class->flags & VIPS_ARGUMENT_CONSTRUCT) &&		(argument_class->flags & VIPS_ARGUMENT_INPUT) &&		argument_instance->assigned ) {		const char *name = g_param_spec_get_name( pspec );		GType type = G_PARAM_SPEC_VALUE_TYPE( pspec );		GValue v1 = { 0, };		GValue v2 = { 0, };		gboolean equal;		g_value_init( &v1, type );		g_value_init( &v2, type );		g_object_get_property( G_OBJECT( object ), name, &v1 ); 		g_object_get_property( G_OBJECT( other ), name, &v2 ); 		equal = vips_value_equal( pspec, &v1, &v2 );		g_value_unset( &v1 );		g_value_unset( &v2 );		if( !equal )			return( object );	}	return( NULL );}

/** * clutter_container_child_get: * @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. * * Gets @container specific properties of an actor. * * In general, a copy is made of the property contents and the caller is * responsible for freeing the memory in the appropriate manner for the type, for * instance by calling free() or g_object_unref(). * * Since: 0.8 */voidclutter_container_child_get (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: container '%s' has no child property named '%s'",                     G_STRLOC, G_OBJECT_TYPE_NAME (container), name);          break;        }      if (!(pspec->flags & G_PARAM_READABLE))        {          g_warning ("%s: child property '%s' of container '%s' is not readable",                     G_STRLOC, pspec->name, G_OBJECT_TYPE_NAME (container));          break;        }      g_value_init (&value, G_PARAM_SPEC_VALUE_TYPE (pspec));      container_get_child_property (container, actor, &value, pspec);      G_VALUE_LCOPY (&value, var_args, 0, &error);      if (error)        {          g_warning ("%s: %s", G_STRLOC, error);          free (error);          g_value_unset (&value);          break;        }      g_value_unset (&value);      name = va_arg (var_args, gchar*);    }  va_end (var_args);}

/** * ags_parameter_grow: * @object_type: the #GType of the object's properties * @params: the #GParameter array * @n_params: location to store new size * @...: a %NULL-terminated list of properties name and value *  * Grow parameter array of @object_type object. This function is mainly used to * prepare a #GParameter array to instantiate a new #GObject by using g_object_newv(). * * Returns: the resized GParameter array * * Since: 2.0.0 */GParameter*ags_parameter_grow(GType object_type,		   GParameter *params, guint *n_params, ...){  //Thank you gimp  GObjectClass *object_class;  gchar *param_name;  va_list ap;  object_class = g_type_class_ref (object_type);  va_start(ap, n_params);  param_name = va_arg (ap, gchar *);  while (param_name)    {      gchar *error;      GParamSpec *pspec;      error = NULL;      pspec = g_object_class_find_property(object_class,					   param_name);      if (! pspec)        {          g_warning ("%s: object class `%s' has no property named `%s'",                     G_STRFUNC, g_type_name (object_type), param_name);          break;        }      if(params != NULL){	params = g_renew (GParameter, params, *n_params + 1);      }else{	params = g_new(GParameter, 1);      }      params[*n_params].name         = param_name;      params[*n_params].value.g_type = 0;      g_value_init (&params[*n_params].value, G_PARAM_SPEC_VALUE_TYPE (pspec));      G_VALUE_COLLECT (&params[*n_params].value, ap, 0, &error);      if (error)        {          g_warning ("%s: %s", G_STRFUNC, error);          g_free (error);          g_value_unset (&params[*n_params].value);          break;        }      *n_params = *n_params + 1;      param_name = va_arg (ap, gchar *);    }  return(params);}

static voidgst_xvidenc_init (GstXvidEnc * xvidenc){  GParamSpec **pspecs;  guint i, num_props;  /* create the sink pad */  xvidenc->sinkpad = gst_pad_new_from_static_template (&sink_template, "sink");  gst_element_add_pad (GST_ELEMENT (xvidenc), xvidenc->sinkpad);  gst_pad_set_chain_function (xvidenc->sinkpad,      GST_DEBUG_FUNCPTR (gst_xvidenc_chain));  gst_pad_set_setcaps_function (xvidenc->sinkpad,      GST_DEBUG_FUNCPTR (gst_xvidenc_setcaps));  gst_pad_set_getcaps_function (xvidenc->sinkpad,      GST_DEBUG_FUNCPTR (gst_xvidenc_getcaps));  gst_pad_set_event_function (xvidenc->sinkpad,      GST_DEBUG_FUNCPTR (gst_xvidenc_handle_sink_event));  /* create the src pad */  xvidenc->srcpad = gst_pad_new_from_static_template (&src_template, "src");  gst_element_add_pad (GST_ELEMENT (xvidenc), xvidenc->srcpad);  gst_pad_use_fixed_caps (xvidenc->srcpad);  /* init properties. */  xvidenc->width = xvidenc->height = xvidenc->csp = -1;  xvidenc->par_width = xvidenc->par_height = 1;  /* set defaults for user properties */  pspecs = g_object_class_list_properties (G_OBJECT_GET_CLASS (xvidenc),      &num_props);  for (i = 0; i < num_props; ++i) {    GValue val = { 0, };    GParamSpec *pspec = pspecs[i];    /* only touch those that are really ours; i.e. should have some qdata */    if (!g_param_spec_get_qdata (pspec, xvidenc_pspec_quark))      continue;    g_value_init (&val, G_PARAM_SPEC_VALUE_TYPE (pspec));    g_param_value_set_default (pspec, &val);    g_object_set_property (G_OBJECT (xvidenc), g_param_spec_get_name (pspec),        &val);    g_value_unset (&val);  }  g_free (pspecs);  /* set xvid handle to NULL */  xvidenc->handle = NULL;  /* get a queue to keep time info if frames get delayed */  xvidenc->delay = NULL;  /* cache some xvid data so need not rebuild for each frame */  xvidenc->xframe_cache = NULL;}

/** * tidy_stylable_set_property: * @stylable: a #TidyStylable * @property_name: the name of the property to set * @value: an initialized #GValue * * Sets the property @property_name with @value. */voidtidy_stylable_set_property (TidyStylable *stylable,                            const gchar  *property_name,                            const GValue *value){  GObjectNotifyQueue *nqueue;  GParamSpec *pspec;  g_return_if_fail (TIDY_IS_STYLABLE (stylable));  g_return_if_fail (property_name != NULL);  g_return_if_fail (value != NULL);  g_object_ref (stylable);  nqueue = g_object_notify_queue_freeze (G_OBJECT (stylable),                                         &property_notify_context);  pspec = tidy_stylable_find_property (stylable, property_name);  if (!pspec)    {      g_warning ("Stylable class `%s' doesn't have a property named `%s'",                 g_type_name (G_OBJECT_TYPE (stylable)),                 property_name);    }  else if (!(pspec->flags & G_PARAM_WRITABLE))    {      g_warning ("Style property `%s' of class `%s' is not readable",                 pspec->name,                 g_type_name (G_OBJECT_TYPE (stylable)));    }  else if (G_VALUE_TYPE (value) != G_PARAM_SPEC_VALUE_TYPE (pspec))    {      g_warning ("Passed value is not of the requested type `%s' for "                 "the style property `%s' of class `%s'",                 g_type_name (G_PARAM_SPEC_VALUE_TYPE (pspec)),                 pspec->name,                 g_type_name (G_OBJECT_TYPE (stylable)));    }  else    tidy_stylable_set_property_internal (stylable, pspec, value, nqueue);  g_object_notify_queue_thaw (G_OBJECT (stylable), nqueue);  g_object_unref (stylable);}