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);
}
