JSObject* gjs_param_from_g_param(JSContext *context, GParamSpec *gparam) { JSObject *obj; Param *priv; if (gparam == NULL) return NULL; gjs_debug(GJS_DEBUG_GPARAM, "Wrapping %s '%s' on %s with JSObject", g_type_name(G_TYPE_FROM_INSTANCE((GTypeInstance*) gparam)), gparam->name, g_type_name(gparam->owner_type)); JS::RootedObject proto(context, gjs_lookup_param_prototype(context)); obj = JS_NewObjectWithGivenProto(context, JS_GetClass(proto), proto); GJS_INC_COUNTER(param); priv = g_slice_new0(Param); JS_SetPrivate(obj, priv); priv->gparam = gparam; g_param_spec_ref (gparam); gjs_debug(GJS_DEBUG_GPARAM, "JSObject created with param instance %p type %s", priv->gparam, g_type_name(G_TYPE_FROM_INSTANCE((GTypeInstance*) priv->gparam))); return obj; }
/* --- functions --- */ void _bst_skin_config_init (void) { BstSkinConfig *skin_config; GValue *value; SfiRec *rec; g_return_if_fail (global_skin_config == NULL); /* global config record description */ pspec_skin_config = sfi_pspec_rec ("beast-skin-config-v1", NULL, NULL, bst_skin_config_fields, SFI_PARAM_STANDARD); g_param_spec_ref (pspec_skin_config); g_param_spec_sink (pspec_skin_config); /* create empty config record */ rec = sfi_rec_new (); value = sfi_value_rec (rec); /* fill out missing values with defaults */ g_param_value_validate (pspec_skin_config, value); /* install global config */ skin_config = bst_skin_config_from_rec (rec); global_skin_config = skin_config; /* cleanup */ sfi_value_free (value); sfi_rec_unref (rec); }
GParamSpec* g_param_spec_value_array (const gchar *name, const gchar *nick, const gchar *blurb, GParamSpec *element_spec, GParamFlags flags) { GParamSpecValueArray *aspec; if (element_spec) g_return_val_if_fail (G_IS_PARAM_SPEC (element_spec), NULL); aspec = g_param_spec_internal (G_TYPE_PARAM_VALUE_ARRAY, name, nick, blurb, flags); if (element_spec) { aspec->element_spec = g_param_spec_ref (element_spec); g_param_spec_sink (element_spec); } return G_PARAM_SPEC (aspec); }
/* Register stylable property of a class */ void xfdashboard_actor_install_stylable_property(XfdashboardActorClass *klass, GParamSpec *inParamSpec) { GParamSpec *stylableParamSpec; g_return_if_fail(XFDASHBOARD_IS_ACTOR_CLASS(klass)); g_return_if_fail(G_IS_PARAM_SPEC(inParamSpec)); g_return_if_fail(inParamSpec->flags & G_PARAM_WRITABLE); g_return_if_fail(!(inParamSpec->flags & G_PARAM_CONSTRUCT_ONLY)); /* Check if param-spec is already registered */ if(g_param_spec_pool_lookup(_xfdashboard_actor_stylable_properties_pool, g_param_spec_get_name(inParamSpec), G_OBJECT_CLASS_TYPE(klass), FALSE)) { g_warning("Class '%s' already contains a stylable property '%s'", G_OBJECT_CLASS_NAME(klass), g_param_spec_get_name(inParamSpec)); return; } /* Add param-spec to pool of themable properties */ stylableParamSpec=g_param_spec_internal(G_PARAM_SPEC_TYPE(inParamSpec), g_param_spec_get_name(inParamSpec), NULL, NULL, 0); g_param_spec_set_qdata_full(stylableParamSpec, XFDASHBOARD_ACTOR_PARAM_SPEC_REF, g_param_spec_ref(inParamSpec), (GDestroyNotify)g_param_spec_unref); g_param_spec_pool_insert(_xfdashboard_actor_stylable_properties_pool, stylableParamSpec, G_OBJECT_CLASS_TYPE(klass)); XFDASHBOARD_DEBUG(NULL, STYLE, "Registered stylable property '%s' for class '%s'", g_param_spec_get_name(inParamSpec), G_OBJECT_CLASS_NAME(klass)); }
/* Get parameter specification of stylable properties and add them to hashtable. * If requested do it recursively over all parent classes. */ static void _xfdashboard_actor_hashtable_get_all_stylable_param_specs(GHashTable *ioHashtable, GObjectClass *inClass, gboolean inRecursive) { GList *paramSpecs, *entry; GObjectClass *parentClass; /* Get list of all parameter specification registered for class */ paramSpecs=g_param_spec_pool_list_owned(_xfdashboard_actor_stylable_properties_pool, G_OBJECT_CLASS_TYPE(inClass)); for(entry=paramSpecs; entry; entry=g_list_next(entry)) { GParamSpec *paramSpec=G_PARAM_SPEC(entry->data); /* Only add parameter specification which aren't already in hashtable */ if(paramSpec && !g_hash_table_lookup_extended(ioHashtable, g_param_spec_get_name(paramSpec), NULL, NULL)) { g_hash_table_insert(ioHashtable, g_strdup(g_param_spec_get_name(paramSpec)), g_param_spec_ref(paramSpec)); } } g_list_free(paramSpecs); /* Call us recursive for parent class if it exists and requested */ parentClass=g_type_class_peek_parent(inClass); if(inRecursive && parentClass) _xfdashboard_actor_hashtable_get_all_stylable_param_specs(ioHashtable, parentClass, inRecursive); }
static gboolean transition_add_property (AfTransition *transition, GParamSpec *pspec, GValue *to, AfTypeTransformationFunc func) { AfPropertyRange property_range = { 0, }; if (G_VALUE_TYPE (to) != pspec->value_type) { g_warning ("Target value type (%s) do not match property type (%s)", G_VALUE_TYPE_NAME (to), g_type_name (pspec->value_type)); return FALSE; } property_range.pspec = g_param_spec_ref (pspec); g_value_init (&property_range.to, pspec->value_type); g_value_copy (to, &property_range.to); g_array_append_val (transition->properties, property_range); transition->func = func; return TRUE; }
/** * ppg_animation_add_property: * @animation: (in): A #PpgAnimation. * @pspec: (in): A #ParamSpec of @target or a #GtkWidget<!-- -->'s parent. * @value: (in): The new value for the property at the end of the animation. * * Adds a new property to the set of properties to be animated during the * lifetime of the animation. * * Returns: None. * Side effects: None. */ void ppg_animation_add_property (PpgAnimation *animation, GParamSpec *pspec, const GValue *value) { PpgAnimationPrivate *priv; Tween tween = { 0 }; GType type; g_return_if_fail(PPG_IS_ANIMATION(animation)); g_return_if_fail(pspec != NULL); g_return_if_fail(value != NULL); g_return_if_fail(value->g_type); g_return_if_fail(animation->priv->target); g_return_if_fail(!animation->priv->tween_handler); priv = animation->priv; type = G_TYPE_FROM_INSTANCE(priv->target); tween.is_child = !g_type_is_a(type, pspec->owner_type); if (tween.is_child) { if (!GTK_IS_WIDGET(priv->target)) { g_critical("Cannot locate property %s in class %s", pspec->name, g_type_name(type)); return; } } tween.pspec = g_param_spec_ref(pspec); g_value_init(&tween.begin, pspec->value_type); g_value_init(&tween.end, pspec->value_type); g_value_copy(value, &tween.end); g_array_append_val(priv->tweens, tween); }
void Property::set_gobject_pspec(GObject *object, GParamSpec *pspec) { if(nullptr != object_) { g_warning("trying to set gobject pspec twice, not setting"); return; } g_param_spec_ref(pspec); g_object_ref(object); property_ = pspec; object_ = object; }
void rbgobj_param_spec_initialize(VALUE self, GParamSpec *pspec) { pspec_holder* holder; Data_Get_Struct(self, pspec_holder, holder); pspec = g_param_spec_ref(pspec); g_param_spec_sink(pspec); holder->instance = pspec; holder->cinfo = GTYPE2CINFO(G_PARAM_SPEC_TYPE(pspec)); g_param_spec_set_qdata(pspec, qparamspec, (gpointer)self); }
void gegl_pad_set_param_spec (GeglPad *self, GParamSpec *param_spec) { g_return_if_fail (GEGL_IS_PAD (self)); if (self->param_spec) g_param_spec_unref (self->param_spec); self->param_spec = g_param_spec_ref (param_spec); gegl_pad_set_name (self, g_param_spec_get_name (param_spec)); }
void gimp_procedure_add_return_value (GimpProcedure *procedure, GParamSpec *pspec) { g_return_if_fail (GIMP_IS_PROCEDURE (procedure)); g_return_if_fail (G_IS_PARAM_SPEC (pspec)); procedure->values = g_renew (GParamSpec *, procedure->values, procedure->num_values + 1); procedure->values[procedure->num_values] = pspec; g_param_spec_ref (pspec); g_param_spec_sink (pspec); procedure->num_values++; }
static gboolean _lookup_child (GESTimelineElement * self, const gchar * prop_name, GObject ** child, GParamSpec ** pspec) { GHashTableIter iter; gpointer key, value; gchar **names, *name, *classename; gboolean res; classename = NULL; res = FALSE; names = g_strsplit (prop_name, "::", 2); if (names[1] != NULL) { classename = names[0]; name = names[1]; } else name = names[0]; g_hash_table_iter_init (&iter, self->priv->children_props); while (g_hash_table_iter_next (&iter, &key, &value)) { if (g_strcmp0 (G_PARAM_SPEC (key)->name, name) == 0) { ChildPropHandler *handler = (ChildPropHandler *) value; if (classename == NULL || g_strcmp0 (G_OBJECT_TYPE_NAME (G_OBJECT (handler->child)), classename) == 0) { GST_DEBUG_OBJECT (self, "The %s property from %s has been found", name, classename); if (child) *child = gst_object_ref (handler->child); if (pspec) *pspec = g_param_spec_ref (key); res = TRUE; break; } } } g_strfreev (names); return res; }
static PropValue * prop_value_new (GstVaapiEncoderPropInfo * prop) { static const GValue default_value = G_VALUE_INIT; PropValue *prop_value; if (!prop || !prop->pspec) return NULL; prop_value = g_slice_new (PropValue); if (!prop_value) return NULL; prop_value->id = prop->prop; prop_value->pspec = g_param_spec_ref (prop->pspec); memcpy (&prop_value->value, &default_value, sizeof (prop_value->value)); g_value_init (&prop_value->value, prop->pspec->value_type); g_param_value_set_default (prop->pspec, &prop_value->value); return prop_value; }
/** * gst_param_spec_fraction: * @name: canonical name of the property specified * @nick: nick name for the property specified * @blurb: description of the property specified * @min_num: minimum value (fraction numerator) * @min_denom: minimum value (fraction denominator) * @max_num: maximum value (fraction numerator) * @max_denom: maximum value (fraction denominator) * @default_num: default value (fraction numerator) * @default_denom: default value (fraction denominator) * @flags: flags for the property specified * * This function creates a fraction GParamSpec for use by objects/elements * that want to expose properties of fraction type. This function is typically * used in connection with g_object_class_install_property() in a GObjects's * instance_init function. * * Returns: a newly created parameter specification * * Since: 0.10.14 */ GParamSpec * gst_param_spec_fraction (const gchar * name, const gchar * nick, const gchar * blurb, gint min_num, gint min_denom, gint max_num, gint max_denom, gint default_num, gint default_denom, GParamFlags flags) { GstParamSpecFraction *fspec; GParamSpec *pspec; GValue default_val = { 0, }; fspec = g_param_spec_internal (GST_TYPE_PARAM_FRACTION, name, nick, blurb, flags); fspec->min_num = min_num; fspec->min_den = min_denom; fspec->max_num = max_num; fspec->max_den = max_denom; fspec->def_num = default_num; fspec->def_den = default_denom; pspec = G_PARAM_SPEC (fspec); /* check that min <= default <= max */ g_value_init (&default_val, GST_TYPE_FRACTION); gst_value_set_fraction (&default_val, default_num, default_denom); /* validate returns TRUE if the validation fails */ if (_gst_param_fraction_validate (pspec, &default_val)) { g_critical ("GstParamSpec of type 'fraction' for property '%s' has a " "default value of %d/%d, which is not within the allowed range of " "%d/%d to %d/%d", name, default_num, default_denom, min_num, min_denom, max_num, max_denom); g_param_spec_ref (pspec); g_param_spec_sink (pspec); g_param_spec_unref (pspec); pspec = NULL; } g_value_unset (&default_val); return pspec; }
/** * gst_vaapi_param_spec_id: * @name: canonical name of the property specified * @nick: nick name for the property specified * @blurb: description of the property specified * @default_value: default value * @flags: flags for the property specified * * This function creates an ID GParamSpec for use by #GstVaapiObject * objects. This function is typically used in connection with * g_object_class_install_property() in a GObjects's instance_init * function. * * Return value: a newly created parameter specification */ GParamSpec * gst_vaapi_param_spec_id( const gchar *name, const gchar *nick, const gchar *blurb, GstVaapiID default_value, GParamFlags flags ) { GstVaapiParamSpecID *ispec; GParamSpec *pspec; GValue value = { 0, }; ispec = g_param_spec_internal( GST_VAAPI_TYPE_PARAM_ID, name, nick, blurb, flags ); if (!ispec) return NULL; ispec->default_value = default_value; pspec = G_PARAM_SPEC(ispec); /* Validate default value */ g_value_init(&value, GST_VAAPI_TYPE_ID); gst_vaapi_value_set_id(&value, default_value); if (gst_vaapi_param_id_validate(pspec, &value)) { g_param_spec_ref(pspec); g_param_spec_sink(pspec); g_param_spec_unref(pspec); pspec = NULL; } g_value_unset(&value); return pspec; }
/** * goo_canvas_item_model_class_install_child_property: * @mclass: a #GObjectClass * @property_id: the id for the property * @pspec: the #GParamSpec for the property * * This function is only intended to be used when implementing new canvas * item models, specifically layout container item models such as * #GooCanvasTableModel. * * It installs a child property on a canvas item class. **/ void goo_canvas_item_model_class_install_child_property (GObjectClass *mclass, guint property_id, GParamSpec *pspec) { g_return_if_fail (G_IS_OBJECT_CLASS (mclass)); g_return_if_fail (G_IS_PARAM_SPEC (pspec)); g_return_if_fail (property_id > 0); if (g_param_spec_pool_lookup (_goo_canvas_item_model_child_property_pool, pspec->name, G_OBJECT_CLASS_TYPE (mclass), FALSE)) { g_warning (G_STRLOC ": class `%s' already contains a child property named `%s'", G_OBJECT_CLASS_NAME (mclass), pspec->name); return; } g_param_spec_ref (pspec); g_param_spec_sink (pspec); pspec->param_id = property_id; g_param_spec_pool_insert (_goo_canvas_item_model_child_property_pool, pspec, G_OBJECT_CLASS_TYPE (mclass)); }
/* Find and add parameter specification of a stylable property to hashtable */ gboolean xfdashboard_stylable_add_stylable_property(XfdashboardStylable *self, GHashTable *ioStylableProperties, const gchar *inProperty) { GParamSpec *spec; g_return_val_if_fail(XFDASHBOARD_IS_STYLABLE(self), FALSE); /* Find property in instance */ spec=g_object_class_find_property(G_OBJECT_GET_CLASS(self), inProperty); if(!spec) { g_warning(_("Could not find property '%s' for class %s"), inProperty, G_OBJECT_TYPE_NAME(self)); return(FALSE); } /* Add parameter specification of found property to hashtable */ g_hash_table_insert(ioStylableProperties, g_strdup(inProperty), g_param_spec_ref(spec)); return(TRUE); }
/* --- functions --- */ void _bst_msg_absorb_config_init (void) { g_return_if_fail (global_msg_absorb_config == NULL); /* global config record description */ pspec_msg_absorb_config = sfi_pspec_seq ("beast-msg-absorb-config-v1", NULL, NULL, sfi_pspec_rec ("mstring", NULL, NULL, bst_msg_absorb_string_fields, SFI_PARAM_STANDARD), SFI_PARAM_STANDARD); g_param_spec_ref (pspec_msg_absorb_config); g_param_spec_sink (pspec_msg_absorb_config); /* create empty config record */ SfiSeq *seq = sfi_seq_new (); GValue *value = sfi_value_seq (seq); /* fill out missing values with defaults */ g_param_value_validate (pspec_msg_absorb_config, value); /* install global config */ BstMsgAbsorbStringSeq *mconfig = bst_msg_absorb_string_seq_from_seq (seq); global_msg_absorb_config = mconfig; /* cleanup */ sfi_value_free (value); sfi_seq_unref (seq); }